deep-cover 0.1.16 → 0.2.0

data/lib/deep_cover/coverage/istanbul.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Coverage::Istanbul
+    def to_istanbul(**options)
+      map do |covered_code|
+        next {} unless covered_code.has_executed?
+        covered_code.to_istanbul(**options)
+      end.inject(:merge)
+    end
+
+    def output_istanbul(dir: '.', name: '.nyc_output', **options)
+      path = Pathname.new(dir).expand_path.join(name)
+      path.mkpath
+      path.each_child(&:delete)
+      path.join('deep_cover.json').write(JSON.pretty_generate(to_istanbul(**options)))
+      path
+    end
+
+    def report_istanbul(output: nil, **options)
+      dir = output_istanbul(**options).dirname
+      unless [nil, '', '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
+  end
+end

data/lib/deep_cover/coverage/persistence.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require 'securerandom'
+  class Coverage::Persistence
+    # rubocop:disable Security/MarshalLoad
+    BASENAME = 'coverage.dc'
+    TRACKER_TEMPLATE = 'trackers%{unique}.dct'
+
+    attr_reader :dir_path
+    def initialize(dest_path, dirname)
+      @dir_path = Pathname(dest_path).join(dirname).expand_path
+    end
+
+    def load(with_trackers: true)
+      saved?
+      load_trackers if with_trackers
+      load_coverage
+    end
+
+    def save(coverage)
+      create_if_needed
+      delete_trackers
+      save_coverage(coverage)
+    end
+
+    def save_trackers(global)
+      saved?
+      trackers = eval(global) # rubocop:disable Security/Eval
+      # Some testing involves more than one process, some of which don't run any of our covered code.
+      # Don't save anything if that's the case
+      return if trackers.nil?
+      basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
+      dir_path.join(basename).binwrite(Marshal.dump(
+                                           version: DeepCover::VERSION,
+                                           global: global,
+                                           trackers: trackers,
+      ))
+    end
+
+    def saved?
+      raise "Can't find folder '#{dir_path}'" unless dir_path.exist?
+      self
+    end
+
+    private
+
+    def create_if_needed
+      dir_path.mkpath
+    end
+
+    def save_coverage(coverage)
+      dir_path.join(BASENAME).binwrite(Marshal.dump(
+                                           version: DeepCover::VERSION,
+                                           coverage: coverage,
+      ))
+    end
+
+    def load_coverage
+      Marshal.load(dir_path.join(BASENAME).binread).tap do |version: raise, coverage: raise|
+        raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
+        return coverage
+      end
+    end
+
+    def load_trackers
+      tracker_files.each do |full_path|
+        Marshal.load(full_path.binread).tap do |version: raise, global: raise, trackers: raise|
+          raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
+          merge_trackers(eval("#{global} ||= {}"), trackers) # rubocop:disable Security/Eval
+        end
+      end
+    end
+
+    def merge_trackers(hash, to_merge)
+      hash.merge!(to_merge) do |_key, current, to_add|
+        unless current.empty? || current.size == to_add.size
+          warn "Merging trackers of different sizes: #{current.size} vs #{to_add.size}"
+        end
+        to_add.zip(current).map { |a, b| a + b }
+      end
+    end
+
+    def tracker_files
+      basename = format(TRACKER_TEMPLATE, unique: '*')
+      Pathname.glob(dir_path.join(basename))
+    end
+
+    def delete_trackers
+      tracker_files.each(&:delete)
+    end
+  end
+end

data/lib/deep_cover/covered_code.rb

@@ -12,11 +12,11 @@ module DeepCover
       raise 'Must provide either path or source' unless path || source
 
       @buffer = ::Parser::Source::Buffer.new(path, lineno)
-      @buffer.source = source ||= File.read(path)
+      @buffer.source = source || File.read(path)
       @tracker_count = 0
       @tracker_global = tracker_global
       @local_var = local_var
-      @name = name || (source ? '(source)' : File.basename(path))
+      @name = name.to_s || (path ? File.basename(path) : '(source)')
       @covered_source = instrument_source
     end
 
@@ -39,28 +39,23 @@ module DeepCover
 
     def execute_code(binding: DeepCover::GLOBAL_BINDING.dup)
       return if has_executed?
-      global[nb] = Array.new(@tracker_count, 0)
       eval(@covered_source, binding, @buffer.name || '<raw_code>', lineno) # rubocop:disable Security/Eval
       self
     end
 
     def cover
-      must_have_executed
-      global[nb]
+      global[nb] ||= Array.new(@tracker_count, 0)
     end
 
     def line_coverage(**options)
-      must_have_executed
       Analyser::PerLine.new(self, **options).results
     end
 
     def to_istanbul(**options)
-      must_have_executed
       Reporter::Istanbul.new(self, **options).convert
     end
 
     def char_cover(**options)
-      must_have_executed
       Analyser::PerChar.new(self, **options).results
     end
 
@@ -103,18 +98,13 @@ module DeepCover
     end
 
     def instrument_source
-      rewriter = ::Parser::Source::Rewriter.new(@buffer)
+      rewriter = ::Parser::Source::TreeRewriter.new(@buffer)
       covered_ast.each_node(:postorder) do |node|
         node.rewriting_rules.each do |range, rule|
           prefix, _node, suffix = rule.partition('%{node}')
-          unless prefix.empty?
-            prefix = yield prefix, node, range.begin, :prefix if block_given?
-            rewriter.insert_before_multi range, prefix
-          end
-          unless suffix.empty?
-            suffix = yield suffix, node, range.end, :suffix if block_given?
-            rewriter.insert_after_multi  range, suffix
-          end
+          prefix = yield prefix, node, range.begin, :prefix if block_given? && !prefix.empty?
+          suffix = yield suffix, node, range.end, :suffix if block_given? && !suffix.empty?
+          rewriter.wrap(range, prefix, suffix)
         end
       end
       rewriter.process
@@ -126,21 +116,21 @@ module DeepCover
 
     def freeze
       unless frozen? # Guard against reentrance
-        must_have_executed
         super
         root.each_node(&:freeze)
       end
       self
     end
 
+    def inspect
+      %{#<DeepCover::CoveredCode "#{name}">}
+    end
+    alias_method :to_s, :inspect
+
     protected
 
     def global
       @@globals[tracker_global]
     end
-
-    def must_have_executed
-      raise "cover for #{buffer.name} not available, file wasn't executed" unless has_executed?
-    end
   end
 end

data/lib/deep_cover/custom_requirer.rb

@@ -5,6 +5,8 @@
 module DeepCover
   class CustomRequirer
     class LoadPathsSubset
+      attr_reader :last_lookup_path
+
       def initialize(load_paths: raise, lookup_paths: raise)
         @original_load_paths = load_paths
         @cached_load_paths_subset = []
@@ -27,7 +29,7 @@ module DeepCover
 
       # E.g.  '/a/b' => true when a lookup path is '/a/'
       def within_lookup?(full_path)
-        @lookup_paths.any? { |p| full_path.start_with? p }
+        @lookup_paths.any? { |p| full_path.start_with?(p) && @last_lookup_path = p }
       end
 
       def exist?(full_path)
@@ -86,6 +88,7 @@ module DeepCover
     #     It is *NOT* recommended to simply delegate to the default #require, since it
     #     might not be safe to run part of the code again.
     def require(path)
+      path = path.to_s
       ext = File.extname(path)
       throw :use_fallback, :not_supported if ext == '.so'
       path += '.rb' if ext != '.rb'
@@ -128,7 +131,8 @@ module DeepCover
 
     def cover_and_execute(path)
       begin
-        covered_code = DeepCover.coverage.covered_code(path)
+        name = path.sub(%r{^#{@load_paths_subset.last_lookup_path}/}, '') if @load_paths_subset
+        covered_code = DeepCover.coverage.covered_code(path, name: name)
       rescue Parser::SyntaxError => e
         if e.message =~ /contains escape sequences incompatible with UTF-8/
           warn "Can't cover #{path} because of incompatible encoding (see issue #9)"

data/lib/deep_cover/node/base.rb

@@ -36,7 +36,7 @@ module DeepCover
     # Search self and descendants for a particular Class or type
     def find_all(lookup)
       case lookup
-      when ::Class
+      when ::Module
         each_node.grep(lookup)
       when ::Symbol
         each_node.find_all { |n| n.type == lookup }

data/lib/deep_cover/node/case.rb

@@ -51,10 +51,10 @@ module DeepCover
                                 if (after_then = base_node.loc.begin)
                                   after_then.end
                                 else
-                                  base_node.loc.expression.end
+                                  base_node.loc.expression.end.succ
                                 end
                               },
-                rewrite: ';%{body_entry_tracker};%{local}=nil;%{node}',
+                rewrite: '%{body_entry_tracker};%{local}=nil;%{node}',
                 is_statement: true,
                 flow_entry_count: :body_entry_tracker_hits
 
@@ -89,6 +89,17 @@ module DeepCover
         whens.map(&:body) << self.else
       end
 
+      def branches_summary(of = branches)
+        texts = []
+        n = of.size
+        if of.include? self.else
+          texts << "#{'implicit ' unless has_else?}else"
+          n -= 1
+        end
+        texts.unshift "#{n} when clause#{'s' if n > 1}" if n > 0
+        texts.join(' and ')
+      end
+
       def execution_count
         return evaluate.flow_completion_count if evaluate
         flow_entry_count

data/lib/deep_cover/node/exceptions.rb

@@ -10,7 +10,7 @@ module DeepCover
       has_child exception: [Node::Array, nil]
       has_child assignment: [Lvasgn, nil], flow_entry_count: :entered_body_tracker_hits
       has_child body: Node,
-                can_be_empty: -> { base_node.loc.expression.end },
+                can_be_empty: -> { (base_node.loc.begin || base_node.loc.expression.succ).end },
                 flow_entry_count: :entered_body_tracker_hits,
                 is_statement: true,
                 rewrite: '((%{entered_body_tracker};%{local}=nil;%{node}))'
@@ -67,7 +67,7 @@ module DeepCover
                 can_be_empty: -> { base_node.loc.expression.begin },
                 is_statement: true
       has_child ensure: Node,
-                can_be_empty: -> { base_node.loc.expression.end },
+                can_be_empty: -> { base_node.loc.expression.end.succ },
                 is_statement: true,
                 flow_entry_count: -> { body.flow_entry_count }
 

data/lib/deep_cover/node/if.rb

@@ -9,21 +9,36 @@ module DeepCover
       has_tracker :truthy
       has_child condition: Node, rewrite: '((%{node}) && %{truthy_tracker})'
       has_child true_branch: Node,
-                can_be_empty: true,
                 executed_loc_keys: -> { :else if style == :unless },
                 flow_entry_count: :truthy_tracker_hits,
                 is_statement: true
       has_child false_branch: Node,
-                can_be_empty: true,
                 executed_loc_keys: -> { [:else, :colon] if style != :unless },
                 flow_entry_count: -> { condition.flow_completion_count - truthy_tracker_hits },
                 is_statement: true
       executed_loc_keys :keyword, :question
 
+      def child_can_be_empty(child, name)
+        return false if name == :condition || style == :ternary
+        if (name == :true_branch) == (style == :if)
+          (base_node.loc.begin || base_node.children[0].loc.expression.succ).end
+        elsif has_else?
+          base_node.loc.else.end.succ
+        else
+          true # implicit else
+        end
+      end
+
       def branches
         [true_branch, false_branch]
       end
 
+      def branches_summary(of = branches)
+        of.map do |jump|
+          "#{'implicit ' if jump.is_a?(EmptyBody) && !has_else?}#{jump == false_branch ? 'falsy' : 'truthy'} branch"
+        end.join(' and ')
+      end
+
       def execution_count
         condition.flow_completion_count
       end
@@ -33,6 +48,10 @@ module DeepCover
         keyword = loc_hash[:keyword]
         keyword ? keyword.source.to_sym : :ternary
       end
+
+      def has_else?
+        !!base_node.loc.to_hash[:else]
+      end
     end
   end
 end

data/lib/deep_cover/node/mixin/flow_accounting.rb

@@ -36,6 +36,7 @@ module DeepCover
       end
 
       # Returns number of times the node itself was "executed". Definition of executed depends on the node.
+      # For now at least, don't return `nil`, instead return `false` in `executable?`
       def execution_count
         flow_entry_count
       end

data/lib/deep_cover/node/send.rb

@@ -58,6 +58,7 @@ module DeepCover
           arguments.empty? || # No issue when no arguments
           loc_hash[:selector_end] || # No issue with foo[bar]= and such
           loc_hash[:operator] || # No issue with foo.bar=
+          (receiver && !loc_hash[:dot]) || # No issue with foo + bar
           loc_hash[:begin] # Ok if has parentheses
       end
     end
@@ -92,10 +93,16 @@ module DeepCover
       end
 
       def branches
-        [actual_send,
-         TrivialBranch.new(condition: receiver, other_branch: actual_send),
+        [TrivialBranch.new(condition: receiver, other_branch: actual_send),
+         actual_send,
         ]
       end
+
+      def branches_summary(of = branches)
+        of.map do |jump|
+          jump == actual_send ? 'safe send' : 'nil shortcut'
+        end.join(' and ')
+      end
     end
 
     class MatchWithLvasgn < Node

data/lib/deep_cover/node/short_circuit.rb

@@ -17,6 +17,16 @@ module DeepCover
           TrivialBranch.new(condition: lhs, other_branch: conditional),
         ]
       end
+
+      def branches_summary(of = branches)
+        of.map do |jump|
+          if jump == conditional
+            'left-hand side'
+          else
+            "#{type == :and ? 'falsy' : 'truthy'} shortcut"
+          end
+        end.join(' and ')
+      end
     end
 
     And = Or = ShortCircuit

data/lib/deep_cover/parser_ext/range.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 class Parser::Source::Range
-  def with(begin_pos: @begin_pos, end_pos: @end_pos)
-    Parser::Source::Range.new(@source_buffer, begin_pos, end_pos)
-  end
-
   # (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)
@@ -34,4 +30,8 @@ class Parser::Source::Range
   def strip(pattern = /\s*/)
     lstrip(pattern).rstrip(pattern)
   end
+
+  def succ
+    adjust(begin_pos: +1, end_pos: +1)
+  end
 end

data/lib/deep_cover/reporter/html.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeepCover
+  Reporter::HTML = Module.new
+
+  require_relative_dir 'html'
+
+  module Reporter::HTML
+    class << self
+      def report(coverage, **options)
+        Site.save(coverage.covered_codes, **options)
+      end
+    end
+  end
+end