deep-cover 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2b3fc6dc22a4c501fd7090466901a9174a9ed0a782218970d1c23bcacb9ea56
-  data.tar.gz: 4ea988ee9e3feea82db9df67cf3da0dd4d44229fb233becbff97953e4833730e
+  metadata.gz: f3b9feb6fdad25312b0111faf653599e6019c51ddbcd31446ec2c45d7c5403f3
+  data.tar.gz: 18c532649cdc00a98690fc3d66ced732e11b1c97a2787ab36d0d5e3151e20601
 SHA512:
-  metadata.gz: 5c0737e921cdc4c6cd4cb4461bb2f7bdd95c4f9b71d0132cda39b6005fd16cd062df45042f8fd0cb7474cf3320281feef60e4903e41d62bf6b5269c344169020
-  data.tar.gz: 752569da3e00e55e136f797903e8686e2a6f5fac70050dcc42c525a104d93dd9174ccd11d17b804b83f9b76c645242d6da823a7e879ca4932a81adca23a2cdab
+  metadata.gz: 1b68e3fc7a62f263f1971b7b50b753d5ca5472bee6231eba897771ff1e036efcc6f8cc5625b1e5b6ef3422a978f1e2876ba7b6f8488d176705e0b8f465d9786d
+  data.tar.gz: 9fcf65daa4618b3c9d056ed95fe1a3f7e9ae1e4d67768940989630fa9c1a45ff05c7504bffae5058e0597fea8f661e730d59fa0ec089446d2ad28ec5f4ab963c

data/lib/deep_cover/base.rb

@@ -9,27 +9,33 @@ module DeepCover
     def start
       return if running?
       if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-        # Autoloaded files are not supported on jruby. We need to use binding_of_caller
-        # And that appears to be unavailable in jruby.
+        # Autoload is not supported in JRuby. We currently need to use binding_of_caller
+        # and that is not available in JRuby. An extension may be able to replace this requirement.
+        # require_relative 'core_ext/autoload_overrides'
+        # AutoloadOverride.active = true
+        require_relative 'core_ext/require_overrides'
+        RequireOverride.active = true
+      elsif RUBY_VERSION >= '2.3.0'
+        require_relative 'core_ext/instruction_sequence_load_iseq'
       else
         require_relative 'core_ext/autoload_overrides'
-        AutoloadOverride.active = true
+        require_relative 'core_ext/require_overrides'
+        AutoloadOverride.active = RequireOverride.active = true
         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
+      @lookup_paths = nil
       @started = true
     end
 
     def stop
-      require_relative 'core_ext/require_overrides'
       if defined? AutoloadOverride
         AutoloadOverride.active = false
         autoload_tracker.remove_interceptors { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
       end
-      RequireOverride.active = false
+      RequireOverride.active = false if defined? RequireOverride
+
       @started = false
     end
 
@@ -57,7 +63,7 @@ module DeepCover
       case what
       when :paths
         warn "Changing DeepCover's paths after starting coverage is highly discouraged" if running?
-        @custom_requirer = nil
+        @lookup_paths = nil
       when :tracker_global
         raise NotImplementedError, "Changing DeepCover's tracker global after starting coverage is not supported" if running?
         @coverage = nil
@@ -66,7 +72,7 @@ module DeepCover
 
     def reset
       stop if running?
-      @coverage = @custom_requirer = @autoload_tracker = nil
+      @coverage = @custom_requirer = @autoload_tracker = @lookup_paths = nil
       config.reset
       self
     end
@@ -75,8 +81,20 @@ module DeepCover
       @coverage ||= Coverage.new(tracker_global: config.tracker_global)
     end
 
+    def lookup_paths
+      return @lookup_paths if @lookup_paths
+      lookup_paths = config.paths || Dir.getwd
+      lookup_paths = Array(lookup_paths).map { |p| File.expand_path(p) }
+      lookup_paths = ['/'] if lookup_paths.include?('/')
+      @lookup_paths = lookup_paths
+    end
+
+    def within_lookup_paths?(path)
+      lookup_paths.any? { |lookup_path| path.start_with?(lookup_path) }
+    end
+
     def custom_requirer
-      @custom_requirer ||= CustomRequirer.new(lookup_paths: config.paths)
+      @custom_requirer ||= CustomRequirer.new
     end
 
     def autoload_tracker

data/lib/deep_cover/core_ext/instruction_sequence_load_iseq.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DeepCover
+  load_all
+
+  module InstructionSequenceLoadIseq
+    def load_iseq(path)
+      compiled = InstructionSequenceLoadIseq.load_iseq_logic(path)
+
+      return compiled if compiled
+
+      # By default there is no super, but if bootsnap is there, and things are in the right order,
+      # we could possibly fallback to it as usual to keep the perf gain. Same for other possible
+      # tools using #load_iseq
+      super if defined?(super)
+    end
+
+    def self.load_iseq_logic(path)
+      return unless DeepCover.running?
+      return unless DeepCover.within_lookup_paths?(path)
+
+      covered_code = DeepCover.coverage.covered_code_or_warn(path)
+      return unless covered_code
+
+      covered_code.compile_or_warn
+    end
+  end
+end
+
+class << RubyVM::InstructionSequence
+  prepend DeepCover::InstructionSequenceLoadIseq
+end

data/lib/deep_cover/coverage.rb

@@ -37,6 +37,18 @@ module DeepCover
                                                     **@options)
     end
 
+    def covered_code_or_warn(path, **options)
+      covered_code(path, **options)
+    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
+      nil
+    end
+
+
     def each
       return to_enum unless block_given?
       @tracker_storage_per_path.each_key do |path|

data/lib/deep_cover/covered_code.rb

@@ -44,6 +44,12 @@ module DeepCover
       self
     end
 
+    def execute_code_or_warn(*args)
+      warn_instead_of_syntax_error do
+        execute_code(*args)
+      end
+    end
+
     def cover
       global[nb] ||= Array.new(@tracker_count, 0)
     end
@@ -93,6 +99,16 @@ module DeepCover
       rewriter.process
     end
 
+    def compile
+      RubyVM::InstructionSequence.compile(covered_source, path.to_s, path.to_s)
+    end
+
+    def compile_or_warn
+      warn_instead_of_syntax_error do
+        compile
+      end
+    end
+
     def freeze
       unless frozen? # Guard against reentrance
         super
@@ -106,6 +122,17 @@ module DeepCover
     end
     alias_method :to_s, :inspect
 
+    def warn_instead_of_syntax_error # &block
+      yield
+    rescue ::SyntaxError => e
+      warn Tools.strip_heredoc(<<-MSG)
+          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 lines:
+          #{e}
+      MSG
+      nil
+    end
+
     private
 
     def parser

data/lib/deep_cover/custom_requirer.rb

@@ -2,72 +2,9 @@
 
 module DeepCover
   class CustomRequirer
-    class LoadPathsSubset
-      def initialize(load_paths:, lookup_paths:)
-        @original_load_paths = load_paths
-        @cached_load_paths_subset = []
-        @cached_load_paths_hash = nil
-        @lookup_paths = lookup_paths.map { |p| File.expand_path(p) }
-      end
-
-      def load_paths
-        if @cached_load_paths_hash != (h = @original_load_paths.hash)
-          @cached_load_paths_subset = compute_subset
-          @cached_load_paths_hash = h
-        end
-        @cached_load_paths_subset
-      end
-
-      # E.g.  '/a/b/' => true if a lookup path is '/a/b/c/', because '/a/b/' + 'c/ok' is within lookup.
-      def potentially_within_lookup?(full_dir_path)
-        @lookup_paths.any? { |p| p.start_with? full_dir_path }
-      end
-
-      # 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) }
-      end
-
-      def exist?(full_path)
-        within_lookup?(full_path) && File.exist?(full_path)
-      end
-
-      private
-
-      def compute_subset
-        @original_load_paths.map { |p| File.expand_path(p) }
-                            .select { |p| within_lookup?(p) || potentially_within_lookup?(p) }
-                            .freeze
-      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)
+    def initialize(load_paths: $LOAD_PATH, loaded_features: $LOADED_FEATURES, &filter)
       @load_paths = load_paths
-      lookup_paths ||= Dir.getwd
-      lookup_paths = Array(lookup_paths)
-
-      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
@@ -146,7 +83,7 @@ module DeepCover
 
         begin
           @paths_being_required.add(found_path)
-          return yield(:not_in_covered_paths) unless @load_paths_subset.within_lookup?(found_path)
+          return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
           return yield(:not_supported) if found_path.end_with?('.so')
           return yield(:skipped) if filter && filter.call(found_path)
 
@@ -197,27 +134,18 @@ module DeepCover
     end
 
     def cover_and_execute(path) # &fallback_block
-      begin
-        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
+      covered_code = DeepCover.coverage.covered_code_or_warn(path)
+      if covered_code.nil?
         yield(:cover_failed)
         raise "The fallback_block is supposed to either return or break, but didn't do either"
       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")
+
+      success = covered_code.execute_code_or_warn
+      unless success
         yield(:cover_failed)
         raise "The fallback_block is supposed to either return or break, but didn't do either"
       end
+
       covered_code
     end
   end

data/lib/deep_cover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepCover
-  VERSION = '0.5.7'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deep-cover
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.0
 platform: ruby
 authors:
 - Marc-André Lafortune
@@ -294,6 +294,7 @@ files:
 - lib/deep_cover/core_ext/autoload_overrides.rb
 - lib/deep_cover/core_ext/coverage_replacement.rb
 - lib/deep_cover/core_ext/exec_callbacks.rb
+- lib/deep_cover/core_ext/instruction_sequence_load_iseq.rb
 - lib/deep_cover/core_ext/load_overrides.rb
 - lib/deep_cover/core_ext/require_overrides.rb
 - lib/deep_cover/coverage.rb
@@ -412,7 +413,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: In depth coverage of your Ruby code.