deep-cover 0.1.14 → 0.1.15

data/exe/deep-cover

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 require 'deep_cover/cli/deep_cover'

data/lib/deep-cover.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'deep_cover'

data/lib/deep_cover.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/MixinUsage (See https://github.com/bbatsov/rubocop/issues/5055)
 module DeepCover
   require 'parser'
   require 'term/ansicolor'

data/lib/deep_cover/analyser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'node'
 require_relative 'covered_code'
 

data/lib/deep_cover/analyser/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   module Analyser::Base
     attr_reader :source, :options

data/lib/deep_cover/analyser/branch.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require_relative 'subset'
 
 module DeepCover
   class Analyser::Branch < Analyser
     include Analyser::Subset
-    SUBSET_CLASSES = [Node::Branch]
+    SUBSET_CLASSES = [Node::Branch].freeze
 
     def results
       each_node.map do |node, _children|
-        branches_runs = node.branches.map{|b| [b, node_runs(b)]}.to_h
+        branches_runs = node.branches.map { |b| [b, node_runs(b)] }.to_h
         [node, branches_runs]
       end.to_h
     end

data/lib/deep_cover/analyser/covered_code_source.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module DeepCover
   class Analyser::CoveredCodeSource < Analyser
     attr_reader :covered_code
 
     def initialize(covered_code)
-      @covered_code = covered_code
+      @covered_code = covered_code.freeze
     end
 
     # Looking exclusively at our subset of nodes, returns the node's direct descendants

data/lib/deep_cover/analyser/function.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require_relative 'subset'
 
 module DeepCover
   class Analyser::Function < Analyser
     include Analyser::Subset
-    SUBSET_CLASSES = [Node::Block, Node::Defs, Node::Def]
+    SUBSET_CLASSES = [Node::Block, Node::Defs, Node::Def].freeze
 
     def node_runs(node)
       super(node.body)

data/lib/deep_cover/analyser/ignore_uncovered.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module DeepCover
   module Analyser::IgnoreUncovered
     def initialize(source, ignore_uncovered: [], **options)
       super
       @allow_filters = Array(ignore_uncovered)
-        .map{|kind| :"is_#{kind}?"}
-        .select{|name| respond_to?(name) }
-        .map{|name| method(name)}   # So was tempted to write `.map(&method(:method))`!
+                       .map { |kind| :"is_#{kind}?" }
+                       .select { |name| respond_to?(name) }
+                       .map { |name| method(name) } # So was tempted to write `.map(&method(:method))`!
     end
 
     def node_runs(node)
       runs = super
-      if runs == 0 && @allow_filters.any?{ |f| f[node] }
+      if runs == 0 && @allow_filters.any? { |f| f[node] }
         runs = nil
       end
       runs

data/lib/deep_cover/analyser/node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   class Analyser::Node < Analyser
     def is_raise?(node)
@@ -14,6 +16,7 @@ module DeepCover
     end
 
     protected
+
     def convert(node, **)
       Analyser::CoveredCodeSource.new(node)
     end

data/lib/deep_cover/analyser/optionally_covered.rb

@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 module DeepCover
   module Analyser::OptionallyCovered
     def optionally_covered
       @optionally_covered ||= Analyser
-        .constants.map{|c| Analyser.const_get(c)}
-        .select{|klass| klass < Analyser }
-        .flat_map do |klass|
-          klass.instance_methods(false).map {|m| m.match(/^is_(.*)\?$/); $1 }
-        end
-        .compact
-        .map(&:to_sym)
+                              .constants.map { |c| Analyser.const_get(c) }
+                              .select { |klass| klass < Analyser }
+                              .flat_map do |klass|
+                                klass.instance_methods(false).map do |method|
+                                  method =~ /^is_(.*)\?$/
+                                  Regexp.last_match(1)
+                                end
+                              end
+                              .compact
+                              .map(&:to_sym)
     end
   end
 end

data/lib/deep_cover/analyser/per_char.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 module DeepCover
   class Analyser::PerChar < Analyser
     # Returns an array of characters for each line of code.
     # Each character is either ' ' (executed), '-' (not executable) or 'x' (not covered)
     def results
       buffer = covered_code.buffer
-      bc = buffer.source_lines.map{|line| '-' * line.size}
+      bc = buffer.source_lines.map { |line| '-' * line.size }
       each_node do |node, _children|
         runs = node_runs(node)
-        if runs != nil
-          node.proper_range.each do |pos|
-            bc[buffer.line_for_position(pos)-buffer.first_line][buffer.column_for_position(pos)] = runs > 0 ? ' ' : 'x'
-          end
+        next if runs == nil
+        node.proper_range.each do |pos|
+          bc[buffer.line_for_position(pos) - buffer.first_line][buffer.column_for_position(pos)] = runs > 0 ? ' ' : 'x'
         end
       end
-      bc.zip(buffer.source_lines){|cov, line| cov[line.size..-1] = ''} # remove extraneous character for end lines, in any
+      bc.zip(buffer.source_lines) { |cov, line| cov[line.size..-1] = '' } # remove extraneous character for end lines, in any
       bc
     end
   end

data/lib/deep_cover/analyser/per_line.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   class Analyser::PerLine < Analyser
     # Returns an array of runs, one per line.
@@ -5,15 +7,14 @@ module DeepCover
       disallow_partial = !options.fetch(:allow_partial, true)
       line_hits = Array.new(covered_code.nb_lines + covered_code.lineno - 1)
       each_node do |node, _children|
-        if (runs = node_runs(node))
-          node.executed_locs.each do |loc|
-            lineno = loc.line - 1
-            if disallow_partial
-              line_hits[lineno] = 0 if runs == 0
-              next if line_hits[lineno] == 0
-            end
-            line_hits[lineno] = [line_hits[lineno] || 0, runs].max
+        next unless (runs = node_runs(node))
+        node.executed_locs.each do |loc|
+          lineno = loc.line - 1
+          if disallow_partial
+            line_hits[lineno] = 0 if runs == 0
+            next if line_hits[lineno] == 0
           end
+          line_hits[lineno] = [line_hits[lineno] || 0, runs].max
         end
       end
 

data/lib/deep_cover/analyser/statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'subset'
 
 module DeepCover

data/lib/deep_cover/analyser/subset.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   # A module to create a subset from a criteria called `in_subset?`
   # Including classes can refine it, or specify SUBSET_CLASSES
@@ -7,6 +9,7 @@ module DeepCover
     end
 
     private
+
     def find_children(from, parent = from)
       @source.node_children(from).flat_map do |node|
         if in_subset?(node, parent)
@@ -18,7 +21,7 @@ module DeepCover
     end
 
     def in_subset?(node, _parent)
-      self.class::SUBSET_CLASSES.any?{|klass| node.is_a?(klass)}
+      self.class::SUBSET_CLASSES.any? { |klass| node.is_a?(klass) }
     end
   end
 end

data/lib/deep_cover/auto_run.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'deep_cover'
 require 'pry'
 
@@ -15,6 +17,7 @@ module DeepCover
       end
 
       private
+
       def detect
         Coverage.saved? @covered_path
       end

data/lib/deep_cover/autoload_tracker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'weakref'
 
 module DeepCover
@@ -10,7 +12,7 @@ module DeepCover
       ext = File.extname(path)
       # We don't care about .so files
       return if ext == '.so'
-      path = path + '.rb' if ext != '.rb'
+      path += '.rb' if ext != '.rb'
 
       pairs = @autoloaded_paths[path] ||= []
       pairs << [WeakRef.new(const), name]
@@ -21,7 +23,7 @@ module DeepCover
 
       paths.flat_map do |path|
         pairs = @autoloaded_paths[path] || []
-        pairs = pairs.map{|weak_const, name| [self.class.value_from_weak_ref(weak_const), name] }
+        pairs = pairs.map { |weak_const, name| [self.class.value_from_weak_ref(weak_const), name] }
         pairs.select!(&:first)
         pairs
       end
@@ -49,9 +51,10 @@ module DeepCover
 
     def initialize_autoloaded_paths
       @autoloaded_paths = {}
+      # This is only used on MRI, so ObjectSpace is alright.
       ObjectSpace.each_object(Module) do |mod|
         mod.constants.each do |name|
-          if path = mod.autoload?(name)
+          if (path = mod.autoload?(name))
             add(mod, name, path)
           end
         end

data/lib/deep_cover/backports.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # We use a few features newer than our target of Ruby 2.0+:
 class Module
   public :prepend # Public in Ruby 2.1+.

data/lib/deep_cover/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   module Base
     def start
@@ -35,12 +37,19 @@ module DeepCover
       stop
     end
 
+    def config_changed(what)
+      if what == :paths
+        warn "Changing DeepCover's paths after starting coverage is highly discouraged" if @started
+        @custom_requirer = nil
+      end
+    end
+
     def coverage
       @coverage ||= Coverage.new
     end
 
     def custom_requirer
-      @custom_requirer ||= CustomRequirer.new
+      @custom_requirer ||= CustomRequirer.new(lookup_paths: config.paths)
     end
 
     def autoload_tracker
@@ -49,7 +58,7 @@ module DeepCover
 
     def handle_relative_filename(filename)
       unless Pathname.new(filename).absolute?
-        relative_to = File.dirname(caller[1].partition(/\.rb:\d/).first)
+        relative_to = File.dirname(caller(2..2).first.partition(/\.rb:\d/).first)
         filename = File.absolute_path(filename, relative_to)
       end
       filename += '.rb' unless filename =~ /\.rb$/

data/lib/deep_cover/builtin_takeover.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require_relative '../deep_cover'
 require_relative '../deep_cover/core_ext/coverage_replacement'

data/lib/deep_cover/cli/debugger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   module CLI
     class Debugger
@@ -6,15 +8,15 @@ module DeepCover
       module ColorAST
         def fancy_type
           color = case
-          when !executable?
-            :faint
-          when !was_executed?
-            :red
-          when flow_interrupt_count > 0
-            :yellow
-          else
-            :green
-          end
+                  when !executable?
+                    :faint
+                  when !was_executed?
+                    :red
+                  when flow_interrupt_count > 0
+                    :yellow
+                  else
+                    :green
+                  end
           Term::ANSIColor.send(color, super)
         end
       end
@@ -29,46 +31,51 @@ module DeepCover
       end
 
       def show
-        execute
-        if @debug
-          show_line_coverage
-          show_instrumented_code
-          show_ast
+        Tools.profile(options[:profile]) do
+          execute
+          covered_code.freeze # Our output relies on the counts, so better freeze. See [#13]
+          if @debug
+            show_line_coverage
+            show_instrumented_code
+            show_ast
+          end
+          show_char_coverage
         end
-        show_char_coverage
         pry if @debug
         finish
       end
 
       def show_line_coverage
-        puts "Line Coverage: Builtin | DeepCover | DeepCover Strict:\n"
+        output { "Line Coverage: Builtin | DeepCover | DeepCover Strict:\n" }
         begin
           builtin_line_coverage = builtin_coverage(@source, @filename, @lineno)
           our_line_coverage = our_coverage(@source, @filename, @lineno, **options)
           our_strict_line_coverage = our_coverage(@source, @filename, @lineno, allow_partial: false, **options)
-          lines = format(builtin_line_coverage, our_line_coverage, our_strict_line_coverage, source: @source)
-          puts number_lines(lines, lineno: @lineno)
+          output do
+            lines = format(builtin_line_coverage, our_line_coverage, our_strict_line_coverage, source: @source)
+            number_lines(lines, lineno: @lineno)
+          end
         rescue Exception => e
-          puts "Can't run coverage: #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"
+          output { "Can't run coverage: #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}" }
           @failed = true
         end
       end
 
       def show_instrumented_code
-        puts "\nInstrumented code:\n"
-        puts format_generated_code(covered_code)
+        output { "\nInstrumented code:\n" }
+        output { format_generated_code(covered_code) }
       end
 
       def show_ast
-        puts "\nParsed code:\n"
+        output { "\nParsed code:\n" }
         Node.prepend ColorAST
-        puts covered_code.covered_ast
+        output { covered_code.covered_ast }
       end
 
       def show_char_coverage
-        puts "\nChar coverage:\n"
+        output { "\nChar coverage:\n" }
 
-        puts format_char_cover(covered_code, show_whitespace: !!ENV['W'], **options)
+        output { format_char_cover(covered_code, show_whitespace: !!ENV['W'], **options) }
       end
 
       def pry
@@ -86,11 +93,29 @@ module DeepCover
       end
 
       def execute
-        begin
-          execute_sample(covered_code)
-        rescue Exception => e
-          puts "Can't `execute_sample`:#{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"
-          @failed = true
+        execute_sample(covered_code)
+        # output { trace_counts }  # Keep for low-level debugging purposes
+      rescue Exception => e
+        output { "Can't `execute_sample`:#{e.class.name}: #{e}\n#{e.backtrace.join("\n")}" }
+        @failed = true
+      end
+
+      def trace_counts
+        all = []
+        trace = TracePoint.new(:call) do |tr|
+          if %i[flow_entry_count flow_completion_count execution_count].include? tr.method_id
+            node = tr.self
+            str = "#{node.type} #{(node.value if node.respond_to?(:value))} #{tr.method_id}"
+            all << str unless all.last == str
+          end
+        end
+        trace.enable { covered_code.freeze }
+        all
+      end
+
+      def output
+        Tools.dont_profile do
+          puts yield
         end
       end
     end