deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/autoload_tracker.rb

@@ -2,77 +2,214 @@
 
 require 'weakref'
 
+# TODO: if a constant is removed, AutoloadEntries should be removed
+
 module DeepCover
   class AutoloadTracker
-    def initialize(autoloaded_paths = {})
-      @autoloaded_paths = autoloaded_paths
+    AutoloadEntry = Struct.new(:weak_mod, :name, :target_path, :interceptor_path) do
+      # If the ref is dead, will return nil
+      # If the target is frozen, will warn and return nil
+      # Otherwise return the target
+      def mod_if_available
+        mod = weak_mod.__getobj__
+        if mod.frozen?
+          AutoloadTracker.warn_frozen_module(mod)
+          nil
+        else
+          mod
+        end
+      rescue WeakRef::RefError
+        nil
+      end
     end
 
-    def add(const, name, path)
-      ext = File.extname(path)
-      # We don't care about .so files
-      return if ext == '.so'
-      path += '.rb' if ext != '.rb'
-
-      pairs = @autoloaded_paths[path] ||= []
-      pairs << [WeakRef.new(const), name]
+    attr_reader :autoloads_by_basename, :interceptor_files_by_path
+    def initialize
+      @autoloads_by_basename = {}
+      @interceptor_files_by_path = {}
     end
 
-    def pairs_for_absolute_path(absolute_path)
-      paths = autoloaded_paths_matching_absolute(absolute_path)
+    def autoload_path_for(mod, name, path)
+      interceptor_path = setup_interceptor_for(mod, name, path)
 
-      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.select!(&:first)
-        pairs
+      if DeepCover.custom_requirer.is_being_required?(path)
+        already_loaded_feature
+      else
+        interceptor_path
       end
     end
 
-    def wrap_require(absolute_path)
-      pairs = pairs_for_absolute_path(absolute_path)
+    def possible_autoload_target?(requested_path)
+      basename = basename_without_extension(requested_path)
+      autoloads = @autoloads_by_basename[basename]
+      autoloads && !autoloads.empty?
+    end
+
+    def wrap_require(requested_path, absolute_path_found) # &block
+      entries = entries_for_target(requested_path, absolute_path_found)
 
       begin
-        pairs.each do |const, name|
-          # Changing the autoload to an already loaded file (this one)
-          const.autoload_without_deep_cover(name, __FILE__)
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          mod.autoload_without_deep_cover(entry.name, already_loaded_feature)
         end
 
         yield
-      rescue Exception
-        pairs.each do |const, name|
-          # Changing the autoload to an already loaded file (this one)
-          const.autoload_without_deep_cover(name, absolute_path)
+      ensure
+        entries = entries_for_target(requested_path, absolute_path_found)
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          # Putting the autoloads back back since we couldn't complete the require
+          mod.autoload_without_deep_cover(entry.name, entry.interceptor_path)
         end
-
-        raise
       end
     end
 
-    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))
-            add(mod, name, path)
+    # This is only used on MRI, so ObjectSpace is alright.
+    def initialize_autoloaded_paths(mods = ObjectSpace.each_object(Module)) # &do_autoload_block
+      mods.each do |mod|
+        # Module's constants are shared with Object. But if you set autoloads directly on Module, they
+        # appear on multiple classes. So just skip, Object will take care of those.
+        next if mod == Module
+
+        if mod.frozen?
+          if mod.constants.any? { |name| mod.autoload?(name) }
+            self.class.warn_frozen_module(mod)
           end
+          next
+        end
+
+        mod.constants.each do |name|
+          path = mod.autoload?(name)
+          next unless path
+          interceptor_path = setup_interceptor_for(mod, name, path)
+          yield mod, name, interceptor_path
+        end
+      end
+    end
+
+    # We need to remove the interceptor hooks, otherwise, the problem if manually requiring
+    # something that is autoloaded will cause issues.
+    def remove_interceptors # &do_autoload_block
+      @autoloads_by_basename.each do |basename, entries|
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          # Module's constants are shared with Object. But if you set autoloads directly on Module, they
+          # appear on multiple classes. So just skip, Object will take care of those.
+          next if mod == Module
+          yield mod, entry.name, entry.target_path
         end
       end
+
+      @autoloaded_paths = {}
+      @interceptor_files_by_path = {}
+    end
+
+    class << self
+      attr_accessor :warned_for_frozen_module
+    end
+    self.warned_for_frozen_module = false
+
+    # Using frozen modules/classes is almost unheard of, but a warning makes things easier if someone does it
+    def self.warn_frozen_module(mod)
+      return if warned_for_frozen_module
+      self.warned_for_frozen_module ||= true
+      warn "There is an autoload on a frozen module/class: #{mod}, DeepCover cannot handle those, failure is probable. " \
+           "This warning won't be displayed again (even for different module/class)"
+    end
+
+    protected
+
+    def setup_interceptor_for(mod, name, path)
+      interceptor_path = autoload_interceptor_for(path)
+      entry = AutoloadEntry.new(WeakRef.new(mod), name, path, interceptor_path)
+
+      basename = basename_without_extension(path)
+
+      @autoloads_by_basename[basename] ||= []
+      @autoloads_by_basename[basename] << entry
+      interceptor_path
     end
 
-    # We need all the paths of autoloaded_path that match a given absolute_path
-    # Since this can happen a lot, a cache is made which only chan
-    def autoloaded_paths_matching_absolute(absolute_path)
-      @autoloaded_paths.keys.select do |path|
-        absolute_path == DeepCover.custom_requirer.resolve_path(path)
+    def entries_for_target(requested_path, absolute_path_found)
+      basename = basename_without_extension(requested_path)
+      autoloads = @autoloads_by_basename[basename] || []
+
+      if absolute_path_found
+        autoloads.select { |entry| entry_is_target?(entry, requested_path, absolute_path_found) }
+      elsif requested_path == File.absolute_path(requested_path)
+        []
+      elsif requested_path.start_with?('./', '../')
+        []
+      else
+        # We didn't find a path that goes through the $LOAD_PATH
+        # It's possible that RubyGems will actually add the $LOAD_PATH and require an actual file
+        # So we must make a best-guest for possible matches
+        requested_path_to_compare = without_extension(requested_path)
+        autoloads.select { |entry| requested_path_to_compare == without_extension(entry.target_path) }
       end
     end
 
-    # A simple if the ref is dead, return nil.
-    # WTF ruby, why is there no such simple interface ?!
-    def self.value_from_weak_ref(weak_ref)
-      WeakRef.class_variable_get(:@@__map)[weak_ref]
+    def entry_is_target?(entry, requested_path, absolute_path_found)
+      return true if entry.target_path == requested_path
+      target_path_rb = with_rb_extension(entry.target_path)
+      return true if target_path_rb == requested_path
+
+      # Even though this is not efficient, it's safer to resolve entries' target_path each time
+      # instead of storing the result, in case subsequent changes to $LOAD_PATH gives different results
+      entry_absolute_path = DeepCover.custom_requirer.resolve_path(entry.target_path)
+      return true if entry_absolute_path == absolute_path_found
+      false
+    end
+
+    def basename_without_extension(path)
+      without_extension(File.basename(path))
+    end
+
+    def with_rb_extension(path)
+      path += '.rb' unless has_supported_extension?(path)
+      path
+    end
+
+    def without_extension(path)
+      path = path[0...-3] if has_supported_extension?(path)
+      path
+    end
+
+    def has_supported_extension?(path)
+      path.end_with?('.rb', '.so')
+    end
+
+    # It is not possible to simply remove an autoload. So, instead, we must change the
+    # autoload to an already loaded path.
+    # The autoload will be set back to what it was once the require returns. This is
+    # needed in case that required path wasn't the one that fulfilled the autoload, or
+    # if the constant and $LOADED_FEATURES gets removed, since in that situation,
+    # the autoload is supposed to be active again.
+    def already_loaded_feature
+      $LOADED_FEATURES.first
+    end
+
+    def autoload_interceptor_for(path)
+      existing_files = @interceptor_files_by_path[path] || []
+      reusable_file = existing_files.detect { |f| !$LOADED_FEATURES.include?(f.path) }
+      return reusable_file.path if reusable_file
+
+      new_file = Tempfile.new([File.basename(path), '.rb'])
+      # Need to store all the tempfiles so that they are not GCed, which would delete the files themselves.
+      # Keeping them by path allows us to reuse them.
+      @interceptor_files_by_path[path] ||= []
+      @interceptor_files_by_path[path] << new_file
+      new_file.write(<<-RUBY)
+# Intermediary file for ruby's autoload made by deep-cover
+require #{path.to_s.inspect}
+      RUBY
+      new_file.close
+
+      new_file.path
     end
   end
 end

data/lib/deep_cover/backports.rb

@@ -12,9 +12,11 @@ class Pathname
   def binwrite(*args)
     File.binwrite(to_path, *args)
   end unless method_defined? :binwrite
-end
+end # nocov
 require 'backports/2.4.0/false_class/dup'
 require 'backports/2.4.0/true_class/dup'
 require 'backports/2.4.0/hash/transform_values'
 require 'backports/2.4.0/enumerable/sum'
 require 'backports/2.5.0/hash/slice'
+require 'backports/2.5.0/hash/transform_keys'
+require 'backports/2.5.0/kernel/yield_self'

data/lib/deep_cover/base.rb

@@ -3,27 +3,32 @@
 module DeepCover
   module Base
     def running?
-      @started
+      @started ||= false # rubocop:disable Naming/MemoizedInstanceVariableName [#5648]
     end
 
     def start
-      return if @started
+      return if running?
       if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-        # No issues with autoload in jruby, so no need to override it!
+        # Autoloaded files are not supported on jruby. We need to use binding_of_caller
+        # And that appears to be unavailable in jruby.
       else
         require_relative 'core_ext/autoload_overrides'
         AutoloadOverride.active = true
-        autoload_tracker.initialize_autoloaded_paths
+        autoload_tracker.initialize_autoloaded_paths { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
       end
       require_relative 'core_ext/require_overrides'
       RequireOverride.active = true
       config # actualize configuration
+      @custom_requirer = nil
       @started = true
     end
 
     def stop
       require_relative 'core_ext/require_overrides'
-      AutoloadOverride.active = false if defined? AutoloadOverride
+      if defined? AutoloadOverride
+        AutoloadOverride.active = false
+        autoload_tracker.remove_interceptors { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
+      end
       RequireOverride.active = false
       @started = false
     end
@@ -51,16 +56,16 @@ module DeepCover
     def config_changed(what)
       case what
       when :paths
-        warn "Changing DeepCover's paths after starting coverage is highly discouraged" if @started
+        warn "Changing DeepCover's paths after starting coverage is highly discouraged" if running?
         @custom_requirer = nil
       when :tracker_global
-        raise NotImplementedError, "Changing DeepCover's tracker global after starting coverage is not supported" if @started
+        raise NotImplementedError, "Changing DeepCover's tracker global after starting coverage is not supported" if running?
         @coverage = nil
       end
     end
 
     def reset
-      stop if @started
+      stop if running?
       @coverage = @custom_requirer = @autoload_tracker = nil
       config.reset
       self

data/lib/deep_cover/basics.rb

@@ -18,5 +18,5 @@ module DeepCover
                    open: false,
                  }.freeze
 
-  OPTIONALLY_COVERED = %i[case_implicit_else default_argument raise trivial_if]
+  OPTIONALLY_COVERED = %i[case_implicit_else default_argument raise trivial_if warn]
 end

data/lib/deep_cover/cli/debugger.rb

@@ -59,7 +59,7 @@ module DeepCover
             number_lines(lines, lineno: @lineno)
           end
         rescue Exception => e
-          output { "Can't run coverage: #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}" }
+          output { "Can't run coverage: #{e.class}: #{e}\n#{e.backtrace.join("\n")}" }
           @failed = true
         end
       end
@@ -100,7 +100,7 @@ module DeepCover
         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")}" }
+        output { "Can't `execute_sample`:#{e.class}: #{e}\n#{e.backtrace.join("\n")}" }
         @failed = true
       end
 

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -20,8 +20,13 @@ module DeepCover
           @root_path = @root_path.dirname
           raise "Can't find Gemfile" unless @root_path.join('Gemfile').exist?
         end
-        @dest_root = Pathname('~/test_deep_cover').expand_path
-        @dest_root = Pathname.new(Dir.mktmpdir('deep_cover_test')) unless @dest_root.exist?
+        path = Pathname('~/test_deep_cover').expand_path
+        if path.exist?
+          @dest_root = path.join(@source_path.basename)
+          @dest_root.mkpath
+        else
+          @dest_root = Pathname.new(Dir.mktmpdir('deep_cover_test'))
+        end
 
         gem_relative_path = @source_path.relative_path_from(@root_path)
         @main_path = @dest_root.join(gem_relative_path)
@@ -107,6 +112,7 @@ module DeepCover
 
       def patch_gemfile
         gemfile = @dest_root.join('Gemfile')
+        require 'bundler'
         deps = Bundler::Definition.build(gemfile, nil, nil).dependencies
 
         return if deps.find { |e| e.name == 'deep-cover' }
@@ -137,12 +143,11 @@ module DeepCover
       end
 
       def cover
-        coverage = Coverage.new
+        coverage = Coverage.new(tracker_global: ::DeepCover.config.tracker_global)
         each_dir_to_cover do |to_cover|
-          original = to_cover.sub_ext('_original')
-          FileUtils.cp_r(to_cover, original)
-          Tools.dump_covered_code(original,
-                                  coverage: coverage, root_path: @dest_root.to_s,
+          FileUtils.cp_r(to_cover, to_cover.sub_ext('_original'))
+          Tools.dump_covered_code(to_cover,
+                                  coverage: coverage,
                                   dest_path: to_cover)
         end
         coverage.save(@dest_root.to_s)
@@ -150,7 +155,14 @@ module DeepCover
 
       def process
         Bundler.with_clean_env do
-          system("cd #{@main_path} && #{@options[:command]}")
+          system({'DISABLE_SPRING' => 'true'}, "cd #{@main_path} && #{@options[:command]}")
+        end
+      end
+
+      def restore
+        each_dir_to_cover do |to_cover|
+          FileUtils.mv(to_cover, to_cover.sub_ext('_instrumented'))
+          FileUtils.mv(to_cover.sub_ext('_original'), to_cover)
         end
       end
 
@@ -174,6 +186,7 @@ module DeepCover
           patch
           bundle if @options[:bundle]
           process
+          restore
         end
         report
       end

data/lib/deep_cover/cli/runner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require 'slop'
+  require_relative '../../deep-cover'
+  bootstrap
+
+  module CLI
+    module SlopExtension
+      attr_accessor :stopped
+      attr_reader :ignored
+
+      def try_process(*)
+        @ignored ||= 0
+        return if stopped
+        o = super
+        @ignored += 1 unless o
+        o
+      end
+    end
+    ::Slop::Parser.prepend SlopExtension
+
+    module Runner
+      extend self
+
+      def show_version
+        require_relative '../version'
+        require 'parser'
+        puts "deep-cover v#{DeepCover::VERSION}; parser v#{Parser::VERSION}"
+      end
+
+      def show_help
+        puts menu
+      end
+
+      class OptionParser < Struct.new(:delegate)
+        def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
+          options = args.last
+          if options.is_a?(Hash) && options.has_key?(:default)
+            args[-2] += " [#{options[:default]}]"
+          end
+          delegate.public_send(method, *args, &block)
+        end
+      end
+
+      def parse
+        Slop.parse do |o|
+          yield OptionParser.new(o)
+        end
+      end
+
+      def menu
+        @menu ||= parse do |o|
+          o.banner = ['usage: deep-cover [options] exec <command ...>',
+                      '   or  deep-cover [options] [path/to/app/or/gem]',
+                     ].join("\n")
+          o.separator ''
+          o.string '-o', '--output', 'output folder', default: DeepCover.config.output
+          o.string '--reporter', 'reporter', default: DeepCover.config.reporter
+          o.bool '--open', 'open the output coverage', default: CLI_DEFAULTS[:open]
+
+          o.separator 'Coverage options'
+          @ignore_uncovered_map = OPTIONALLY_COVERED.map do |option|
+            default = DeepCover.config.ignore_uncovered.include?(option)
+            o.bool "--ignore-#{dasherize(option)}", '', default: default
+            [:"ignore_#{option}", option]
+          end.to_h
+
+          o.separator "\nWhen not using ’exec’:"
+          o.string '-c', '--command', 'command to run tests', default: CLI_DEFAULTS[:command]
+          o.bool '--bundle', 'run bundle before the tests', default: CLI_DEFAULTS[:bundle]
+          o.bool '--process', 'turn off to only redo the reporting', default: CLI_DEFAULTS[:process]
+
+          o.separator "\nFor testing purposes:"
+          o.bool '--profile', 'use profiler' unless RUBY_PLATFORM == 'java'
+          o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
+          o.bool '-d', '--debug', 'enter debugging after cover'
+
+          o.separator "\nOther available commands:"
+          o.on('--version', 'print the version') do
+            show_version
+            exit
+          end
+          o.boolean('-h', '--help')
+
+          o.boolean('exec', '', help: false) do
+            o.parser.stopped = true if o.parser.ignored == 0
+          end
+        end
+      end
+
+      def convert_options(options)
+        iu = options[:ignore_uncovered] = []
+        @ignore_uncovered_map.each do |cli_option, option|
+          iu << option if options.delete(cli_option)
+        end
+        options[:output] = false if ['false', 'f', ''].include?(options[:output])
+        options
+      end
+
+      def go
+        options = convert_options(menu.to_h)
+        if options[:help]
+          show_help
+        elsif options[:expression]
+          require_relative 'debugger'
+          Debugger.new(options[:expression], **options).show
+        elsif menu.parser.stopped
+          require_relative 'exec'
+          Exec.new(menu.arguments, **options).run
+        else
+          require_relative 'instrumented_clone_reporter'
+          path = menu.arguments.first || '.'
+          InstrumentedCloneReporter.new(path, **options).run
+        end
+      end
+
+      private
+
+      # Poor man's dasherize. 'an_example' => 'an-example'
+      def dasherize(string)
+        string.to_s.tr('_', '-')
+      end
+    end
+  end
+end