deep-cover-core 0.6.3.pre

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module Filters
+      module ClassMethods
+        def filter_to_method_name(kind)
+          :"is_#{kind}?"
+        end
+
+        def create_filter(name, &block)
+          Filters.define_method(filter_to_method_name(name), &block)
+          OPTIONALLY_COVERED << name
+        end
+
+        def unique_filter
+          (1..Float::INFINITY).each do |i|
+            name = :"custom_filter_#{i}"
+            return name unless Filters.method_defined?(filter_to_method_name(name))
+          end
+        end
+      end
+
+      RAISING_MESSAGES = %i[raise exit].freeze
+      def is_raise?
+        is_a?(Node::Send) && RAISING_MESSAGES.include?(message) && receiver == nil
+      end
+
+      def is_warn?
+        is_a?(Node::Send) && message == :warn
+      end
+
+      def is_default_argument?
+        parent.is_a?(Node::Optarg) && simple_literal?
+      end
+
+      def is_case_implicit_else?
+        is_a?(Node::EmptyBody) && parent.is_a?(Node::Case) && !parent.has_else?
+      end
+
+      def is_trivial_if?
+        # Supports only node being a branch or the fork itself
+        parent.is_a?(Node::If) && parent.condition.simple_literal?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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.
+      # For now at least, don't return `nil`, instead return `false` in `executable?`
+      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
+
+      # Returns the counts in a hash
+      def counts
+        {flow_entry: flow_entry_count, flow_completion: flow_completion_count, execution: execution_count}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module HasChild
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      CHILDREN = {}.freeze
+      CHILDREN_TYPES = {}.freeze
+
+      def initialize(*)
+        super
+        self.validate_children_types(children)
+      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
+
+      def child_index_to_name(index)
+        self.class.child_index_to_name(index, children.size)
+      end
+
+      module ClassMethods
+        def has_child(rest_: false, refine_: false, **args)
+          raise "Needs exactly one custom named argument, got #{args.size}" if args.size != 1
+          name, types = args.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_) unless refine_
+          define_accessor(name) unless refine_
+          add_runtime_check(name, types)
+          self
+        end
+
+        def has_extra_children(**args)
+          has_child(**args, rest_: true)
+        end
+
+        def refine_child(child_name = nil, **args)
+          if child_name
+            args = {child_name => self::CHILDREN_TYPES.fetch(child_name), **args}
+          end
+          has_child(**args, refine_: 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)
+          subclass.const_set :CHILDREN, self::CHILDREN.dup
+          subclass.const_set :CHILDREN_TYPES, self::CHILDREN_TYPES.dup
+          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
+                                 if already_has_rest
+                                   raise "Class #{self} can't have extra children '#{name}' because it already has '#{name}' (#{children_map})"
+                                 end
+                                 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 <<-EVAL, __FILE__, __LINE__ + 1
+            def #{name}
+              children[CHILDREN.fetch(#{name.inspect})]
+            end
+          EVAL
+        end
+
+        def add_runtime_check(name, type)
+          self::CHILDREN_TYPES[name] = type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module HasChildHandler
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def call_child_handler(template, child, child_name = nil)
+        child_name ||= self.child_index_to_name(child.index)
+        method_name = format(template, name: child_name)
+        if respond_to?(method_name)
+          args = [child, child_name]
+          arity = method(method_name).arity
+          if arity >= 0
+            args = args[0...arity]
+          end
+          answer = send(method_name, *args)
+        end
+        answer
+      end
+      private :call_child_handler
+
+      module ClassMethods
+        def has_child_handler(template)
+          child_method_name = format(template, name: 'child')
+          action = template.gsub(/_%{name}/, '').gsub(/%{name}_/, '')
+          const_name = "#{Tools.camelize(action)}Handler"
+          class_eval <<-EVAL, __FILE__, __LINE__ + 1
+            module #{const_name}                                     # module RewriteHandler
+              module ClassMethods                                    #   module ClassMethods
+                def has_child(#{action}: nil, **args)                #     def has_child(rewrite: nil, **args)
+                  name, _types = args.first                          #       name, _types = args.first
+                  define_child_handler(#{template.inspect},          #       define_child_handler('rewrite_%{child}',
+                    name, #{action})                                 #         name, rewrite)
+                  super(**args)                                      #       super(**args)
+                end                                                  #     end
+              end                                                    #   end
+
+              def #{child_method_name}(child, name = nil)            #   def rewrite_child(child, name = nil)
+                call_child_handler(#{template.inspect}, child,       #     call_child_handler('rewrite_%{child}', child,
+                  name) || super                                     #       name) || super
+              end                                                    #   end
+            end                                                      # end
+            include #{const_name}                                    # include RewriteHandler
+            singleton_class.prepend #{const_name}::ClassMethods      # singleton_class.prepend RewriteHandler::ClassMethods
+          EVAL
+        end
+
+        def define_child_handler(template, name, action)
+          method_name = format(template, name: name)
+          case action
+          when nil
+            # Nothing to do
+          when Symbol
+            define_method(method_name) do |*args|
+              arity = method(action).arity
+              if arity < 0
+                send(action, *args)
+              else
+                send(action, *args[0...arity])
+              end
+            end
+          when Proc
+            define_method(method_name, &action)
+          else
+            define_method(method_name) { |*| action }
+          end
+        end
+        private :define_child_handler
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module HasTracker
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      TRACKERS = {}
+
+      def initialize(*)
+        @tracker_offset = tracker_storage.allocate_trackers(self.class::TRACKERS.size).begin
+        super
+      end
+
+      def tracker_storage
+        covered_code.tracker_storage
+      end
+
+      def tracker_sources
+        self.class::TRACKERS.map do |name, _|
+          [:"#{name}_tracker", send(:"#{name}_tracker_source")]
+        end.to_h
+      end
+
+      module ClassMethods
+        def inherited(base)
+          base.const_set :TRACKERS, self::TRACKERS.dup
+          super
+        end
+
+        def has_tracker(name)
+          i = self::TRACKERS[name] = self::TRACKERS.size
+          class_eval <<-EVAL, __FILE__, __LINE__ + 1
+            def #{name}_tracker_source
+              tracker_storage.tracker_source(@tracker_offset + #{i})
+            end
+            def #{name}_tracker_hits
+              tracker_storage[@tracker_offset + #{i}]
+            end
+          EVAL
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module IsStatement
+      def self.included(base)
+        base.has_child_handler('is_%{name}_statement')
+      end
+
+      def is_statement
+        parent.is_child_statement(self)
+      end
+
+      # Default child rewriting rule
+      def is_child_statement(child, name = nil)
+        :if_incompatible
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module Rewriting
+      def self.included(base)
+        base.has_child_handler('rewrite_%{name}')
+      end
+
+      # Code to add before and after the node for covering purposes
+      def rewrite
+      end
+
+      # Default child rewriting rule
+      def rewrite_child(child, name = nil)
+      end
+
+      # Replaces all the '%{local}' or '%{some_tracker}' in rewriting rules
+      def resolve_rewrite(rule, context)
+        return if rule == nil
+        sources = context.tracker_sources
+        format(rule, local: covered_code.local_var, node: '%{node}', **sources)
+      end
+
+      # Returns an array of [range, rule], where rule is a string containing '%{node}'
+      # Rules must be ordered inner-most first
+      def rewriting_rules
+        [
+          resolve_rewrite(rewrite, self),
+          resolve_rewrite(parent.rewrite_child(self), parent),
+        ].compact.map { |rule| [expression, rule] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module Wrapper
+      def initialize(base_node, **kwargs)
+        super(base_node, base_children: [base_node], **kwargs)
+      end
+
+      def executed_loc_keys
+        []
+      end
+    end
+  end
+end

data/lib/deep_cover/node/module.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'const'
+
+module DeepCover
+  class Node
+    class ModuleName < Node
+      has_child scope: [Node, nil]
+      has_child const_name: Symbol
+
+      def flow_completion_count
+        parent.execution_count
+      end
+
+      def execution_count
+        if scope
+          scope.flow_completion_count
+        else
+          super
+        end
+      end
+    end
+
+    class Module < Node
+      check_completion
+      has_tracker :body_entry
+      has_child const: {const: ModuleName}
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                rewrite: '%{body_entry_tracker};%{local}=nil;%{node}',
+                is_statement: true,
+                flow_entry_count: :body_entry_tracker_hits
+      executed_loc_keys :keyword
+
+      def execution_count
+        body_entry_tracker_hits
+      end
+    end
+
+    class Class < Node
+      check_completion
+      has_tracker :body_entry
+      has_child const: {const: ModuleName}
+      has_child inherit: [Node, nil] # TODO
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                rewrite: '%{body_entry_tracker};%{node}',
+                is_statement: true,
+                flow_entry_count: :body_entry_tracker_hits
+      executed_loc_keys :keyword
+
+      def execution_count
+        body_entry_tracker_hits
+      end
+    end
+
+    # class << foo
+    class Sclass < Node
+      has_child object: Node
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                is_statement: true
+      # TODO
+    end
+  end
+end

data/lib/deep_cover/node/root.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node::Root < Node
+    has_tracker :root
+    has_child main: Node,
+              can_be_empty: -> { Parser::Source::Range.new(covered_code.buffer, 0, 0) },
+              is_statement: true,
+              rewrite: -> {
+                "#{tracker_storage.setup_source};%{root_tracker};%{local}=nil;%{node}"
+              }
+    attr_reader :covered_code
+    alias_method :flow_entry_count, :root_tracker_hits
+
+    def initialize(child_ast, covered_code)
+      @covered_code = covered_code
+      super(nil, parent: nil, base_children: [child_ast])
+    end
+  end
+end