deep-cover 0.1.1

data/lib/deep_cover/node/begin.rb

@@ -0,0 +1,25 @@
+module DeepCover
+  class Node
+    class Begin < Node
+      has_extra_children expressions: Node,
+                         is_statement: true
+
+      def is_statement
+        false
+      end
+
+      def executed_loc_keys
+        # Begin is a generic grouping used in different contexts.
+        case loc_hash[:begin] && loc_hash[:begin].source
+        when nil, '(', 'begin'
+          []
+        when 'else', '#{'
+          %i[begin end]
+        else
+          warn "Unknown context for Begin node"
+          []
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/block.rb

@@ -0,0 +1,53 @@
+require_relative 'send'
+require_relative 'keywords'
+
+module DeepCover
+  class Node
+    module WithBlock
+      def flow_completion_count
+        parent.flow_completion_count
+      end
+
+      def execution_count
+        last = children_nodes.last
+        return last.flow_completion_count if last
+        super
+      end
+    end
+
+    class SendWithBlock < Node
+      include WithBlock
+      has_child receiver: [Node, nil]
+      has_child method_name: Symbol
+      has_extra_children arguments: Node
+    end
+
+    class SuperWithBlock < Node
+      include WithBlock
+      has_extra_children arguments: Node
+    end
+
+    class Block < Node
+      check_completion
+      has_tracker :body
+      has_child call: {send: SendWithBlock, zsuper: SuperWithBlock, super: SuperWithBlock}
+      has_child args: Args
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.begin.end },
+                rewrite: '%{body_tracker};%{local}=nil;%{node}',
+                flow_entry_count: :body_tracker_hits,
+                is_statement: true
+      executed_loc_keys # none
+
+      def children_nodes_in_flow_order
+        [call, args] # Similarly to a def, the body is actually not part of the flow of this node...
+      end
+    end
+
+    # &foo
+    class BlockPass < Node
+      has_child block: Node
+      # TODO
+    end
+  end
+end

data/lib/deep_cover/node/boolean.rb

@@ -0,0 +1,22 @@
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class ShortCircuit < Node
+      include Branch
+      has_tracker :conditional
+      has_child first: Node
+      has_child conditional: Node, flow_entry_count: :conditional_tracker_hits,
+        rewrite: '((%{conditional_tracker};%{node}))'
+
+      def branches
+        [
+          conditional,
+          TrivialBranch.new(first, conditional)
+        ]
+      end
+    end
+
+    And = Or = ShortCircuit
+  end
+end

data/lib/deep_cover/node/branch.rb

@@ -0,0 +1,28 @@
+module DeepCover
+  class Node
+    module Branch
+      def flow_completion_count
+        branches.map(&:flow_completion_count).inject(0, :+)
+      end
+
+      # Define in sublasses:
+      def branches
+        raise NotImplementedError
+      end
+
+      # Also define flow_entry_count
+    end
+
+    class TrivialBranch < Struct.new(:condition, :other_branch)
+      def flow_entry_count
+        condition.flow_completion_count - other_branch.flow_entry_count
+      end
+      alias_method :flow_completion_count, :flow_entry_count
+      alias_method :execution_count, :flow_entry_count
+      def executable?
+        true
+      end
+    end
+
+  end
+end

data/lib/deep_cover/node/case.rb

@@ -0,0 +1,94 @@
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class WhenCondition < Node
+      include Wrapper
+      has_tracker :entry
+      # Using && instead of ; solves a weird bug in jruby 9.1.7.0 and 9.1.9.0 (probably before too).
+      # The following will only print 'test' once
+      #    class EqEqEq; def ===(other); puts 'test'; end; end
+      #    eqeqeq = EqEqEq.new
+      #    case 1; when eqeqeq; end
+      #    case 1; when (3;eqeqeq); end
+      # See https://github.com/jruby/jruby/issues/4804
+      # This is solved in jruby 9.2.0.0, better keep the workaround
+      # for compatibility.
+      has_child condition: Node, rewrite: "(((%{entry_tracker}) && %{node}))",
+        flow_entry_count: :entry_tracker_hits
+      executed_loc_keys []
+
+      def flow_entry_count
+        entry_tracker_hits
+      end
+
+      def flow_completion_count
+        condition.flow_completion_count
+      end
+
+      def loc_hash
+        condition.loc_hash
+      end
+    end
+
+    class WhenSplatCondition < Node
+      has_tracker :entry
+      check_completion inner: '(%{entry_tracker};[%{node}])', outer: '*%{node}'
+      has_child receiver: Node
+
+      def flow_entry_count
+        entry_tracker_hits
+      end
+    end
+
+    class When < Node
+      has_tracker :body_entry
+      has_extra_children matches: { splat: WhenSplatCondition, Parser::AST::Node => WhenCondition }
+      has_child body: Node,
+        can_be_empty: -> { base_node.loc.expression.succ },
+        rewrite: ";%{body_entry_tracker};%{local}=nil;%{node}",
+        is_statement: true,
+        flow_entry_count: :body_entry_tracker_hits
+
+      def flow_entry_count
+        matches.first.flow_entry_count
+      end
+
+      def execution_count
+        matches.first.flow_completion_count
+      end
+
+      def flow_completion_count
+        body.flow_completion_count + next_sibling.flow_entry_count
+      end
+    end
+
+    class Case < Node
+      include Branch
+      has_tracker :else_entry
+      has_child evaluate: [Node, nil]
+      has_extra_children whens: When
+      has_child else: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                rewrite: -> { "#{'else;' unless has_else?}((%{else_entry_tracker};%{local}=nil;%{node}))" },
+                executed_loc_keys: [:else],
+                is_statement: true,
+                flow_entry_count: :else_entry_tracker_hits
+
+      executed_loc_keys :begin, :keyword
+
+      def branches
+        whens.map(&:body) << self.else
+      end
+
+      def execution_count
+        return evaluate.flow_completion_count if evaluate
+        flow_entry_count
+      end
+
+      def has_else?
+        !!base_node.loc.to_hash[:else]
+      end
+    end
+  end
+end

data/lib/deep_cover/node/collections.rb

@@ -0,0 +1,21 @@
+require_relative 'splat'
+
+module DeepCover
+  class Node
+    class Array < Node
+      has_extra_children elements: Node
+      executed_loc_keys :begin, :end
+    end
+
+    class Pair < Node
+      has_child key: Node
+      has_child value: Node
+      executed_loc_keys :operator
+    end
+
+    class Hash < Node
+      has_extra_children elements: [Pair, Kwsplat]
+      executed_loc_keys :begin, :end
+    end
+  end
+end

data/lib/deep_cover/node/const.rb

@@ -0,0 +1,10 @@
+module DeepCover
+  class Node::Const < Node
+    check_completion
+    has_child scope: [Node, nil]
+    has_child const_name: Symbol
+  end
+
+  class Node::Cbase < Node
+  end
+end

data/lib/deep_cover/node/def.rb

@@ -0,0 +1,38 @@
+require_relative 'arguments'
+
+module DeepCover
+  class Node::Def < Node
+    check_completion
+    has_tracker :method_call
+    has_child method_name: Symbol
+    has_child signature: Args
+    has_child body: Node,
+      rewrite: '%{method_call_tracker};%{local}=nil;%{node};',
+      can_be_empty: -> { base_node.loc.end.begin },
+      is_statement: true,
+      flow_entry_count: :method_call_tracker_hits
+    executed_loc_keys :keyword, :name
+
+    def children_nodes_in_flow_order
+      []
+    end
+  end
+
+  class Node::Defs < Node
+    check_completion
+    has_tracker :method_call
+    has_child singleton: Node, rewrite: '(%{node})'
+    has_child method_name: Symbol
+    has_child signature: Args
+    has_child body: Node,
+      rewrite: '%{method_call_tracker};%{local}=nil;%{node};',
+      can_be_empty: -> { base_node.loc.end.begin },
+      is_statement: true,
+      flow_entry_count: :method_call_tracker_hits
+    executed_loc_keys :keyword, :name, :operator
+
+    def children_nodes_in_flow_order
+      [singleton]
+    end
+  end
+end

data/lib/deep_cover/node/empty_body.rb

@@ -0,0 +1,21 @@
+module DeepCover
+  class Node::EmptyBody < Node
+    def initialize(base_node, parent: raise, index: 0, position: ChildCanBeEmpty.last_empty_position)
+      @position = position
+      @position = parent.expression.begin if @position == true # Some random position... don't rewrite!
+      super(base_node, parent: parent, index: index, base_children: [])
+    end
+
+    def type
+      :EmptyBody
+    end
+
+    def loc_hash
+      {expression: @position}
+    end
+
+    def is_statement
+      false
+    end
+  end
+end

data/lib/deep_cover/node/exceptions.rb

@@ -0,0 +1,74 @@
+require_relative 'variables'
+require_relative 'collections'
+
+module DeepCover
+  class Node
+    class Resbody < Node
+      has_tracker :entered_body
+      has_child exception: [Node::Array, nil]
+      has_child assignment: [Lvasgn, nil], flow_entry_count: :entered_body_tracker_hits
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.expression.succ },
+                flow_entry_count: :entered_body_tracker_hits,
+                is_statement: true,
+                rewrite: '((%{entered_body_tracker};%{local}=nil;%{node}))'
+
+      def is_statement
+        false
+      end
+
+      def execution_count
+        entered_body_tracker_hits
+      end
+    end
+
+    class Rescue < Node
+      has_child watched_body: Node,
+                can_be_empty: -> { base_node.loc.expression.begin },
+                is_statement: true
+      has_extra_children resbodies: Resbody
+      has_child else: Node,
+                can_be_empty: -> { base_node.loc.expression.succ },
+                flow_entry_count: :execution_count,
+                is_statement: true
+      executed_loc_keys :else
+
+      def is_statement
+        false
+      end
+
+      def flow_completion_count
+        resbodies.map(&:flow_completion_count).inject(0, :+) + self.else.flow_completion_count
+      end
+
+      def execution_count
+        watched_body.flow_completion_count
+      end
+
+      def resbodies_flow_entry_count(child)
+        prev = child.previous_sibling
+
+        if prev.equal? watched_body
+          prev.flow_entry_count - prev.flow_completion_count
+        else # RESBODIES
+          # TODO is this okay?
+          prev.exception.flow_completion_count - prev.execution_count
+        end
+      end
+    end
+
+    class Ensure < Node
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.expression.begin },
+                is_statement: true
+      has_child ensure: Node,
+                can_be_empty: -> { base_node.loc.expression.succ },
+                is_statement: true,
+                flow_entry_count: -> { body.flow_entry_count }
+
+      def flow_completion_count
+        body.flow_completion_count
+      end
+    end
+  end
+end

data/lib/deep_cover/node/if.rb

@@ -0,0 +1,36 @@
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class If < Node
+      include Branch
+      has_tracker :truthy
+      has_child condition: Node, rewrite: '((%{node}) && %{truthy_tracker})'
+      has_child true_branch: Node,
+                can_be_empty: true,
+                executed_loc_keys: -> { :else if style == :unless },
+                flow_entry_count: :truthy_tracker_hits,
+                is_statement: true
+      has_child false_branch: Node,
+                can_be_empty: true,
+                executed_loc_keys: -> { [:else, :colon] if style != :unless },
+                flow_entry_count: -> { condition.flow_completion_count - truthy_tracker_hits },
+                is_statement: true
+      executed_loc_keys :keyword, :question
+
+      def branches
+        [ true_branch, false_branch ]
+      end
+
+      def execution_count
+        condition.flow_completion_count
+      end
+
+      # returns on of %i[ternary if unless elsif]
+      def style
+        keyword = loc_hash[:keyword]
+        keyword ? keyword.source.to_sym : :ternary
+      end
+    end
+  end
+end

data/lib/deep_cover/node/keywords.rb

@@ -0,0 +1,84 @@
+require_relative 'variables'
+require_relative 'literals'
+
+module DeepCover
+  class Node
+    class Kwbegin < Node
+      has_extra_children instructions: Node,
+                         is_statement: true
+
+      def is_statement
+        false
+      end
+    end
+
+    class Return < Node
+      has_extra_children values: Node
+      # TODO
+    end
+
+    class Super < Node
+      check_completion
+      has_extra_children arguments: Node
+      # TODO
+    end
+    Zsuper = Super # Zsuper is super with no parenthesis (same arguments as caller)
+
+    class Yield < Node
+      has_extra_children arguments: Node
+      # TODO
+    end
+
+    class Break < Node
+      has_extra_children arguments: Node
+      # TODO Anything special needed for the arguments?
+
+      def flow_completion_count
+        0
+      end
+    end
+
+    class Next < Node
+      has_extra_children arguments: Node
+      # TODO Anything special needed for the arguments?
+
+      def flow_completion_count
+        0
+      end
+    end
+
+    class Alias < Node
+      check_completion
+      has_child alias: [Sym, Dsym, Gvar, BackRef]
+      has_child original: [Sym, Dsym, Gvar, BackRef]
+      # TODO: test
+    end
+
+    class NeverEvaluated < Node
+      has_extra_children whatever: [:any], remap: {Parser::AST::Node => NeverEvaluated}
+
+      def executable?
+        false
+      end
+    end
+
+    class Defined < Node
+      has_child code: {Parser::AST::Node => NeverEvaluated}
+      # TODO: test
+    end
+
+    class Undef < Node
+      check_completion
+      has_extra_children arguments: [Sym, Dsym]
+      # TODO: test
+    end
+
+    class Return < Node
+      include ExecutedAfterChildren
+
+      def flow_completion_count
+        0
+      end
+    end
+  end
+end