deep-cover 0.1.14 → 0.1.15

data/lib/deep_cover/custom_requirer.rb

@@ -1,11 +1,56 @@
+# frozen_string_literal: true
+
 # TODO: must handle circular requires
 
 module DeepCover
   class CustomRequirer
-    attr_reader :load_path, :loaded_features
-    def initialize(load_path=$LOAD_PATH, loaded_features=$LOADED_FEATURES)
-      @load_path = load_path
+    class LoadPathsSubset
+      def initialize(load_paths: raise, lookup_paths: raise)
+        @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
+
+    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? '/'
       @loaded_features = loaded_features
+      @filter = filter
     end
 
     # Returns a path to an existing file or nil if none can be found.
@@ -14,46 +59,46 @@ module DeepCover
     # 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?('./') || path.start_with?('../')
-
-      if Pathname.new(path).absolute?
-        return path if File.exist?(path)
-        return nil
-      end
-
-      @load_path.each do |load_path|
-        possible_path = File.absolute_path(path, load_path)
-        return possible_path if File.exist?(possible_path)
+      path = File.absolute_path(path) if path.start_with?('./', '../')
+
+      abs_path = File.absolute_path(path)
+      if path == abs_path
+        path if (@load_paths_subset || File).exist?(path)
+      else
+        (@load_paths_subset || self).load_paths.each do |load_path|
+          possible_path = File.absolute_path(path, load_path)
+          return possible_path if (@load_paths_subset || File).exist?(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)
-    # Returns :not_found if the file couldn't be found.
-    #     Caller should delegate to the default #require.
-    # Returns :cover_failed if DeepCover couldn't apply instrumentation the file found.
-    #     Caller should delegate to the default #require.
-    # Returns :not_supported for files that are not supported (such as ike .so files)
-    #     Caller should delegate to the default #require.
+    # Throws :use_fallback in case caller should delegate to the default #require.
+    # Reasons given could be:
+    #  - :not_found if the file couldn't be found.
+    #  - :cover_failed if DeepCover couldn't apply instrumentation the file found.
+    #  - :not_supported for files that are not supported (such as ike .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)
       ext = File.extname(path)
-      return :not_supported if ext == '.so'
-      path = path + '.rb' if ext != '.rb'
+      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)
 
-      return :not_found unless found_path
+      throw :use_fallback, :not_found unless found_path
       return false if @loaded_features.include?(found_path)
 
-      covered_code = cover_and_execute(found_path)
-      return covered_code if covered_code.is_a?(Symbol)
+      throw :use_fallback, :skipped if filter && filter.call(found_path)
+
+      cover_and_execute(found_path)
 
       @loaded_features << found_path
       true
@@ -61,7 +106,7 @@ module DeepCover
 
     # 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/raise as CustomRequirer#require, except:
+    # 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)
@@ -69,18 +114,18 @@ module DeepCover
       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 File.exist?(possible_path)
+        found_path = possible_path if (@load_paths_subset || File).exist?(possible_path)
       end
 
-      return :not_found unless found_path
+      throw :use_fallback, :not_found unless found_path
 
-      covered_code = cover_and_execute(found_path)
-      return covered_code if covered_code.is_a?(Symbol)
+      cover_and_execute(found_path)
 
       true
     end
 
     protected
+
     def cover_and_execute(path)
       begin
         covered_code = DeepCover.coverage.covered_code(path)
@@ -90,15 +135,17 @@ module DeepCover
         else
           warn "The file #{path} can't be instrumented"
         end
-        return :cover_failed
+        throw :use_fallback, :cover_failed
       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.\n" +
-               "Please report this error and provide the source code around the following:\n#{e}"
-          return :cover_failed
+          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
       end
       covered_code

data/lib/deep_cover/memoize.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DeepCover
+  # Memoize is a quick way to prepend a module that defines
+  # the memoized methods as `@_cache ||= super.freeze`
+  # It also refines `freeze` to precache memoized methods
+  #
+  module Memoize
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def freeze
+      self.class.memoized.each do |method|
+        send method
+      end
+      super
+    end
+
+    module ClassMethods
+      def memoized
+        @memoized ||= [].freeze
+      end
+
+      def memoizer_module
+        @memoizer_module ||= begin
+          mod = const_set(:Memoizer, Module.new)
+          prepend mod
+          mod
+        end
+      end
+
+      def memoize(*methods)
+        @memoized ||= []
+        @memoized |= methods
+        @memoized.freeze
+
+        methods.each do |method|
+          memoizer_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}                    # def foo
+              @_#{method} ||= super.freeze   #   @_foo ||= super.freeze
+            end                              # end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/module_override.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   # Helps redefine methods in overriden_modules.
   # For each methods in Mod, this defines `<method>_with{out}_deep_cover`.

data/lib/deep_cover/node.rb

@@ -1,8 +1,21 @@
+# frozen_string_literal: true
+
 module DeepCover
-  class  Node
+  class Node
     # Reopened in base
+    CLASSES = []
+    def self.inherited(parent)
+      CLASSES << parent
+      super
+    end
   end
   require_relative_dir 'node/mixin'
   require_relative 'node/base'
   require_relative_dir 'node'
+
+  require_relative 'memoize'
+  Node.include Memoize
+  Node::CLASSES.freeze.each do |klass|
+    klass.memoize :flow_entry_count, :flow_completion_count, :execution_count, :loc_hash
+  end
 end

data/lib/deep_cover/node/arguments.rb

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

data/lib/deep_cover/node/assignments.rb

@@ -1,5 +1,7 @@
-require_relative "const"
-require_relative "literals"
+# frozen_string_literal: true
+
+require_relative 'const'
+require_relative 'literals'
 
 module DeepCover
   class Node
@@ -88,17 +90,17 @@ module DeepCover
           if method_name == :[]=
             selector = base[:selector]
             {
-                expression: base[:expression],
-                selector_begin: selector.resize(1),
-                # The = is implicit, so only backtrack the end by one
-                selector_end: Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos),
+              expression: base[:expression],
+              selector_begin: selector.resize(1),
+              # The = is implicit, so only backtrack the end by one
+              selector_end: Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos),
             }
           else
             {
-                dot: base[:dot],
-                expression: base[:expression],
-                selector_begin: base[:selector],
-                selector_end: nil#,
+              dot: base[:dot],
+              expression: base[:expression],
+              selector_begin: base[:selector],
+              selector_end: nil, # ,
             }
           end
         end
@@ -134,11 +136,11 @@ module DeepCover
       end
 
       BASE_MAP = {
-        cvasgn: VariableAssignment, gvasgn: VariableAssignment,
-        ivasgn: VariableAssignment, lvasgn: VariableAssignment,
-        casgn: ConstantAssignment,
-        send: Setter,
-      }
+                   cvasgn: VariableAssignment, gvasgn: VariableAssignment,
+                   ivasgn: VariableAssignment, lvasgn: VariableAssignment,
+                   casgn: ConstantAssignment,
+                   send: Setter,
+                 }.freeze
       class Splat < Node
         include BackwardsStrategy
         has_child rest_arg: [nil], remap: BASE_MAP
@@ -148,10 +150,10 @@ module DeepCover
       class LeftSide < Node
         include BackwardsStrategy
         has_extra_children receivers: {
-          splat: Splat,
-          mlhs: LeftSide,
-          **BASE_MAP,
-        }
+                                        splat: Splat,
+                                        mlhs: LeftSide,
+                                        **BASE_MAP,
+                                      }
         executed_loc_keys # none
 
         def flow_completion_count
@@ -195,7 +197,7 @@ module DeepCover
 
       def loc_hash
         base = super
-        hash = { expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
+        hash = {expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
         selector = base[:selector]
 
         if [:[], :[]=].include?(method_name)
@@ -214,11 +216,11 @@ module DeepCover
       check_completion
       has_tracker :reader
       has_child receiver: {
-        lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
-        cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
-        casgn: Casgn, # TODO
-        send: SendOperatorAssign,
-      }
+                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
+                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
+                            casgn: Casgn, # TODO
+                            send: SendOperatorAssign,
+                          }
       has_child operator: Symbol
       has_child value: Node, rewrite: '(%{reader_tracker};%{node})', flow_entry_count: :reader_tracker_hits
       executed_loc_keys :operator
@@ -233,11 +235,11 @@ module DeepCover
       check_completion
       has_tracker :long_branch
       has_child receiver: {
-        lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
-        cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
-        casgn: ConstantOperatorAssign,
-        send: SendOperatorAssign,
-      }
+                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
+                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
+                            casgn: ConstantOperatorAssign,
+                            send: SendOperatorAssign,
+                          }
       has_child value: Node, rewrite: '(%{long_branch_tracker};%{node})', flow_entry_count: :long_branch_tracker_hits
       executed_loc_keys :operator
 

data/lib/deep_cover/node/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   # Base class to handle covered nodes.
   class Node
@@ -22,6 +24,7 @@ module DeepCover
       @children = []
       begin
         @children = augment_children(base_children)
+        initialize_siblings
         super()
       rescue StandardError => e
         diagnose(e)
@@ -36,11 +39,11 @@ module DeepCover
       when ::Class
         each_node.grep(lookup)
       when ::Symbol
-        each_node.find_all{|n| n.type == lookup}
+        each_node.find_all { |n| n.type == lookup }
       when ::String
-        each_node.find_all{|n| n.source == lookup}
+        each_node.find_all { |n| n.source == lookup }
       when ::Regexp
-        each_node.find_all{|n| n.source =~ lookup}
+        each_node.find_all { |n| n.source =~ lookup }
       else
         binding.pry
         raise ::TypeError, "Expected class or symbol, got #{lookup.class}: #{lookup.inspect}"
@@ -70,28 +73,25 @@ module DeepCover
     end
 
     def children_nodes
-      children.select{|c| c.is_a? Node }
+      children.select { |c| c.is_a? Node }
     end
     alias_method :children_nodes_in_flow_order, :children_nodes
 
-    def next_sibling
-      parent.children_nodes_in_flow_order.each_cons(2) do |child, next_child|
-        return next_child if child.equal? self
-      end
-      nil
-    end
-
-    def previous_sibling
-      parent.children_nodes_in_flow_order.each_cons(2) do |previous_child, child|
-        return previous_child if child.equal? self
+    attr_accessor :next_sibling
+    attr_accessor :previous_sibling
+    protected :next_sibling=, :previous_sibling=
+    def initialize_siblings
+      children_nodes_in_flow_order.each_cons(2) do |child, next_child|
+        child.next_sibling = next_child
+        next_child.previous_sibling = child
       end
-      nil
     end
+    private :initialize_siblings
 
     # Adapted from https://github.com/whitequark/ast/blob/master/lib/ast/node.rb
-    def to_s(indent=0)
+    def to_s(indent = 0)
       [
-        "  " * indent,
+        '  ' * indent,
         '(',
         fancy_type,
         *children.map do |child, idx|
@@ -101,7 +101,7 @@ module DeepCover
             " #{child.inspect}"
           end
         end,
-        ')'
+        ')',
       ].join
     end
 
@@ -128,25 +128,26 @@ module DeepCover
     end
 
     def fancy_type
-      class_name = self.class.to_s.gsub(/^DeepCover::/,'').gsub(/^Node::/, '')
+      class_name = self.class.to_s.gsub(/^DeepCover::/, '').gsub(/^Node::/, '')
       t = type.to_s
       t.casecmp(class_name) == 0 ? t : "#{t}[#{class_name}]"
     end
 
     private
+
     def diagnose(exception)
       msg = if self.class == Node
-        "Unknown node type encountered: #{base_node.type}"
-      else
-        "Node class #{self.class} incorrectly defined"
-      end
+              "Unknown node type encountered: #{base_node.type}"
+            else
+              "Node class #{self.class} incorrectly defined"
+            end
       warn [msg,
-        'Attempting to continue, but this node will not be handled properly',
-        ('Its subnodes will be ignored' if children.empty?),
-        'Source:',
-        expression,
-        "Original exception:",
-        exception.inspect,
+            'Attempting to continue, but this node will not be handled properly',
+            ('Its subnodes will be ignored' if children.empty?),
+            'Source:',
+            expression,
+            'Original exception:',
+            exception.inspect,
       ].join("\n")
     end
   end