deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/reporter/text.rb

@@ -1,18 +1,10 @@
 # frozen_string_literal: true
 
 module DeepCover
-  module Reporter
-    class Text
-      include Util::Tree
-      def initialize(coverage, **options)
-        @coverage = coverage
-        @options = options
-      end
-
-      def analysis
-        Coverage::Analysis.new(@coverage.covered_codes, **@options)
-      end
+  require_relative 'base'
 
+  module Reporter
+    class Text < Base
       INDENT = '  '
       def report
         formatted_headings = headings.map.with_index { |h, i| {value: h, alignment: :center} }
@@ -24,7 +16,7 @@ module DeepCover
             style: {border_bottom: false, border_top: false, alignment: :right},
         )
         table.align_column 0, :left
-        table.render
+        table.render + "\n\nOverall: #{analysis.overall}%"
       end
 
       def self.report(coverage, **options)
@@ -43,7 +35,7 @@ module DeepCover
       end
 
       def rows
-        populate_stats(analysis).map do |full_path, partial_path, data, children|
+        populate_stats.map do |full_path, partial_path, data, children|
           [partial_path, *transform_data(data)]
         end
       end

data/lib/deep_cover/reporter/{util/tree.rb → tree/util.rb}

@@ -2,9 +2,26 @@
 
 module DeepCover
   module Reporter
-    module Util
+    class Tree
       # Utility functions to deal with trees
-      module Tree
+      module Util
+        extend self
+
+        def populate_from_map(tree:, map:, merge:)
+          return to_enum(__method__, tree: tree, map: map, merge: merge) unless block_given?
+          final_results, _final_data = populate(tree) do |full_path, partial_path, children|
+            if children.empty?
+              data = map.fetch(full_path)
+            else
+              child_results, child_data = children.transpose
+              data = merge.call(child_data)
+            end
+            result = yield full_path, partial_path, data, child_results || []
+            [result, data]
+          end.transpose
+          final_results
+        end
+
         def paths_to_tree(paths)
           twigs = paths.map do |path|
             partials = path_to_partial_paths(path)
@@ -63,25 +80,6 @@ module DeepCover
             yield full_path, path, children
           end
         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(analysis)
-          return to_enum(__method__, analysis) unless block_given?
-          map = Tools.transform_keys(analysis.stat_map, &:name)
-          tree = paths_to_tree(map.keys)
-          final_results, _final_data = populate(tree) do |full_path, partial_path, children|
-            if children.empty?
-              data = map[full_path]
-            else
-              child_results, child_data = children.transpose
-              data = Tools.merge(*child_data, :+)
-            end
-            result = yield full_path, partial_path, data, child_results || []
-            [result, data]
-          end.transpose
-          final_results
-        end
       end
     end
   end

data/lib/deep_cover/tools/blank.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::Blank
+    BLANK_RE = /\A[[:space:]]*\z/
+
+    # Homemade poor-man's blank?
+    # Based, but modified, on https://github.com/rails/rails/blob/5-0-stable/activesupport/lib/active_support/core_ext/object/blank.rb
+    def blank?(obj)
+      if obj.is_a?(String)
+        obj.empty? || obj =~ BLANK_RE
+      else
+        obj.respond_to?(:empty?) ? !!obj.empty? : !obj
+      end
+    end
+
+    def present?(obj)
+      !blank?(obj)
+    end
+
+    def presence(obj)
+      obj if present?(obj)
+    end
+  end
+end

data/lib/deep_cover/tools/builtin_coverage.rb

@@ -2,22 +2,22 @@
 
 module DeepCover
   module Tools::BuiltinCoverage
-    def builtin_coverage(source, fn, lineno)
+    def builtin_coverage(source, filename, lineno)
       require 'coverage'
-      fn = File.absolute_path(File.expand_path(fn))
+      filename = File.absolute_path(File.expand_path(filename))
       ::Coverage.start
       Tools.silence_warnings do
-        execute_sample -> { run_with_line_coverage(source, fn, lineno) }
+        execute_sample -> { run_with_line_coverage(source, filename, lineno) }
       end
-      unshift_coverage(::Coverage.result.fetch(fn), lineno)
+      unshift_coverage(::Coverage.result.fetch(filename), lineno)
     end
 
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
       # Executes the source as if it was in the specified file while
       # builtin coverage information is still captured
-      def run_with_line_coverage(source, fn = nil, lineno = 1)
+      def run_with_line_coverage(source, filename = nil, lineno = 1)
         source = shift_source(source, lineno)
-        Object.to_java.getRuntime.executeScript(source, fn)
+        Object.to_java.getRuntime.executeScript(source, filename)
       end
     else
       # In ruby 2.0 and 2.1, using 2, 3 or 4 as lineno with RubyVM::InstructionSequence.compile
@@ -32,9 +32,9 @@ module DeepCover
 
       # Executes the source as if it was in the specified file while
       # builtin coverage information is still captured
-      def run_with_line_coverage(source, fn = nil, lineno = 1)
+      def run_with_line_coverage(source, filename = nil, lineno = 1)
         source = shift_source(source, lineno)
-        RubyVM::InstructionSequence.compile(source, fn).eval
+        RubyVM::InstructionSequence.compile(source, filename).eval
       end
     end
 

data/lib/deep_cover/tools/dump_covered_code.rb

@@ -5,22 +5,15 @@ module DeepCover
     require 'with_progress'
   end
   module Tools::DumpCoveredCode
-    def dump_covered_code_and_save(source_path, dest_path: Dir.mktmpdir)
-      coverage = Coverage.new(tracker_global: '$_sc')
-      dump_covered_code(source_path, coverage: coverage, dest_path: dest_path)
-      coverage.save(dest_path)
-    end
-
-    def dump_covered_code(source_path, coverage:, dest_path: Dir.mktmpdir, root_path: source_path)
+    def dump_covered_code(source_path, coverage:, dest_path: Dir.mktmpdir)
       source_path = File.join(File.expand_path(source_path), '')
       dest_path = File.join(File.expand_path(dest_path), '')
-      root_path = Pathname.new(root_path)
       skipped = []
       file_paths = Dir.glob("#{source_path}**/*.rb").select { |p| File.file?(p) }
       file_paths.each.with_progress(title: 'Rewriting') do |path|
         new_path = Pathname(path.gsub(source_path, dest_path))
         begin
-          covered_code = coverage.covered_code(path, name: new_path.relative_path_from(root_path))
+          covered_code = coverage.covered_code(path)
         rescue Parser::SyntaxError
           skipped << path
           next

data/lib/deep_cover/tools/execute_sample.rb

@@ -2,8 +2,11 @@
 
 module DeepCover
   module Tools::ExecuteSample
+    class ExceptionInSample < StandardError
+    end
+
     # Returns true if the code would have continued, false if the rescue was triggered.
-    def execute_sample(to_execute)
+    def execute_sample(to_execute, source: nil)
       # Disable some annoying warning by ruby. We are testing edge cases, so warnings are to be expected.
       Tools.silence_warnings do
         if to_execute.is_a?(CoveredCode)
@@ -13,11 +16,19 @@ module DeepCover
         end
       end
       true
-    rescue RuntimeError => e
-      # In our samples, a simple `raise` doesn't need to be rescued
-      # Other exceptions are not rescued
-      raise unless e.message.empty?
-      false
+    rescue StandardError => e
+      # In our samples, a simple `raise` is expected and doesn't need to be rescued
+      return false if e.is_a?(RuntimeError) && e.message.empty?
+
+      source = to_execute.covered_source if to_execute.is_a?(CoveredCode)
+      raise unless source
+
+      inner_msg = Tools.indent_string("#{e.class.name}: #{e.message}", 4)
+      source = Tools.indent_string(source, 4)
+      msg = "Exception when executing the sample:\n#{inner_msg}\n*Code follows*\n#{source}"
+      new_exc = ExceptionInSample.new(msg)
+      new_exc.set_backtrace(e.backtrace)
+      raise new_exc
     end
   end
 end

data/lib/deep_cover/tools/format_generated_code.rb

@@ -15,7 +15,7 @@ module DeepCover
       inserts.each do |exp_limit, size|
         # Line index starts at 1, so array index returns the next line
         comment_line = generated_lines[exp_limit.line]
-        next unless comment_line.present?
+        next if Tools.blank?(comment_line)
         next unless comment_line.start_with?('#>')
         next if comment_line.start_with?('#>X')
         next unless comment_line.size >= exp_limit.column

data/lib/deep_cover/tools/indent_string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::IndentString
+    # In-place implementation copied from active-support.
+    IMPLEMENTATION = ->(amount, indent_string = nil, indent_empty_lines = false) do
+      indent_string = indent_string || self[/^[ \t]/] || ' '
+      re = indent_empty_lines ? /^/ : /^(?!$)/
+      gsub!(re, indent_string * amount)
+    end
+
+    # Same as #indent! from active-support
+    # https://github.com/rails/rails/blob/10e1f1f9a129f2f197a44009a99b73b8ff9dbc0d/activesupport/lib/active_support/core_ext/string/indent.rb#L7
+    def indent_string!(string, *args)
+      string.instance_exec(*args, &IMPLEMENTATION)
+    end
+
+    # Same as #indent from active-support
+    # https://github.com/rails/rails/blob/10e1f1f9a129f2f197a44009a99b73b8ff9dbc0d/activesupport/lib/active_support/core_ext/string/indent.rb#L42
+    def indent_string(string, *args)
+      string = string.dup
+      indent_string!(string, *args)
+      string
+    end
+  end
+end

data/lib/deep_cover/tools/our_coverage.rb

@@ -2,8 +2,8 @@
 
 module DeepCover
   module Tools::OurCoverage
-    def our_coverage(source, fn, lineno, **options)
-      covered_code = CoveredCode.new(source: source, path: fn, lineno: lineno)
+    def our_coverage(source, filename, lineno, **options)
+      covered_code = CoveredCode.new(source: source, path: filename, lineno: lineno)
       Tools.execute_sample(covered_code)
       covered_code.line_coverage(options)[(lineno - 1)..-1]
     end

data/lib/deep_cover/tools/strip_heredoc.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::StripHeredoc
+    # In-place implementation copied from active-support.
+    IMPLEMENTATION = -> do
+      gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, ''.freeze).tap do |stripped|
+        stripped.freeze if frozen?
+      end
+    end
+
+    # Same as #strip_heredoc from active-support
+    # https://github.com/rails/rails/blob/16574409f813e2197f88e4a06b527618d64d9ff0/activesupport/lib/active_support/core_ext/string/strip.rb#L22
+    def strip_heredoc(string)
+      string.instance_exec(&IMPLEMENTATION)
+    end
+  end
+end

data/lib/deep_cover/tracker_bucket.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  require_relative 'tracker_storage'
+
+  # A holder for TrackerStorages, using some `global_name`.
+  class TrackerBucket
+    @@index = {}
+
+    def self.[](global_name)
+      raise ArgumentError, "'#{global_name}' is not a valid global name" unless global_name.start_with? '$'
+      @@index[global_name] ||= new(global_name)
+    end
+
+    def setup_source
+      "#{source} ||= {}"
+    end
+
+    def source
+      @global_name
+    end
+
+    class << self
+      alias_method :_load, :[]
+      private :_load, :new
+    end
+
+    def inspect
+      %{#<DeepCover::TrackerBucket "#{@global_name}">}
+    end
+
+    def create_storage(index = nil)
+      index ||= @global.size
+      TrackerStorage.new(bucket: self, array: @global[index] ||= [], index: index)
+    end
+
+    private
+
+    def initialize(global_name)
+      @global_name = global_name
+      @global = eval(setup_source) # rubocop:disable Security/Eval
+    end
+
+    def _dump(_level)
+      @global_name
+    end
+  end
+end

data/lib/deep_cover/tracker_hits_per_path.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # Should be seen as a hash like {path => tracker_hits, ...},
+  # where tracker_hits is simply an array of integers returned from
+  # TrackerStorage#tracker_hits.
+  # Make it easier to separate some concerns, as well as marshalling.
+  #
+  class TrackerHitsPerPath
+    extend Forwardable
+    def_delegators :@index, :each, :each_key, :map, :transform_values, :to_h, :to_hash
+
+    def initialize(index = {})
+      @index = index
+    end
+
+    def [](val)
+      @index[val] ||= []
+    end
+
+    def merge!(tracker_hits_per_path)
+      @index.merge!(tracker_hits_per_path) { |_h, actual, to_merge| merge_tracker_hits(actual, to_merge) }
+      self
+    end
+
+    private def merge_tracker_hits(hits, to_merge)
+      unless hits.size == to_merge.size
+        raise "Attempting to merge trackers of different sizes: #{hits.size} vs #{to_merge.size}"
+      end
+      hits.map!.with_index { |val, i| val + to_merge[i] }
+    end
+  end
+end

data/lib/deep_cover/tracker_storage.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # List of allocated trackers from a bucket.
+  # Should be thought of as a simple array of integers with
+  # a limited interface.
+  class TrackerBucket
+    class TrackerStorage
+      extend Forwardable
+      def_delegators :@array, :[], :size, :each, :map, :fetch
+
+      attr_reader :bucket
+
+      def initialize(bucket:, array:, index:)
+        @bucket = bucket
+        @array = array
+        @index = index
+        @allocated = 0
+      end
+
+      # Returns a range of tracker ids
+      def allocate_trackers(nb_needed)
+        prev = @allocated
+        @allocated += nb_needed
+        missing = @allocated - @array.size
+        @array.concat(Array.new(missing, 0)) if missing > 0
+        prev...@allocated
+      end
+
+      def setup_source
+        "(#{bucket.setup_source})[#{@index}]||=Array.new(#{size},0)"
+      end
+
+      def tracker_source(tracker_id)
+        "#{bucket.source}[#{@index}][#{tracker_id}]+=1"
+      end
+
+      def tracker_hits
+        @array.dup.freeze
+      end
+
+      def tracker_hits=(new_hits)
+        if new_hits.size != @array.size
+          warn 'Replacing tracker hits with array of different size'
+        end
+        @array.replace(new_hits)
+      end
+
+      private
+
+      def dump
+        {bucket: @bucket, index: @index, size: @array.size}
+      end
+
+      def _dump(_level)
+        Marshal.dump(dump)
+      end
+
+      class << self
+        private def load(bucket:, index:, size:)
+          storage = bucket.create_storage(index)
+          storage.allocate_trackers(size - storage.size)
+          storage
+        end
+
+        private def _load(data)
+          load(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+        end
+      end
+    end
+
+    private_constant :TrackerStorage
+  end
+end