deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/node/base.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-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
-    include Filters
-    extend Filters::ClassMethods
-
-    attr_reader :index, :parent, :children, :base_node
-
-    def initialize(base_node, parent:, index: 0, base_children: base_node.children)
-      @base_node = base_node
-      @parent = parent
-      @index = index
-      @children = []
-      begin
-        @children = augment_children(base_children)
-        initialize_siblings
-        super()
-      rescue StandardError => e
-        diagnose(e)
-      end
-    end
-
-    ### Public API
-
-    # Search self and descendants for a particular Class or type
-    def find_all(lookup)
-      case lookup
-      when ::Module
-        each_node.grep(lookup)
-      when ::Symbol
-        each_node.find_all { |n| n.type == lookup }
-      when ::String
-        each_node.find_all { |n| n.source == lookup }
-      when ::Regexp
-        each_node.find_all { |n| n.source =~ lookup }
-      else
-        raise ::TypeError, "Expected class or symbol, got #{lookup.class}: #{lookup.inspect}"
-      end
-    end
-
-    # Shortcut to access children
-    def [](lookup)
-      if lookup.is_a?(Integer)
-        children.fetch(lookup)
-      else
-        found = find_all(lookup)
-        case found.size
-        when 1
-          found.first
-        when 0
-          raise "No children of type #{lookup}"
-        else
-          raise "Ambiguous lookup #{lookup}, found #{found}."
-        end
-      end
-    end
-
-    # Shortcut to create a node from source code
-    def self.[](source)
-      CoveredCode.new(source: source).execute_code.covered_ast
-    end
-
-    def children_nodes
-      children.select { |c| c.is_a? Node }
-    end
-    alias_method :children_nodes_in_flow_order, :children_nodes
-
-    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
-    end
-    private :initialize_siblings
-
-    # 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.respond_to? :type
-      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
-
-    private
-
-    def diagnose(exception)
-      msg = if self.class == Node
-              "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,
-      ].join("\n")
-    end
-  end
-end

data/lib/deep_cover/node/begin.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-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 < SendBase
-      include WithBlock
-    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, csend: Csend}
-      has_child args: Args
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                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
-
-      alias_method :rewrite_for_completion, :rewrite
-      def rewrite
-        if call.is_a?(Csend)
-          rewrite_for_completion.gsub('%{node}', Csend::REWRITE_SUFFIX)
-        else
-          rewrite_for_completion
-        end
-      end
-    end
-
-    # &foo
-    class BlockPass < Node
-      has_child block: Node
-      # TODO
-    end
-  end
-end

data/lib/deep_cover/node/branch.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'empty_body'
-
-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 < Node::EmptyBody
-      def initialize(other_branch:, condition:, position: true)
-        @condition = condition
-        @other_branch = other_branch
-        super(nil, parent: condition.parent, position: position)
-      end
-
-      def flow_entry_count
-        @condition.flow_completion_count - @other_branch.flow_entry_count
-      end
-    end
-  end
-end

data/lib/deep_cover/node/case.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-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: -> {
-                                if (after_then = base_node.loc.begin)
-                                  after_then.end
-                                else
-                                  base_node.loc.expression.end.succ
-                                end
-                              },
-                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 branches_summary(of_branches = branches)
-        texts = []
-        n = of_branches.size
-        if of_branches.include? self.else
-          texts << "#{'implicit ' unless has_else?}else"
-          n -= 1
-        end
-        texts.unshift "#{n} when clause#{'s' if n > 1}" if n > 0
-        texts.join(' and ')
-      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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'splat'
-
-module DeepCover
-  class Node
-    module SimpleIfEmpty
-      def simple_literal?
-        children.empty?
-      end
-    end
-
-    class Array < Node
-      include SimpleIfEmpty
-      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
-      include SimpleIfEmpty
-      has_extra_children elements: [Pair, Kwsplat]
-      executed_loc_keys :begin, :end
-    end
-  end
-end

data/lib/deep_cover/node/const.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-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