deep-cover 0.6.2 → 0.6.3.pre

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-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)
-        if child_base_nodes.size < (sz = self.class.min_children)
-          child_base_nodes = child_base_nodes.dup
-          child_base_nodes[sz..-1] = [] # Fill with nil
-        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)
-          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, **args)
-          name, types = args.first
-          if types.is_a? Hash
-            raise 'Use either remap or a hash as type but not both' if remap
-            remap = types
-            args[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(**args, remap: remap)
-        end
-      end
-    end
-  end
-end

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

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

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

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-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
-        return [] unless executable?
-        loc_hash.keys - [:expression]
-      end
-
-      def child_executed_loc_keys(_child, _child_name)
-        nil
-      end
-
-      def executed_loc_hash
-        h = Tools.slice(loc_hash, *executed_loc_keys)
-        if (keys = parent.child_executed_loc_keys(self))
-          h.merge!(Tools.slice(parent.loc_hash, *keys))
-        end
-        h.reject { |k, v| v.nil? }
-      end
-
-      def executed_locs
-        executed_loc_hash.values
-      end
-
-      def loc_hash
-        base_node.respond_to?(:location) ? base_node.location.to_hash : {}
-      end
-
-      def expression
-        loc_hash[:expression]
-      end
-
-      def source
-        expression.source if expression
-      end
-
-      def diagnostic_expression
-        expression || parent.diagnostic_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
-      end
-    end
-  end
-end

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

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

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

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