deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/node/empty_body.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  class Node::EmptyBody < Node
-    def initialize(base_node, parent:, index: 0, position: ChildCanBeEmpty.last_empty_position)
-      @position = position
-      super(base_node, parent: parent, index: index, base_children: [])
-    end
-
-    def type
-      :EmptyBody
-    end
-
-    def loc_hash
-      return {} if @position == true
-      {expression: @position}
-    end
-
-    def is_statement
-      false
-    end
-
-    # When parent rewrites us, the %{node} must always be at the beginning because our location can
-    # also be rewritten by out parent, and we want the rewrite to be after it.
-    def rewriting_rules
-      rules = super
-      rules.map do |expression, rule|
-        [expression, "%{node};#{rule.sub('%{node}', 'nil;')}"]
-      end
-    end
-  end
-end

data/lib/deep_cover/node/exceptions.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-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.begin || base_node.loc.expression.succ).end },
-                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.end },
-                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
-          if prev.exception # rubocop:disable Style/IfInsideElse
-            prev.exception.flow_completion_count - prev.execution_count
-          else
-            prev.flow_entry_count - prev.execution_count
-          end
-        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.end.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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-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,
-                executed_loc_keys: -> { :else if style == :unless },
-                flow_entry_count: :truthy_tracker_hits,
-                is_statement: true
-      has_child false_branch: Node,
-                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 child_can_be_empty(child, name)
-        return false if name == :condition || style == :ternary
-        if (name == :true_branch) == [:if, :elsif].include?(style)
-          (base_node.loc.begin || base_node.children[0].loc.expression.succ).end
-        elsif has_else?
-          base_node.loc.else.end.succ
-        else
-          true # implicit else
-        end
-      end
-
-      def branches
-        [true_branch, false_branch]
-      end
-
-      def branches_summary(of_branches = branches)
-        of_branches.map do |jump|
-          "#{'implicit ' if jump.is_a?(EmptyBody) && !has_else?}#{jump == false_branch ? 'falsy' : 'truthy'} branch"
-        end.join(' and ')
-      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
-
-      def root_if_node
-        if style != :elsif
-          self
-        else
-          parent.root_if_node
-        end
-      end
-
-      def deepest_elsif_node
-        return if style != :elsif
-        return self if loc_hash[:else] && loc_hash[:else].source == 'else'
-        return self if false_branch.is_a?(EmptyBody)
-        false_branch.deepest_elsif_node
-      end
-
-
-      def has_else?
-        !!base_node.loc.to_hash[:else]
-      end
-    end
-  end
-end

data/lib/deep_cover/node/keywords.rb

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

data/lib/deep_cover/node/literals.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'begin'
-require_relative 'variables'
-require_relative 'collections'
-module DeepCover
-  class Node
-    def simple_literal?
-      false
-    end
-
-    class StaticLiteral < Node
-      executed_loc_keys :expression
-
-      def simple_literal?
-        true
-      end
-    end
-
-    # Singletons
-    class SingletonLiteral < StaticLiteral
-    end
-    True = False = Nil = Self = SingletonLiteral
-
-    # Atoms
-    def self.atom(type)
-      ::Class.new(StaticLiteral) do
-        has_child value: type
-      end
-    end
-    Sym = atom(::Symbol)
-    Int = atom(::Integer)
-    Float = atom(::Float)
-    Complex = atom(::Complex)
-    Rational = atom(::Rational)
-    class Regopt < StaticLiteral
-      has_extra_children options: [::Symbol]
-    end
-
-    class Str < StaticLiteral
-      has_child value: ::String
-
-      def executed_loc_keys
-        keys = [:expression, :heredoc_body, :heredoc_end]
-
-        exp = expression
-        keys.delete(:expression) if exp && exp.source !~ /\S/
-
-        hd_body = loc_hash[:heredoc_body]
-        keys.delete(:heredoc_body) if hd_body && hd_body.source !~ /\S/
-
-        keys
-      end
-    end
-
-    # (Potentially) dynamic
-    module SimpleIfItsChildrenAre
-      def simple_literal?
-        children.all?(&:simple_literal?)
-      end
-    end
-
-    # Di-atomic
-    class Range < Node
-      include SimpleIfItsChildrenAre
-
-      has_child from: Node
-      has_child to: Node
-    end
-    Erange = Irange = Range
-
-    # Dynamic
-    def self.has_evaluated_segments
-      has_extra_children constituents: [Str, Begin, Ivar, Cvar, Gvar, Dstr, NthRef]
-    end
-    class DynamicLiteral < Node
-      def executed_loc_keys
-        if loc_hash[:heredoc_end]
-          [:expression, :heredoc_end]
-        else
-          [:begin, :end]
-        end
-      end
-    end
-    Dsym = Dstr = DynamicLiteral
-    DynamicLiteral.has_evaluated_segments
-
-    class Regexp < Node
-      include SimpleIfItsChildrenAre
-
-      has_evaluated_segments
-      has_child option: Regopt
-    end
-
-    class Xstr < Node
-      check_completion
-      has_evaluated_segments
-    end
-  end
-end

data/lib/deep_cover/node/loops.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  class Node
-    class For < Node
-      has_tracker :body
-      has_child assignments: [Mlhs, VariableAssignment], flow_entry_count: -> { body.flow_entry_count if body }
-      has_child iterable: [Node], flow_entry_count: -> { flow_entry_count }
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                flow_entry_count: :body_tracker_hits,
-                rewrite: '(%{body_tracker};%{local}=nil;%{node})'
-      check_completion
-
-      def execution_count
-        iterable.flow_completion_count
-      end
-    end
-
-    class Until < Node
-      has_tracker :body
-      has_child condition: Node, rewrite: '((%{node})) || (%{body_tracker};false)'
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                flow_entry_count: :body_tracker_hits
-      check_completion
-
-      def execution_count
-        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
-        condition.flow_completion_count
-      end
-    end
-
-    class UntilPost < Node
-      has_tracker :body
-      has_child condition: Node, rewrite: '((%{node})) || (%{body_tracker};false)'
-      has_child body: Kwbegin, flow_entry_count: -> { body_tracker_hits + parent.flow_entry_count }
-      check_completion
-
-      def execution_count
-        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
-        body.flow_completion_count
-      end
-      # TODO: test
-    end
-
-    class While < Node
-      has_tracker :body
-      has_child condition: Node, rewrite: '((%{node})) && %{body_tracker}'
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                flow_entry_count: :body_tracker_hits
-      check_completion
-
-      def execution_count
-        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
-        condition.flow_completion_count
-      end
-    end
-
-    class WhilePost < Node
-      has_tracker :body
-      has_child condition: Node, rewrite: '((%{node})) && %{body_tracker}'
-      has_child body: Kwbegin, flow_entry_count: -> { body_tracker_hits + parent.flow_entry_count }
-      check_completion
-
-      def execution_count
-        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
-        body.flow_completion_count
-      end
-      # TODO: test
-    end
-  end
-end