deep-cover 0.1.1

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

@@ -0,0 +1,73 @@
+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.class.child_index_to_name(child.index, children.size) rescue binding.pry
+        method_name = 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 = template % {name: 'child'}
+          action = template.gsub(/_%{name}/, '').gsub(/%{name}_/, '')
+          const_name = "#{Tools.camelize(action)}Handler"
+          class_eval <<-end_eval, __FILE__, __LINE__
+            module #{const_name}                                     # module RewriteHandler
+              module ClassMethods                                    #   module ClassMethods
+                def has_child(#{action}: nil, **h)                   #     def has_child(rewrite: nil, **h)
+                  name, _types = h.first                             #       name, _types = h.first
+                  define_child_handler(#{template.inspect},          #       define_child_handler('rewrite_%{child}',
+                    name, #{action})                                 #         name, rewrite)
+                  super(**h)                                         #       super(**h)
+                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
+          end_eval
+        end
+
+        def define_child_handler(template, name, action)
+          method_name = 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,44 @@
+module DeepCover
+  module Node::Mixin
+    module HasTracker
+      def self.included(base)
+        base.extend ClassMethods
+        setup_constants(base)
+      end
+
+      def self.setup_constants(base)
+        base.const_set :TRACKERS, {}
+      end
+
+      def initialize(*)
+        @tracker_offset = covered_code.allocate_trackers(self.class::TRACKERS.size).begin
+        super
+      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)
+          super
+          HasTracker.setup_constants(base)
+        end
+
+        def has_tracker(name)
+          i = self::TRACKERS[name] = self::TRACKERS.size
+          class_eval <<-end_eval, __FILE__, __LINE__ + 1
+            def #{name}_tracker_source
+              covered_code.tracker_source(@tracker_offset + #{i})
+            end
+            def #{name}_tracker_hits
+              covered_code.tracker_hits(@tracker_offset + #{i})
+            end
+          end_eval
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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,32 @@
+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
+
+      def resolve_rewrite(rule, context)
+        rule ||= '%{node}'
+        sources = context.tracker_sources
+        rule.split('%{node}').map{|s| s % {local: covered_code.local_var, **sources} }
+      end
+
+      def rewrite_prefix_suffix
+        parent_prefix, parent_suffix = resolve_rewrite(parent.rewrite_child(self), parent)
+        prefix, suffix = resolve_rewrite(rewrite, self)
+        [
+          "#{parent_prefix}#{prefix}",
+          "#{suffix}#{parent_suffix}"
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+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,64 @@
+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,18 @@
+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: -> {
+                "#{covered_code.trackers_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

data/lib/deep_cover/node/send.rb

@@ -0,0 +1,83 @@
+require_relative 'literals'
+
+module DeepCover
+  class Node
+    class MethodName < Node
+      has_child name: Symbol
+
+      def initialize(name, parent: raise, **kwargs)
+        super(parent, **kwargs, parent: parent, base_children: [name])
+      end
+
+      def loc_hash
+        # Expression is used in the rewriting
+        # if selector_end is present, then this won't be needed
+        {expression: parent.loc_hash[:selector_begin]}
+      end
+
+      def executable?
+        false
+      end
+    end
+
+    class Send < Node
+      check_completion
+      has_child receiver: [Node, nil]
+      has_child method_name_wrapper: {Symbol => MethodName}, rewrite: :add_opening_parentheses
+      has_extra_children arguments: Node, rewrite: :add_closing_parentheses
+      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
+
+      def method_name
+        method_name_wrapper.name
+      end
+
+      def loc_hash
+        base = super
+        hash = { expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
+        selector = base[:selector]
+
+        if [:[], :[]=].include?(method_name)
+          hash[:selector_begin] = selector.resize(1)
+          hash[:selector_end] = Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos)
+        else
+          hash[:selector_begin] = base[:selector]
+        end
+
+        hash
+      end
+
+      # Only need to add them to deal with ambiguous cases where a method is hidden by a local. Ex:
+      #   raise TypeError, 'hello'  #=> Works
+      #   raise (TypeError), 'hello'  #=> Simplification of what DeepCover generates, still works
+      #   raise = 1; raise TypeError, 'hello'  #=> works
+      #   raise = 1; raise (TypeError), 'hello'  #=> syntax error.
+      #   raise = 1; raise((TypeError), 'hello'0  #=> works
+      def add_parentheses?
+        return if arguments.empty?
+        # No ambiguity if there is a receiver
+        return if receiver
+        # Already has parentheses
+        return if self.loc_hash[:begin]
+        true
+      end
+
+      def add_opening_parentheses
+        return unless add_parentheses?
+        "%{node}("
+      end
+
+      def add_closing_parentheses(child)
+        return unless add_parentheses?
+        return unless child.index == children.size - 1
+        "%{node})"
+      end
+    end
+
+    class MatchWithLvasgn < Node
+      check_completion
+      has_child receiver: Regexp
+      has_child compare_to: Node
+      # TODO: test
+    end
+  end
+end

data/lib/deep_cover/node/splat.rb

@@ -0,0 +1,13 @@
+module DeepCover
+  class Node
+    class Splat < Node
+      check_completion inner: '[%{node}]', outer: '*%{node}'
+      has_child receiver: Node
+    end
+
+    class Kwsplat < Node
+      check_completion inner: '{%{node}}', outer: '**%{node}'
+      has_child receiver: Node
+    end
+  end
+end

data/lib/deep_cover/node/variables.rb

@@ -0,0 +1,14 @@
+module DeepCover
+  class Node
+    class Variable < Node
+      has_child var_name: Symbol
+    end
+    Ivar = Lvar = Cvar = Gvar = BackRef = Variable
+
+    # $1
+    class NthRef < Node
+      has_child n: Integer
+      # TODO
+    end
+  end
+end

data/lib/deep_cover/parser_ext/range.rb

@@ -0,0 +1,40 @@
+class Parser::Source::Range
+  def with(begin_pos: @begin_pos, end_pos: @end_pos)
+    Parser::Source::Range.new(@source_buffer, begin_pos, end_pos)
+  end
+
+  # Similar to `end`, but is just after the current Range
+  def succ
+    with begin_pos: @end_pos+1, end_pos: @end_pos+1
+  end
+
+  # (1...10).split(2...3, 6...8) => [1...2, 3...6, 7...10]
+  # Assumes inner_ranges are exclusive, and included in self
+  def split(*inner_ranges)
+    inner_ranges.sort_by!(&:begin_pos)
+    [self.begin, *inner_ranges, self.end]
+      .each_cons(2)
+      .map{|i, j| with(begin_pos: i.end_pos, end_pos: j.begin_pos)}
+      .reject(&:empty?)
+  end
+
+  def lstrip(pattern = /\s*/)
+    if (match = /^#{pattern}/.match(source))
+      with(begin_pos: @begin_pos + match[0].length)
+    else
+      self
+    end
+  end
+
+  def rstrip(pattern = /\s*/)
+    if (match = /#{pattern}$/.match(source))
+      with(end_pos: @end_pos - match[0].length)
+    else
+      self
+    end
+  end
+
+  def strip(pattern = /\s*/)
+    lstrip(pattern).rstrip(pattern)
+  end
+end

data/lib/deep_cover/reporter.rb

@@ -0,0 +1,6 @@
+module DeepCover
+  module Reporter
+  end
+  require_relative 'node'
+  require_relative_dir 'reporter'
+end

data/lib/deep_cover/reporter/istanbul.rb

@@ -0,0 +1,151 @@
+require 'json'
+
+module DeepCover
+  module Reporter
+    class Istanbul < Struct.new(:covered_code, :options)
+      # Converters has no dependency on the including class.
+      module Converters
+        def convert_range(range)
+          { start: {
+              line: range.line,
+              column: range.column,
+            },
+            end: {
+              line: range.last_line,
+              column: range.last_column-1, # Our ranges are exclusive, Istanbul's are inclusive
+            },
+          }
+        end
+
+        # [:a, :b, :c] => {'1': :a, '2': :b, '3': :c}
+        def convert_list(list)
+          list.map.with_index{ |val, i| [i.succ.to_s, val] }.to_h
+        end
+
+        def convert_def(node)
+          ends_at = node.signature.loc_hash[:end] || node.loc_hash[:name]
+          decl = node.loc_hash[:keyword].with(end_pos: ends_at.end_pos)
+          _convert_function(node, node.method_name, decl)
+        end
+
+        def convert_block(node)
+          decl = node.loc_hash[:begin]
+          if (args = node.args.expression)
+            decl = decl.join(args) rescue binding.pry
+          end
+          _convert_function(node, '(block)', decl)
+        end
+
+        def convert_function(node)
+          if node.is_a?(Node::Block)
+            convert_block(node)
+          else
+            convert_def(node)
+          end
+        end
+
+        def convert_branch(node, branches = node.branches)
+          # Currently, nyc seems to outputs the same location over and over...
+          loc = convert_range(node.expression)
+          {
+            loc: loc,
+            type: node.type,
+            line: node.expression.line,
+            locations: branches.map{|n| loc}
+          }
+        end
+
+        private
+        def _convert_function(node, name, decl)
+          loc = node.body ? node.body.expression : decl.end
+          {
+            name: name,
+            line: node.expression.line,
+            decl: convert_range(decl),
+            loc:  convert_range(loc),
+          }
+        end
+      end
+      include Converters
+
+      def node_analyser
+        @node_analyser ||= Analyser::Node.new(covered_code, **options)
+      end
+
+      def node_runs
+        @node_runs ||= node_analyser.results
+      end
+
+      def functions
+        @functions ||= Analyser::Function.new(node_analyser, **options).results
+      end
+
+      def statements
+        @statements ||= Analyser::Statement.new(node_analyser, **options).results
+      end
+
+      def branches
+        @branches ||= Analyser::Branch.new(node_analyser, **options).results
+      end
+
+      def branch_map
+        branches.map do |node, branches_runs|
+          convert_branch(node, branches_runs.keys)
+        end
+      end
+
+      # Istanbul doesn't understand how to ignore a branch...
+      def zero_to_something(values)
+        values.map{|v| v || 1}
+      end
+
+      def branch_runs
+        branches.values.map{|r| zero_to_something(r.values) }
+      end
+
+      def statement_map
+        statements.keys.map{ |range| convert_range(range) }
+      end
+
+      def statement_runs
+        statements.values
+      end
+
+      def function_map
+        functions.keys.map{|n| convert_function(n) }
+      end
+
+      def function_runs
+        functions.values
+      end
+
+      def data
+        {
+          statementMap: statement_map ,
+          s:            statement_runs,
+          fnMap:        function_map  ,
+          f:            function_runs ,
+          branchMap:    branch_map    ,
+          b:            branch_runs   ,
+        }
+      end
+
+      def convert
+        { covered_code.name => {
+            path: covered_code.path,
+            **data.transform_values{|l| convert_list(l)},
+        } }
+      end
+
+      def report
+        convert.to_json
+      end
+
+      class << self
+        def available?
+          `nyc --version` >= '11.' rescue false
+        end
+      end
+    end
+  end
+end