deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/node/short_circuit.rb

@@ -18,8 +18,8 @@ module DeepCover
         ]
       end
 
-      def branches_summary(of = branches)
-        of.map do |jump|
+      def branches_summary(of_branches = branches)
+        of_branches.map do |jump|
           if jump == conditional
             'left-hand side'
           else
@@ -27,8 +27,16 @@ module DeepCover
           end
         end.join(' and ')
       end
+
+      def operator
+        loc_hash[:operator].source.to_sym
+      end
     end
 
-    And = Or = ShortCircuit
+    class And < ShortCircuit
+    end
+
+    class Or < ShortCircuit
+    end
   end
 end

data/lib/deep_cover/parser_ext/range.rb

@@ -1,37 +1,21 @@
 # frozen_string_literal: true
 
 class Parser::Source::Range
-  # (1...10).split(2...3, 6...8) => [1...2, 3...6, 7...10]
-  # Assumes inner_ranges are exclusive, and included in self
-  def split(*inner_ranges)
-    inner_ranges.sort_by!(&:begin_pos)
-    [self.begin, *inner_ranges, self.end]
-      .each_cons(2)
-      .map { |i, j| with(begin_pos: i.end_pos, end_pos: j.begin_pos) }
-      .reject(&:empty?)
+  def succ
+    adjust(begin_pos: +1, end_pos: +1)
   end
 
-  def lstrip(pattern = /\s*/)
-    if (match = /^#{pattern}/.match(source))
-      with(begin_pos: @begin_pos + match[0].length)
-    else
-      self
-    end
+  def wrap_rwhitespace
+    whitespace = @source_buffer.slice(end_pos..-1)[/\A\s+/] || ''
+    adjust(end_pos: whitespace.size)
   end
 
-  def rstrip(pattern = /\s*/)
-    if (match = /#{pattern}$/.match(source))
-      with(end_pos: @end_pos - match[0].length)
-    else
-      self
+  def wrap_rwhitespace_and_comments
+    current = wrap_rwhitespace
+    while @source_buffer.slice(current.end_pos) == '#'
+      comment = @source_buffer.slice(current.end_pos..-1)[/\A[^\n]+/] || ''
+      current = current.adjust(end_pos: comment.size).wrap_rwhitespace
     end
-  end
-
-  def strip(pattern = /\s*/)
-    lstrip(pattern).rstrip(pattern)
-  end
-
-  def succ
-    adjust(begin_pos: +1, end_pos: +1)
+    current
   end
 end

data/lib/deep_cover/problem_with_diagnostic.rb

@@ -38,7 +38,7 @@ module DeepCover
       lines.concat(source_lines.map { |line| "   #{line}" })
       if original_exception
         lines << 'Original exception:'
-        lines << "  #{original_exception.class.name}: #{original_exception.message}"
+        lines << "  #{original_exception.class}: #{original_exception.message}"
         backtrace = Tools.truncate_backtrace(original_exception)
         lines.concat(backtrace.map { |line| "    #{line}" })
       end

data/lib/deep_cover/reporter.rb

@@ -6,6 +6,5 @@ module DeepCover
   module Reporter
   end
   require_relative 'node'
-  require_relative_dir 'reporter/util'
   require_relative_dir 'reporter'
 end

data/lib/deep_cover/reporter/base.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Reporter
+    require_relative 'tree/util'
+
+    class Base
+      include Memoize
+      memoize :map, :tree, :root_path
+
+      attr_reader :options
+
+      def initialize(coverage, **options)
+        @coverage = coverage
+        @options = options
+      end
+
+      def analysis
+        @analysis ||= Coverage::Analysis.new(@coverage.covered_codes, **options)
+      end
+
+      def each(&block)
+        return to_enum :each unless block_given?
+        @coverage.each do |covered_code|
+          yield relative_path(covered_code.path), covered_code
+        end
+        self
+      end
+
+      # Same as populate, but also yields data, which is either the analysis data (for leaves)
+      # of the sum of the children (for subtrees)
+      def populate_stats
+        return to_enum(__method__) unless block_given?
+        Tree::Util.populate_from_map(
+            tree: tree,
+            map: map,
+            merge: ->(child_data) { Tools.merge(*child_data, :+) }
+        ) do |full_path, partial_path, data, children|
+          yield relative_path(full_path), relative_path(partial_path), data, children
+        end
+      end
+
+      private
+
+      def relative_path(path)
+        path = path.to_s
+        path = path.slice(root_path.length + 1..-1) if path.start_with?(root_path)
+        path
+      end
+
+      def root_path
+        return '' if tree.size > 1
+        path = tree.first.first
+        root = File.dirname(path)
+        root = File.dirname(root) if File.basename(path) == 'dir'
+        root
+      end
+
+      def map
+        analysis.stat_map.transform_keys(&:path).transform_keys(&:to_s)
+      end
+
+      def tree
+        Tree::Util.paths_to_tree(map.keys)
+      end
+    end
+  end
+end

data/lib/deep_cover/reporter/html.rb

@@ -8,7 +8,7 @@ module DeepCover
   module Reporter::HTML
     class << self
       def report(coverage, **options)
-        Site.save(coverage.covered_codes, **options)
+        Site.save(coverage, **options)
       end
     end
   end

data/lib/deep_cover/reporter/html/index.rb

@@ -4,17 +4,13 @@ module DeepCover
   require_relative 'base'
 
   module Reporter
-    class HTML::Index < Struct.new(:analysis, :options)
-      def initialize(analysis, **options)
-        raise ArgumentError unless analysis.is_a? Coverage::Analysis
-        super
-      end
-
-      include Util::Tree
+    class HTML::Index < Struct.new(:base)
       include HTML::Base
+      extend Forwardable
+      def_delegators :base, :analysis, :options, :populate_stats
 
       def stats_to_data
-        populate_stats(analysis) do |full_path, partial_path, data, children|
+        populate_stats do |full_path, partial_path, data, children|
           data = transform_data(data)
           if children.empty?
             {

data/lib/deep_cover/reporter/html/site.rb

@@ -1,23 +1,15 @@
 # frozen_string_literal: true
 
 module DeepCover
+  require_relative 'base'
   require_relative 'index'
   require_relative 'source'
 
   module Reporter::HTML
-    class Site < Struct.new(:covered_codes, :options)
-      def initialize(covered_codes, **options)
-        raise ArgumentError unless covered_codes.all? { |c| c.is_a? CoveredCode }
-        super
-      end
-
+    class Site < Reporter::Base
       include Memoize
       memoize :analysis
 
-      def analysis
-        Coverage::Analysis.new(covered_codes, **options)
-      end
-
       def path
         Pathname(options[:output])
       end
@@ -42,7 +34,7 @@ module DeepCover
       end
 
       def render_index
-        Tools.render_template(:index, Index.new(analysis, **options))
+        Tools.render_template(:index, Index.new(self))
       end
 
       def save_index
@@ -58,20 +50,20 @@ module DeepCover
         dest.join('deep_cover.css.sass').delete
       end
 
-      def render_source(covered_code)
-        Tools.render_template(:source, Source.new(analysis.analyser_map.fetch(covered_code)))
+      def render_source(partial_path, covered_code)
+        Tools.render_template(:source, Source.new(analysis.analyser_map.fetch(covered_code), partial_path))
       end
 
       def save_pages
-        covered_codes.each do |covered_code|
-          dest = path.join("#{covered_code.name}.html")
+        each do |partial_path, covered_code|
+          dest = path.join("#{partial_path}.html")
           dest.dirname.mkpath
-          dest.write(render_source(covered_code))
+          dest.write(render_source(partial_path, covered_code))
         end
       end
 
-      def self.save(covered_codes, output:, **options)
-        Site.new(covered_codes, output: output, **options).save
+      def self.save(coverage, output:, **options)
+        Site.new(coverage, output: output, **options).save
       end
     end
   end

data/lib/deep_cover/reporter/html/source.rb

@@ -4,10 +4,10 @@ module DeepCover
   module Reporter
     require_relative 'base'
 
-    class HTML::Source < Struct.new(:analyser_map)
+    class HTML::Source < Struct.new(:analyser_map, :partial_path)
       include Tools::Covered
 
-      def initialize(analyser_map)
+      def initialize(analyser_map, partial_path)
         raise ArgumentError unless analyser_map.values.all? { |a| a.is_a?(Analyser) }
         super
       end
@@ -33,7 +33,7 @@ module DeepCover
       end
 
       def root_path
-        Pathname('.').relative_path_from(Pathname(covered_code.name).dirname)
+        Pathname('.').relative_path_from(Pathname(partial_path).dirname)
       end
 
       def stats

data/lib/deep_cover/reporter/html/template/source.html.erb

@@ -19,7 +19,7 @@
         </div>
         <div class="nav">
           <a href="index.html" aria-label="Home"><i class="fa fa-home" aria-hidden="true"></i></a>
-          <span class="path"><%= covered_code.name %><span>
+          <span class="path"><%= partial_path %><span>
         </div>
       </div>
     </header>

data/lib/deep_cover/reporter/istanbul.rb

@@ -4,8 +4,7 @@ require 'json'
 
 module DeepCover
   module Reporter
-    class Istanbul < Struct.new(:covered_code, :options)
-      # Converters has no dependency on the including class.
+    class Istanbul < Base
       module Converters
         def convert_range(range)
           {start: {
@@ -68,83 +67,114 @@ module DeepCover
           }
         end
       end
-      include Converters
 
-      def node_analyser
-        @node_analyser ||= Analyser::Node.new(covered_code, **options)
-      end
+      class CoveredCodeConverter < Struct.new(:covered_code, :options)
+        include Converters
 
-      def node_runs
-        @node_runs ||= node_analyser.results
-      end
+        def node_analyser
+          @node_analyser ||= Analyser::Node.new(covered_code, **options)
+        end
 
-      def functions
-        @functions ||= Analyser::Function.new(node_analyser, **options).results
-      end
+        def node_runs
+          @node_runs ||= node_analyser.results
+        end
 
-      def statements
-        @statements ||= Analyser::Statement.new(node_analyser, **options).results
-      end
+        def functions
+          @functions ||= Analyser::Function.new(node_analyser, **options).results
+        end
 
-      def branches
-        @branches ||= Analyser::Branch.new(node_analyser, **options).results
-      end
+        def statements
+          @statements ||= Analyser::Statement.new(node_analyser, **options).results
+        end
 
-      def branch_map
-        branches.map do |node, branches_runs|
-          convert_branch(node, branches_runs.keys)
+        def branches
+          @branches ||= Analyser::Branch.new(node_analyser, **options).results
         end
-      end
 
-      # Istanbul doesn't understand how to ignore a branch...
-      def zero_to_something(values)
-        values.map { |v| v || 1 }
-      end
+        def branch_map
+          branches.map do |node, branches_runs|
+            convert_branch(node, branches_runs.keys)
+          end
+        end
 
-      def branch_runs
-        branches.values.map { |r| zero_to_something(r.values) }
-      end
+        # Istanbul doesn't understand how to ignore a branch...
+        def zero_to_something(values)
+          values.map { |v| v || 1 }
+        end
 
-      def statement_map
-        statements.keys.map { |range| convert_range(range) }
-      end
+        def branch_runs
+          branches.values.map { |r| zero_to_something(r.values) }
+        end
 
-      def statement_runs
-        statements.values
-      end
+        def statement_map
+          statements.keys.map { |range| convert_range(range) }
+        end
 
-      def function_map
-        functions.keys.map { |n| convert_function(n) }
-      end
+        def statement_runs
+          statements.values
+        end
 
-      def function_runs
-        functions.values
-      end
+        def function_map
+          functions.keys.map { |n| convert_function(n) }
+        end
+
+        def function_runs
+          functions.values
+        end
 
-      def data
-        {
-          statementMap: statement_map,
-          s:            statement_runs,
-          fnMap:        function_map,
-          f:            function_runs,
-          branchMap:    branch_map,
-          b:            branch_runs,
-        }
+        def data
+          {
+            statementMap: statement_map,
+            s:            statement_runs,
+            fnMap:        function_map,
+            f:            function_runs,
+            branchMap:    branch_map,
+            b:            branch_runs,
+          }
+        end
+
+        def convert
+          {
+            path: covered_code.path,
+            **data.transform_values { |l| convert_list(l) },
+          }
+        end
       end
 
       def convert
-        {covered_code.name => {
-                                path: covered_code.path,
-                                **data.transform_values { |l| convert_list(l) },
-                              },
-}
+        each.to_a.to_h.transform_values  do |covered_code|
+          CoveredCodeConverter.new(covered_code, **@options).convert
+        end
+      end
+
+      def save(dir: '.', name: '.nyc_output')
+        path = Pathname.new(dir).expand_path.join(name)
+        path.mkpath
+        path.each_child(&:delete)
+        path.join('deep_cover.json').write(JSON.pretty_generate(convert))
+        path
       end
 
       def report
-        convert.to_json
+        output = @options[:output]
+        dir = save.dirname
+        unless [nil, false, '', 'false'].include? output
+          output = File.expand_path(output)
+          html = "--reporter=html --report-dir='#{output}'"
+          if @options[:open]
+            html += " && open '#{output}/index.html'"
+          else
+            msg = "\nHTML coverage written to: '#{output}/index.html'"
+          end
+        end
+        `cd #{dir} && nyc report --reporter=text #{html}` + msg.to_s
       end
 
       class << self
+        def report(coverage, **options)
+          new(coverage, options).report
+        end
+
         def available?
           `nyc --version` >= '11.' rescue false
         end