deep-cover 0.1.1

data/lib/deep_cover/custom_requirer.rb

@@ -0,0 +1,93 @@
+# 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
+      @loaded_features = loaded_features
+    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
+    #
+    # 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.exists?(path)
+        return nil
+      end
+
+      @load_path.each do |load_path|
+        possible_path = File.absolute_path(path, load_path)
+        return possible_path if File.exists?(possible_path)
+      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.
+    # 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'
+      return false if @loaded_features.include?(path)
+
+      found_path = resolve_path(path)
+
+      return :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)
+
+      @loaded_features << found_path
+      true
+    end
+
+    # 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:
+    # Cannot return false since #load doesn't care about a file already being executed.
+    def load(path)
+      found_path = resolve_path(path)
+
+      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.exists?(possible_path)
+      end
+
+      return :not_found unless found_path
+
+      covered_code = cover_and_execute(found_path)
+      return covered_code if covered_code.is_a?(Symbol)
+
+      true
+    end
+
+    protected
+    def cover_and_execute(path)
+      covered_code = DeepCover.coverage.covered_code(path)
+      return :cover_failed unless covered_code
+      DeepCover.autoload_tracker.wrap_require(path) do
+        covered_code.execute_code
+      end
+      covered_code
+    end
+  end
+end

data/lib/deep_cover/node.rb

@@ -0,0 +1,8 @@
+module DeepCover
+  class  Node
+    # Reopened in base
+  end
+  require_relative_dir 'node/mixin'
+  require_relative 'node/base'
+  require_relative_dir 'node'
+end

data/lib/deep_cover/node/arguments.rb

@@ -0,0 +1,50 @@
+require_relative 'assignments'
+
+module DeepCover
+  class Node
+    class Arg < Node
+      has_child name: Symbol
+      def executable?
+        false
+      end
+    end
+    Kwarg = Arg
+
+    class Restarg < Node
+      has_child name: [Symbol, nil]
+      def executable?
+        false
+      end
+    end
+    Kwrestarg = Restarg
+
+    class Optarg < Node
+      has_tracker :default
+      has_child name: Symbol
+      has_child default: Node, flow_entry_count: :default_tracker_hits, rewrite: '(%{default_tracker};%{node})'
+      executed_loc_keys :name, :operator
+
+      def executable?
+        false
+      end
+    end
+    Kwoptarg = Optarg
+
+    # foo(&block)
+    class Blockarg < Node
+      has_child name: Symbol
+
+      def executable?
+        false
+      end
+    end
+
+    class Args < Node
+      has_extra_children arguments: [Arg, Optarg, Restarg, Kwarg, Kwoptarg, Kwrestarg, Blockarg, Mlhs]
+
+      def executable?
+        false
+      end
+    end
+  end
+end

data/lib/deep_cover/node/assignments.rb

@@ -0,0 +1,250 @@
+require_relative "const"
+
+module DeepCover
+  class Node
+    class VariableAssignment < Node
+      has_child var_name: Symbol
+      has_child value: [Node, nil]
+      executed_loc_keys :name, :operator
+
+      def execution_count
+        return super unless value
+        value.flow_completion_count
+      end
+    end
+    Cvasgn = Gvasgn = Ivasgn = Lvasgn = VariableAssignment
+
+    class Casgn < Node
+      has_child cbase: [Cbase, Const, nil]
+      has_child var_name: Symbol
+      has_child value: [Node, nil]
+
+      def execution_count
+        return super unless value
+        value.flow_completion_count
+      end
+    end
+
+    class Mlhs < Node
+      has_extra_children being_set: Node
+      # TODO
+    end
+
+    module BackwardsStrategy
+      # Instead of assuming our parent tracks our entry and we are responsible
+      # for tracking our completion, we go the other way and assume our parent
+      # tracks our completion and we are responsible for our entry.
+      def flow_completion_count
+        if (s = next_sibling)
+          s.flow_entry_count
+        else
+          parent.flow_completion_count
+        end
+      end
+
+      def flow_entry_count
+        if (first_child = children_nodes.first)
+          first_child.flow_entry_count
+        else
+          flow_completion_count
+        end
+      end
+    end
+
+    # a, b = ...
+    class Masgn < Node
+      class BackwardsNode < Node
+        include BackwardsStrategy
+      end
+
+      class SelfReceiver < BackwardsNode
+        executed_loc_keys :expression
+      end
+
+      class ConstantCbase < BackwardsNode
+      end
+
+      class DynamicReceiverWrap < Node
+        include Wrapper
+        has_tracker :entry
+        has_child actual_receiver: Node
+        def rewrite
+          # The local=local is to avoid Ruby warning about "Possible use of value in void context"
+          '(%{local} = (%{node});%{entry_tracker}; %{local}=%{local})'
+        end
+        alias_method :flow_entry_count, :entry_tracker_hits
+      end
+
+      class Setter < Node
+        include BackwardsStrategy
+        has_child receiver: {self: SelfReceiver, Parser::AST::Node => DynamicReceiverWrap}
+        has_child method_name: Symbol
+        has_child arg: [Node, nil] # When method is :[]=
+        executed_loc_keys :dot, :selector_begin, :selector_end
+
+        def loc_hash
+          base = super
+          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),
+            }
+          else
+            {
+                dot: base[:dot],
+                expression: base[:expression],
+                selector_begin: base[:selector],
+                selector_end: nil#,
+            }
+          end
+        end
+      end
+
+      class ConstantScopeWrapper < Node
+        include Wrapper
+        has_tracker :entry
+        has_child actual_node: Node
+
+        def rewrite
+          '(%{entry_tracker};%{node})'
+        end
+
+        def flow_entry_count
+          entry_tracker_hits
+        end
+      end
+
+      class ConstantAssignment < Node
+        include BackwardsStrategy
+        has_child scope: [nil], remap: {cbase: ConstantCbase, Parser::AST::Node => ConstantScopeWrapper}
+        has_child constant_name: Symbol
+
+        def execution_count
+          scope ? scope.flow_completion_count : super
+        end
+      end
+
+      class VariableAssignment < Node
+        include BackwardsStrategy
+        has_child var_name: Symbol
+      end
+
+      BASE_MAP = {
+        cvasgn: VariableAssignment, gvasgn: VariableAssignment,
+        ivasgn: VariableAssignment, lvasgn: VariableAssignment,
+        casgn: ConstantAssignment,
+        send: Setter,
+      }
+      class Splat < Node
+        include BackwardsStrategy
+        has_child rest_arg: BASE_MAP
+        executed_loc_keys :operator
+      end
+
+      class LeftSide < Node
+        include BackwardsStrategy
+        has_extra_children receivers: {
+          splat: Splat,
+          mlhs: LeftSide,
+          **BASE_MAP,
+        }
+        executed_loc_keys # none
+
+        def flow_completion_count
+          parent.flow_completion_count
+        end
+      end
+
+      check_completion
+
+      has_child left: {mlhs: LeftSide}
+      has_child value: Node
+
+      executed_loc_keys :operator
+
+      def execution_count
+        value.flow_completion_count
+      end
+
+      def children_nodes_in_flow_order
+        [value, left]
+      end
+    end
+
+    class VariableOperatorAssign < Node
+      has_child var_name: Symbol
+    end
+
+    class ConstantOperatorAssign < Node
+      has_child scope: [Node, nil]
+      has_child const_name: Symbol
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    class SendOperatorAssign < Node
+      has_child receiver: [Node, nil]
+      has_child method_name: Symbol
+      has_extra_children arguments: Node
+      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
+
+      def loc_hash
+        base = super
+        hash = { expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
+        selector = base[:selector]
+
+        if [:[], :[]=].include?(method_name)
+          hash[:selector_begin] = selector.resize(1)
+          hash[:selector_end] = Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos)
+        else
+          hash[:selector_begin] = base[:selector]
+        end
+
+        hash
+      end
+    end
+
+    # foo += bar
+    class OpAsgn < Node
+      check_completion
+      has_tracker :reader
+      has_child receiver: {
+        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
+
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    # foo ||= bar, foo &&= base
+    class BooleanAssignment < Node
+      check_completion
+      has_tracker :long_branch
+      has_child receiver: {
+        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
+
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    OrAsgn = AndAsgn = BooleanAssignment
+  end
+end

data/lib/deep_cover/node/base.rb

@@ -0,0 +1,99 @@
+module DeepCover
+  # Base class to handle covered nodes.
+  class Node
+    include Mixin
+    include HasTracker
+    include HasChild
+    include HasChildHandler
+    include CanAugmentChildren
+    include Rewriting
+    extend CheckCompletion
+    include FlowAccounting
+    include IsStatement
+    include ExecutionLocation
+    include ChildCanBeEmpty
+
+    attr_reader :index, :parent, :children, :base_node
+
+    def initialize(base_node, parent: raise, index: 0, base_children: base_node.children)
+      @base_node = base_node
+      @parent = parent
+      @index = index
+      @children = augment_children(base_children)
+      super()
+    end
+
+    ### High level API for coverage purposes
+
+    def [](v)
+      children[v]
+    end
+
+    ### Public API
+
+    def children_nodes
+      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
+      end
+      nil
+    end
+
+    # Adapted from https://github.com/whitequark/ast/blob/master/lib/ast/node.rb
+    def to_s(indent=0)
+      [
+        "  " * indent,
+        '(',
+        fancy_type,
+        *children.map do |child, idx|
+          if child.is_a?(Node)
+            "\n#{child.to_s(indent + 1)}"
+          else
+            " #{child.inspect}"
+          end
+        end,
+        ')'
+      ].join
+    end
+
+    alias_method :inspect, :to_s
+    ### Internal API
+
+    def covered_code
+      parent.covered_code
+    end
+
+    def type
+      return base_node.type if base_node
+      self.class.name.split('::').last.to_sym
+    end
+
+    def each_node(order = :postorder, &block)
+      return to_enum :each_node, order unless block_given?
+      yield self unless order == :postorder
+      children_nodes.each do |child|
+        child.each_node(order, &block)
+      end
+      yield self if order == :postorder
+      self
+    end
+
+    def fancy_type
+      class_name = self.class.to_s.gsub(/^DeepCover::/,'').gsub(/^Node::/, '')
+      t = type.to_s
+      t.casecmp(class_name) == 0 ? t : "#{t}[#{class_name}]"
+    end
+
+  end
+end