deep-cover 0.1.1

data/lib/deep_cover/node/literals.rb

@@ -0,0 +1,77 @@
+require_relative 'begin'
+require_relative 'variables'
+module DeepCover
+  class Node
+    # Singletons
+    class SingletonLiteral < Node
+      executed_loc_keys :expression
+    end
+    True = False = Nil = SingletonLiteral
+
+    # Atoms
+    def self.atom(type)
+      ::Class.new(Node) do
+        has_child value: type
+        executed_loc_keys :expression
+      end
+    end
+    Sym = atom(::Symbol)
+    Int = atom(::Integer)
+    Float = atom(::Float)
+    Complex = atom(::Complex)
+    Rational = atom(::Rational)
+    class Regopt < Node
+      has_extra_children options: [::Symbol]
+      executed_loc_keys :expression
+    end
+
+    class Str < Node
+      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
+
+    # Di-atomic
+    class Range < Node
+      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
+      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

@@ -0,0 +1,72 @@
+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

data/lib/deep_cover/node/mixin/can_augment_children.rb

@@ -0,0 +1,65 @@
+module DeepCover
+  module Node::Mixin
+    module CanAugmentChildren
+      def self.included(base)
+        base.has_child_handler('remap_%{name}')
+        base.singleton_class.prepend ClassMethods
+      end
+
+      # Augment creates a covered node from the child_base_node.
+      # Caution: receiver is not fully constructed since it is also being augmented.
+      #          don't call `children`
+      def augment_children(child_base_nodes)
+        missing = self.class.min_children - child_base_nodes.size
+        if missing > 0
+          child_base_nodes = [*child_base_nodes, *Array.new(missing)]
+        end
+        child_base_nodes.map.with_index do |child, child_index|
+          child_name = self.class.child_index_to_name(child_index, child_base_nodes.size) rescue binding.pry
+
+          if (klass = remap_child(child, child_name))
+            klass.new(child, parent: self, index: child_index)
+          else
+            child
+          end
+        end
+      end
+      private :augment_children
+
+      def remap_child(child, name=nil)
+        return unless child.is_a?(Parser::AST::Node)
+        class_name = Tools.camelize(child.type)
+        Node.const_defined?(class_name) ? Node.const_get(class_name) : Node
+      end
+
+      module ClassMethods
+
+        # This handles the following shortcuts:
+        #   has_child foo: {type: NodeClass, ...}
+        # same as:
+        #   has_child foo: [], remap: {type: NodeClass, ...}
+        # same as:
+        #   has_child foo: [NodeClass, ...], remap: {type: NodeClass, ...}
+        #
+        def has_child(remap: nil, **h)
+          name, types = h.first
+          if types.is_a? Hash
+            raise "Use either remap or a hash as type but not both" if remap
+            remap = types
+            h[name] = types = []
+          end
+          if remap.is_a? Hash
+            type_map = remap
+            remap = -> (child) do
+              klass = type_map[child.type] if child.respond_to? :type
+              klass ||= type_map[child.class]
+              klass
+            end
+            types.concat(type_map.values).uniq!
+          end
+          super(**h, remap: remap)
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/check_completion.rb

@@ -0,0 +1,16 @@
+require_relative 'executed_after_children'
+
+module DeepCover
+  module Node::Mixin
+    module CheckCompletion
+      def check_completion(outer:'(%{node})', inner:'(%{node})')
+        has_tracker :completion
+        include ExecutedAfterChildren
+        alias_method :flow_completion_count, :completion_tracker_hits
+        pre, post = outer.split('%{node}')
+        # The local=local is to avoid Ruby warning about "Possible use of value in void context"
+        define_method(:rewrite) { "#{pre}(%{local}=#{inner};%{completion_tracker};%{local}=%{local})#{post}" }
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/child_can_be_empty.rb

@@ -0,0 +1,25 @@
+module DeepCover
+  module Node::Mixin
+    module ChildCanBeEmpty
+      class << self
+        attr_accessor :last_empty_position # Ugly hack to pass info from Handler to constructor
+        def included(base)
+          base.has_child_handler('%{name}_can_be_empty')
+        end
+      end
+
+      def remap_child(child, name=raise)
+        if child == nil
+          if (ChildCanBeEmpty.last_empty_position = child_can_be_empty(child, name))
+            return Node::EmptyBody
+          end
+        end
+        super
+      end
+
+      def child_can_be_empty(_child, _name=nil)
+        false
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/executed_after_children.rb

@@ -0,0 +1,13 @@
+module DeepCover
+  module Node::Mixin
+    # By default, nodes are considered executed if they are entered.
+    # Some are considered executed only if their arguments complete.
+    module ExecutedAfterChildren
+      def execution_count
+        last = children_nodes_in_flow_order.last
+        return last.flow_completion_count if last
+        super
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/execution_location.rb

@@ -0,0 +1,56 @@
+module DeepCover
+  module Node::Mixin
+    module ExecutionLocation
+      def self.included(base)
+        base.extend ClassMethods
+        base.has_child_handler('%{name}_executed_loc_keys')
+      end
+
+      module ClassMethods
+        # Macro to define the executed_loc_keys
+        def executed_loc_keys(*loc_keys)
+          # #flatten allows passing an empty array to be explicit
+          loc_keys = loc_keys.flatten
+          define_method :executed_loc_keys do
+            loc_keys
+          end
+        end
+      end
+
+      def executed_loc_keys
+        loc_hash.keys - [:expression]
+      end
+
+      def child_executed_loc_keys(_child, _child_name)
+        nil
+      end
+
+      def executed_locs
+        if (keys = parent.child_executed_loc_keys(self))
+          inherited = parent.loc_hash.values_at(*keys)
+        end
+        [  *loc_hash.values_at(*executed_loc_keys),
+           *inherited
+        ].compact
+      end
+
+      def loc_hash
+        @loc_hash ||= base_node.location.to_hash
+      end
+
+      def expression
+        loc_hash[:expression]
+      end
+
+      def source
+        expression.source if expression
+      end
+
+      # Returns an array of character numbers (in the original buffer) that
+      # pertain exclusively to this node (and thus not to any children).
+      def proper_range
+        executed_locs.map(&:to_a).inject([], :+).uniq rescue binding.pry
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/flow_accounting.rb

@@ -0,0 +1,63 @@
+module DeepCover
+  module Node::Mixin
+    module FlowAccounting
+      def self.included(base)
+        base.has_child_handler('%{name}_flow_entry_count')
+      end
+
+      # Returns true iff it is executable and if was successfully executed
+      def was_executed?
+        # There is a rare case of non executable nodes that have important data in flow_entry_count / flow_completion_count,
+        # like `if cond; end`, so make sure it's actually executable first...
+        executable? && execution_count > 0
+      end
+
+      # Returns the control flow entered the node.
+      # The control flow can then either complete normally or be interrupted
+      #
+      # Implementation: This is always the responsibility of the parent; Nodes should not override.
+      def flow_entry_count
+        parent.child_flow_entry_count(self)
+      end
+
+      # Returns the number of times it changed the usual control flow (e.g. raised, returned, ...)
+      # Implementation: This is always deduced; Nodes should not override.
+      def flow_interrupt_count
+        flow_entry_count - flow_completion_count
+      end
+
+      ### These are refined by subclasses
+
+      # Returns true iff it is executable. Keywords like `end` are not executable, but literals like `42` are executable.
+      def executable?
+        true
+      end
+
+      # Returns number of times the node itself was "executed". Definition of executed depends on the node.
+      def execution_count
+        flow_entry_count
+      end
+
+      # Returns the number of times the control flow succesfully left the node.
+      # This is the responsability of the child Node, never of the parent.
+      # Must be refined if the child node may have an impact on control flow (raising, branching, ...)
+      def flow_completion_count
+        last = children_nodes_in_flow_order.last
+        return last.flow_completion_count if last
+        flow_entry_count
+      end
+
+      # Returns the number of time the control flow entered this child_node.
+      # This is the responsability of the Node, not of the child.
+      # Must be refined if the parent node may have an impact on control flow (raising, branching, ...)
+      def child_flow_entry_count(child, _name = nil)
+        prev = child.previous_sibling
+        if prev
+          prev.flow_completion_count
+        else
+          flow_entry_count
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/has_child.rb

@@ -0,0 +1,138 @@
+module DeepCover
+  module Node::Mixin
+    module HasChild
+      def self.included(base)
+        base.extend ClassMethods
+        setup_constants(base)
+      end
+
+      def self.setup_constants(subclass)
+        subclass.const_set :CHILDREN, {}
+        subclass.const_set :CHILDREN_TYPES, {}
+      end
+
+
+      def initialize(*)
+        super
+        self.validate_children_types(children) rescue binding.pry
+      end
+
+      def validate_children_types(nodes)
+        mismatches = self.class.check_children_types(nodes)
+        unless mismatches.empty?
+          raise TypeError, "Invalid children types for #{self.class}(type: #{self.type}): #{mismatches}"
+        end
+      end
+
+      module ClassMethods
+        def has_child(rest: false, **h)
+          raise "Needs exactly one custom named argument, got #{h.size}" if h.size != 1
+          name, types = h.first
+          raise TypeError, "Expect a Symbol for name, got a #{name.class} (#{name.inspect})" unless name.is_a?(Symbol)
+          update_children_const(name, rest: rest)
+          define_accessor(name)
+          add_runtime_check(name, types)
+          self
+        end
+
+        def has_extra_children(**h)
+          has_child(**h, rest: true)
+        end
+
+        def child_index_to_name(index, nb_children)
+          self::CHILDREN.each do |name, i|
+            return name if i == index || (i == index - nb_children) ||
+              (i.is_a?(Range) && i.begin <= index && i.end + nb_children >= index)
+          end
+          raise IndexError, "index #{index} does not correspond to any child of #{self}"
+        end
+
+        def check_children_types(nodes)
+          types = expected_types(nodes)
+          nodes_mismatches(nodes, types)
+        end
+
+        def min_children
+          self::CHILDREN.values.grep(Integer).size
+        end
+
+        private
+
+        def expected_types(nodes)
+          self::CHILDREN.flat_map do |name, i|
+            type = self::CHILDREN_TYPES[name]
+            Array.new(nodes.values_at(i).size, type)
+          end
+        end
+
+        def nodes_mismatches(nodes, types)
+          nodes = nodes.dup
+          nodes[nodes.size...types.size] = nil
+          nodes.zip(types).reject do |node, type|
+            node_matches_type?(node, type)
+          end
+        end
+
+        def node_matches_type?(node, expected)
+          case expected
+          when :any
+            true
+          when nil
+            node.nil?
+          when Array
+            expected.any? {|exp| node_matches_type?(node, exp) }
+          when Class
+            node.is_a?(expected)
+          when Symbol
+            node.is_a?(Node) && node.type == expected
+          else
+            raise "Unrecognized expected type #{expected}"
+          end
+        end
+
+        def inherited(subclass)
+          HasChild.setup_constants(subclass)
+          super
+        end
+
+        def const_missing(name)
+          const_set(name, self::CHILDREN.fetch(name.downcase) { return super })
+        end
+
+        def update_children_const(name, rest: false)
+          children_map = self::CHILDREN
+          already_has_rest = false
+          children_map.each do |key, value|
+            if value.is_a? Range
+              children_map[key] = children_map[key].begin..(children_map[key].end - 1)
+              already_has_rest = key
+            elsif value < 0
+              children_map[key] -= 1
+            end
+          end
+          children_map[name] = if rest
+            raise "Class #{self} can't have extra children '#{name}' because it already has '#{name}' (#{children_map.inspect})" if already_has_rest
+            children_map.size..-1
+          elsif already_has_rest
+            -1
+          else
+            children_map.size
+          end
+        end
+
+        def define_accessor(name)
+          warn "child name '#{name}' conflicts with existing method for #{self}" if method_defined? name
+          class_eval <<-end_eval, __FILE__, __LINE__
+            def #{name}
+              children[#{name.upcase}]
+            end
+          end_eval
+        end
+
+        def add_runtime_check(name, type)
+          self::CHILDREN_TYPES[name] = type
+        end
+      end
+    end
+  end
+end