deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/covered_code.rb

@@ -5,26 +5,27 @@ module DeepCover
   load_parser
 
   class CoveredCode
-    attr_accessor :covered_source, :buffer, :tracker_global, :local_var, :name
-    @@counter = 0
-    @@globals = Hash.new { |h, global| h[global] = eval("#{global} ||= {}") } # rubocop:disable Security/Eval
-
-    def initialize(path: nil, source: nil, lineno: 1, tracker_global: DEFAULTS[:tracker_global], local_var: '_temp', name: nil)
+    attr_accessor :covered_source, :buffer, :tracker_storage, :local_var, :path
+
+    def initialize(
+      path: nil,
+      source: nil,
+      lineno: 1,
+      tracker_global: DEFAULTS[:tracker_global],
+      tracker_storage: TrackerBucket[tracker_global].create_storage,
+      local_var: '_temp'
+    )
       raise 'Must provide either path or source' unless path || source
 
-      @buffer = Parser::Source::Buffer.new(path, lineno)
-      @buffer.source = source || File.read(path)
+      @path = path &&= Pathname(path)
+      @buffer = Parser::Source::Buffer.new('', lineno)
+      @buffer.source = source || path.read
       @tracker_count = 0
-      @tracker_global = tracker_global
+      @tracker_storage = tracker_storage
       @local_var = local_var
-      @name = name.to_s || (path ? File.basename(path) : '(source)')
       @covered_source = instrument_source
     end
 
-    def path
-      @buffer.name || "(source: '#{@buffer.source[0..20]}...')"
-    end
-
     def lineno
       @buffer.first_line
     end
@@ -39,8 +40,7 @@ module DeepCover
     end
 
     def execute_code(binding: DeepCover::GLOBAL_BINDING.dup)
-      return if has_executed?
-      eval(@covered_source, binding, @buffer.name || '<raw_code>', lineno) # rubocop:disable Security/Eval
+      eval(@covered_source, binding, (@path || '<raw_code>').to_s, lineno) # rubocop:disable Security/Eval
       self
     end
 
@@ -52,33 +52,10 @@ module DeepCover
       Analyser::PerLine.new(self, **options).results
     end
 
-    def to_istanbul(**options)
-      Reporter::Istanbul.new(self, **options).convert
-    end
-
     def char_cover(**options)
       Analyser::PerChar.new(self, **options).results
     end
 
-    def nb
-      @nb ||= (@@counter += 1)
-    end
-
-    # Returns a range of tracker ids
-    def allocate_trackers(nb_needed)
-      prev = @tracker_count
-      @tracker_count += nb_needed if nb_needed > 0 # Avoid error if frozen and called with 0.
-      prev...@tracker_count
-    end
-
-    def tracker_source(tracker_id)
-      "#{tracker_global}[#{nb}][#{tracker_id}]+=1"
-    end
-
-    def trackers_setup_source
-      "(#{tracker_global}||={})[#{nb}]||=Array.new(#{@tracker_count},0)"
-    end
-
     def tracker_hits(tracker_id)
       cover.fetch(tracker_id)
     end
@@ -116,10 +93,6 @@ module DeepCover
       rewriter.process
     end
 
-    def has_executed?
-      global[nb] != nil
-    end
-
     def freeze
       unless frozen? # Guard against reentrance
         super
@@ -129,16 +102,10 @@ module DeepCover
     end
 
     def inspect
-      %{#<DeepCover::CoveredCode "#{name}">}
+      %{#<DeepCover::CoveredCode "#{path}">}
     end
     alias_method :to_s, :inspect
 
-    protected
-
-    def global
-      @@globals[tracker_global]
-    end
-
     private
 
     def parser

data/lib/deep_cover/custom_requirer.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-# TODO: must handle circular requires
-
 module DeepCover
   class CustomRequirer
     class LoadPathsSubset
-      attr_reader :last_lookup_path
-
       def initialize(load_paths:, lookup_paths:)
         @original_load_paths = load_paths
         @cached_load_paths_subset = []
@@ -29,7 +25,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) && @last_lookup_path = p }
+        @lookup_paths.any? { |p| full_path.start_with?(p) }
       end
 
       def exist?(full_path)
@@ -45,117 +41,182 @@ module DeepCover
       end
     end
 
+    class EveryLoadPaths
+      attr_reader :load_paths
+      def initialize(load_paths)
+        @load_paths = load_paths
+      end
+
+      def exist?(full_path)
+        File.exist?(full_path)
+      end
+
+      def within_lookup?(full_path)
+        true
+      end
+    end
+
     attr_reader :load_paths, :loaded_features, :filter
     def initialize(load_paths: $LOAD_PATH, loaded_features: $LOADED_FEATURES, lookup_paths: nil, &filter)
       @load_paths = load_paths
       lookup_paths ||= Dir.getwd
       lookup_paths = Array(lookup_paths)
-      @load_paths_subset = LoadPathsSubset.new(load_paths: load_paths, lookup_paths: lookup_paths) unless lookup_paths.include? '/'
+
+      if lookup_paths.include?('/')
+        @load_paths_subset = EveryLoadPaths.new(load_paths)
+      else
+        @load_paths_subset = LoadPathsSubset.new(load_paths: load_paths, lookup_paths: lookup_paths)
+      end
+
       @loaded_features = loaded_features
       @filter = filter
+      @paths_being_required = Set.new
     end
 
     # Returns a path to an existing file or nil if none can be found.
-    # The search follows how ruby search for files using the $LOAD_PATH
+    # The search follows how ruby search for files using the $LOAD_PATH, but limits
+    # those it checks based on the LoadPathsSubset.
     #
-    # An absolute path is returned directly if it exists, otherwise nil
-    # is returned without searching anywhere else.
-    def resolve_path(path)
-      path = File.absolute_path(path) if path.start_with?('./', '../')
+    # An absolute path is returned directly if it exists, otherwise nil is returned
+    # without searching anywhere else.
+    def resolve_path(path, extensions_to_try = ['.rb', '.so'])
+      if extensions_to_try
+        extensions_to_try = [''] if extensions_to_try.any? { |ext| path.end_with?(ext) }
+      else
+        extensions_to_try = ['']
+      end
 
       abs_path = File.absolute_path(path)
+      path = abs_path if path.start_with?('./', '../')
+
+      paths_with_ext = extensions_to_try.map { |ext| path + ext }
+
+      # Doing this check in every case instead of only for absolute_path because ruby has some
+      # built-in $LOADED_FEATURES which aren't an absolute path. Ex: enumerator.so, thread.rb
+      paths_with_ext.each do |path_with_ext|
+        return path_with_ext if @loaded_features.include?(path_with_ext)
+      end
+
       if path == abs_path
-        path if (@load_paths_subset || File).exist?(path)
+        paths_with_ext.each do |path_with_ext|
+          return path_with_ext if File.exist?(path_with_ext)
+        end
       else
-        (@load_paths_subset || self).load_paths.each do |load_path|
-          possible_path = File.absolute_path(path, load_path)
+        possible_paths = paths_with_load_paths(paths_with_ext)
+        possible_paths.each do |possible_path|
+          return possible_path if @loaded_features.include?(possible_path)
+        end
 
-          next unless (@load_paths_subset || File).exist?(possible_path)
+        possible_paths.each do |possible_path|
+          next unless File.exist?(possible_path)
           # Ruby 2.5 changed some behaviors of require related to symlinks in $LOAD_PATH
           # https://bugs.ruby-lang.org/issues/10222
           return File.realpath(possible_path) if RUBY_VERSION >= '2.5'
           return possible_path
         end
-        nil
       end
+      nil
     end
 
     # Homemade #require to be able to instrument the code before it gets executed.
     # Returns true when everything went right. (Same as regular ruby)
     # Returns false when the found file was already required. (Same as regular ruby)
-    # Throws :use_fallback in case caller should delegate to the default #require.
-    # Reasons given could be:
+    # Calls &fallback_block with the reason as parameter if the work couldn't be done.
+    # The possible reasons are:
     #  - :not_found if the file couldn't be found.
+    #  - :not_in_covered_paths if the file is not in the paths to cover
     #  - :cover_failed if DeepCover couldn't apply instrumentation the file found.
-    #  - :not_supported for files that are not supported (such as ike .so files)
+    #  - :not_supported for files that are not supported (such as .so files)
     #  - :skipped if the filter block returned `true`
-    # Exceptions raised by the required code bubble up as normal.
-    #     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)
+    # Exceptions raised by the required code bubble up as normal, except for
+    # SyntaxError, which is turned into a :cover_failed which calls the fallback_block.
+    def require(path) # &fallback_block
       path = path.to_s
-      ext = File.extname(path)
-      throw :use_fallback, :not_supported if ext == '.so'
-      path += '.rb' if ext != '.rb'
-      return false if @loaded_features.include?(path)
 
       found_path = resolve_path(path)
 
-      throw :use_fallback, :not_found unless found_path
-      return false if @loaded_features.include?(found_path)
+      if found_path
+        return false if @loaded_features.include?(found_path)
+        return false if @paths_being_required.include?(found_path)
+      end
+
+      DeepCover.autoload_tracker.wrap_require(path, found_path) do
+        # Either a problem with resolve_path, or a gem that will be added to the load_path by RubyGems
+        return yield(:not_found) unless found_path
 
-      throw :use_fallback, :skipped if filter && filter.call(found_path)
+        begin
+          @paths_being_required.add(found_path)
+          return yield(:not_in_covered_paths) unless @load_paths_subset.within_lookup?(found_path)
+          return yield(:not_supported) if found_path.end_with?('.so')
+          return yield(:skipped) if filter && filter.call(found_path)
 
-      cover_and_execute(found_path)
+          cover_and_execute(found_path) { |reason| return yield(reason) }
 
-      @loaded_features << found_path
+          @loaded_features << found_path
+        ensure
+          @paths_being_required.delete(found_path)
+        end
+      end
       true
     end
 
+    ### Not currently used ###
     # Homemade #load to be able to instrument the code before it gets executed.
     # Note, this doesn't support the `wrap` parameter that ruby's #load has.
     # Same return/throw as CustomRequirer#require, except:
     # Cannot return false since #load doesn't care about a file already being executed.
-    def load(path)
-      found_path = resolve_path(path)
+    def load(path) # &fallback_block
+      found_path = resolve_path(path, nil)
 
       if found_path.nil?
         # #load has a final fallback of always trying relative to current work directory of process
         possible_path = File.absolute_path(path)
-        found_path = possible_path if (@load_paths_subset || File).exist?(possible_path)
+        found_path = possible_path if File.exist?(possible_path)
       end
 
-      throw :use_fallback, :not_found unless found_path
+      return yield(:not_found) unless found_path
 
-      cover_and_execute(found_path)
+      cover_and_execute(found_path) { |reason| return yield(reason) }
 
       true
     end
 
+    def is_being_required?(path)
+      found_path = resolve_path(path)
+      @paths_being_required.include?(found_path)
+    end
+
     protected
 
-    def cover_and_execute(path)
+    def paths_with_load_paths(paths)
+      paths.flat_map do |path|
+        @load_paths.map do |load_path|
+          File.absolute_path(path, load_path)
+        end
+      end
+    end
+
+    def cover_and_execute(path) # &fallback_block
       begin
-        name = path.sub(%r{^#{@load_paths_subset.last_lookup_path}/}, '') if @load_paths_subset
-        covered_code = DeepCover.coverage.covered_code(path, name: name)
+        covered_code = DeepCover.coverage.covered_code(path)
       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)"
         else
           warn "The file #{path} can't be instrumented"
         end
-        throw :use_fallback, :cover_failed
+        yield(:cover_failed)
+        raise "The fallback_block is supposed to either return or break, but didn't do either"
       end
-      DeepCover.autoload_tracker.wrap_require(path) do
-        begin
-          covered_code.execute_code
-        rescue ::SyntaxError => e
-          warn ["DeepCover is getting confused with the file #{path} and it won't be instrumented.",
-                'Please report this error and provide the source code around the following:',
-                e,
-               ].join("\n")
-          throw :use_fallback, :cover_failed
-        end
+      begin
+        covered_code.execute_code
+      rescue ::SyntaxError => e
+        warn ["DeepCover is getting confused with the file #{path} and it won't be instrumented.",
+              'Please report this error and provide the source code around the following:',
+              e,
+             ].join("\n")
+        yield(:cover_failed)
+        raise "The fallback_block is supposed to either return or break, but didn't do either"
       end
       covered_code
     end

data/lib/deep_cover/load.rb

@@ -4,8 +4,9 @@ module DeepCover
   module Load
     AUTOLOAD = %i[analyser autoload_tracker auto_run config
                   coverage covered_code custom_requirer
+                  tracker_hits_per_path tracker_storage_per_path
                   flag_comment_associator memoize module_override node
-                  problem_with_diagnostic reporter
+                  problem_with_diagnostic reporter tracker_bucket
                  ]
 
     def load_absolute_basics
@@ -16,13 +17,15 @@ module DeepCover
       AUTOLOAD.each do |module_name|
         DeepCover.autoload(Tools::Camelize.camelize(module_name), "#{__dir__}/#{module_name}")
       end
-      DeepCover.autoload :VERSION, 'deep_cover/version'
+      DeepCover.autoload :VERSION, "#{__dir__}/version"
       Object.autoload :Term, 'term/ansicolor'
       Object.autoload :Terminal, 'terminal-table'
       Object.autoload :YAML, 'yaml'
+      Object.autoload :Forwardable, 'forwardable'
     end
 
     def bootstrap
+      @bootstrapped ||= false # Avoid warning
       return if @bootstrapped
       require_relative 'backports'
       require_relative 'tools'
@@ -30,14 +33,14 @@ module DeepCover
     end
 
     def load_parser
+      @parser_loaded ||= false # Avoid warning
       return if @parser_loaded
-      require 'parser'
       silence_warnings do
+        require 'parser'
         require 'parser/current'
       end
-      require 'parser_tree_rewriter'
       require_relative_dir 'parser_ext'
-      @parser_loaded
+      @parser_loaded = true
     end
 
     def load_pry
@@ -47,13 +50,14 @@ module DeepCover
     end
 
     def load_all
+      @all_loaded ||= false
       return if @all_loaded
       bootstrap
       load_parser
       AUTOLOAD.each do |module_name|
         DeepCover.const_get(Tools::Camelize.camelize(module_name))
       end
-      DeepCover::VERSION # rubocop:disable Lint/Void
+      DeepCover.const_get(:VERSION)
       @all_loaded = true
     end
   end

data/lib/deep_cover/memoize.rb

@@ -33,9 +33,7 @@ module DeepCover
       end
 
       def memoize(*methods)
-        @memoized ||= []
-        @memoized |= methods
-        @memoized.freeze
+        @memoized = (memoized | methods).freeze
 
         methods.each do |method|
           memoizer_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1

data/lib/deep_cover/module_override.rb

@@ -10,6 +10,9 @@ module DeepCover
     def active=(active)
       each do |mod, method_name|
         mod.send :alias_method, method_name, :"#{method_name}_#{active ? 'with' : 'without'}_deep_cover"
+        if mod == ::Kernel
+          mod.send :private, method_name
+        end
       end
     end
 
@@ -18,6 +21,10 @@ module DeepCover
       each do |mod, method_name|
         mod.send :alias_method, :"#{method_name}_without_deep_cover", method_name
         mod.send :define_method, :"#{method_name}_with_deep_cover", instance_method(method_name)
+        if mod == ::Kernel
+          mod.send :private, :"#{method_name}_without_deep_cover"
+          mod.send :private, :"#{method_name}_with_deep_cover"
+        end
       end
     end