deep-cover 0.1.1 → 0.1.2

data/lib/deep_cover/config.rb

@@ -6,8 +6,8 @@ module DeepCover
       allow_partial: false,
     }
 
-    def initialize
-      @options = copy(DEFAULTS)
+    def initialize(**options)
+      @options = copy(DEFAULTS.merge(options))
     end
 
     def to_hash
@@ -16,12 +16,14 @@ module DeepCover
     alias_method :to_h, :to_hash
 
     def ignore_uncovered(*keywords)
-      @options[:ignore_uncovered] -= keywords
+      check_uncovered(keywords)
+      @options[:ignore_uncovered] += keywords
       self
     end
 
     def detect_uncovered(*keywords)
-      @options[:ignore_uncovered] += keywords
+      check_uncovered(keywords)
+      @options[:ignore_uncovered] -= keywords
       self
     end
 
@@ -31,20 +33,27 @@ module DeepCover
     end
 
     private
+    def check_uncovered(keywords)
+      unknown = keywords - Analyser.optionally_covered
+      raise ArgumentError, "unknown options: #{unknown.join(', ')}" unless unknown.empty?
+    end
+
     def copy(h)
       h.dup.transform_values(&:dup)
     end
 
     module Setter
-      def configure(&block)
+      def config
         @config ||= Config.new
+      end
 
+      def configure(&block)
         raise "Must provide a block" unless block
         case block.arity
         when 0
-          @config.instance_eval(&block)
+          config.instance_eval(&block)
         when 1
-          block.call(@config)
+          block.call(config)
         end
       end
     end

data/lib/deep_cover/coverage.rb

@@ -4,7 +4,6 @@ module DeepCover
     require 'parser/current'
   end
   require 'pry'
-  require 'pathname'
   require_relative 'covered_code'
   require 'securerandom'
 
@@ -29,9 +28,9 @@ module DeepCover
       covered_code(filename).line_coverage(**options)
     end
 
-    def covered_code(path)
+    def covered_code(path, **options)
       raise 'path must be an absolute path' unless Pathname.new(path).absolute?
-      @covered_codes[path] ||= CoveredCode.new(path: path, **@options)
+      @covered_codes[path] ||= CoveredCode.new(path: path, **options, **@options)
     end
 
     def each
@@ -57,7 +56,7 @@ module DeepCover
 
     def report_istanbul(output: nil, **options)
       dir = output_istanbul(**options).dirname
-      if output
+      unless [nil, '', 'false'].include? output
         output = File.expand_path(output)
         html = "--reporter=html --report-dir='#{output}' && open '#{output}/index.html'"
       end
@@ -89,8 +88,8 @@ module DeepCover
       end
     end
 
-    def self.load(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).load
+    def self.load(dest_path, dirname = 'deep_cover', with_trackers: true)
+      Persistence.new(dest_path, dirname).load(with_trackers: with_trackers)
     end
 
     def self.saved?(dest_path, dirname = 'deep_cover')
@@ -108,7 +107,7 @@ module DeepCover
     end
 
     def tracker_global
-      @options[:tracker_global]
+      @options.fetch(:tracker_global, CoveredCode::DEFAULT_TRACKER_GLOBAL)
     end
 
     class Persistence
@@ -120,9 +119,9 @@ module DeepCover
         @dir_path = Pathname(dest_path).join(dirname).expand_path
       end
 
-      def load
+      def load(with_trackers: true)
         saved?
-        load_trackers
+        load_trackers if with_trackers
         load_coverage
       end
 

data/lib/deep_cover/covered_code.rb

@@ -1,10 +1,12 @@
 module DeepCover
   class CoveredCode
-    attr_accessor :covered_source, :buffer, :tracker_global, :local_var
+    DEFAULT_TRACKER_GLOBAL = '$_cov'
+
+    attr_accessor :covered_source, :buffer, :tracker_global, :local_var, :name
     @@counter = 0
     @@globals = Hash.new{|h, global| h[global] = eval("#{global} ||= {}") }
 
-    def initialize(path: nil, source: nil, lineno: nil, tracker_global: '$_cov', local_var: '_temp')
+    def initialize(path: nil, source: nil, lineno: nil, tracker_global: DEFAULT_TRACKER_GLOBAL, local_var: '_temp', name: nil)
       raise "Must provide either path or source" unless path || source
 
       @buffer = ::Parser::Source::Buffer.new(path)
@@ -17,6 +19,7 @@ module DeepCover
       @tracker_count = 0
       @tracker_global = tracker_global
       @local_var = local_var
+      @name = name || (source ? '(source)' : File.basename(path))
       @covered_source = instrument_source
     end
 
@@ -24,10 +27,6 @@ module DeepCover
       @buffer.name || "(source: '#{@buffer.source[0..20]}...')"
     end
 
-    def name
-      @buffer.name ? File.basename(@buffer.name) : "(source)"
-    end
-
     def nb_lines
       @nb_lines ||= begin
         lines = buffer.source_lines
@@ -95,7 +94,7 @@ module DeepCover
 
     def root
       @root ||= begin
-        ast = Parser::CurrentRuby.new.parse(@buffer)
+        ast = DeepCover.parser.parse(@buffer)
         Node::Root.new(ast, self)
       end
     end
@@ -106,17 +105,17 @@ module DeepCover
 
     def instrument_source
       rewriter = ::Parser::Source::Rewriter.new(@buffer)
-      covered_ast.each_node do |node|
-        prefix, suffix = node.rewrite_prefix_suffix
-        unless prefix.empty?
-          expression = node.expression
-          prefix = yield prefix, node, expression.begin, :prefix if block_given?
-          rewriter.insert_before_multi expression, prefix rescue binding.pry
-        end
-        unless suffix.empty?
-          expression = node.expression
-          suffix = yield suffix, node, expression.end, :suffix if block_given?
-          rewriter.insert_after_multi  expression, suffix
+      covered_ast.each_node(:postorder) do |node|
+        node.rewriting_rules.each do |range, rule|
+          prefix, _node, suffix = rule.partition('%{node}')
+          unless prefix.empty?
+            prefix = yield prefix, node, range.begin, :prefix if block_given?
+            rewriter.insert_before_multi range, prefix rescue binding.pry
+          end
+          unless suffix.empty?
+            suffix = yield suffix, node, range.end, :suffix if block_given?
+            rewriter.insert_after_multi  range, suffix
+          end
         end
       end
       rewriter.process

data/lib/deep_cover/node/base.rb

@@ -19,17 +19,25 @@ module DeepCover
       @base_node = base_node
       @parent = parent
       @index = index
-      @children = augment_children(base_children)
+      @children = begin
+        augment_children(base_children)
+      rescue StandardError => e
+        diagnose(e)
+      end
       super()
     end
 
-    ### High level API for coverage purposes
+    ### Public API
 
+    # Shortcut to access children
     def [](v)
       children[v]
     end
 
-    ### Public API
+    # Shortcut to create a node from source code
+    def self.[](source)
+      CoveredCode.new(source: source).execute_code.covered_ast
+    end
 
     def children_nodes
       children.select{|c| c.is_a? Node }
@@ -75,7 +83,7 @@ module DeepCover
     end
 
     def type
-      return base_node.type if base_node
+      return base_node.type if base_node.respond_to? :type
       self.class.name.split('::').last.to_sym
     end
 
@@ -95,5 +103,21 @@ module DeepCover
       t.casecmp(class_name) == 0 ? t : "#{t}[#{class_name}]"
     end
 
+    private
+    def diagnose(exception)
+      if self.class == Node
+        exp = base_node.loc.expression
+        warn ["Unknown node type encountered: #{base_node.type}",
+          'This node will not be handled properly; its subnodes will be ignored',
+          'Source:',
+          exp && exp.source,
+          "Original exception:",
+          exception.inspect,
+        ].join("\n")
+        []
+      else
+        raise exception
+      end
+    end
   end
 end

data/lib/deep_cover/node/branch.rb

@@ -1,3 +1,5 @@
+require_relative 'empty_body'
+
 module DeepCover
   class Node
     module Branch
@@ -13,14 +15,15 @@ module DeepCover
       # Also define flow_entry_count
     end
 
-    class TrivialBranch < Struct.new(:condition, :other_branch)
-      def flow_entry_count
-        condition.flow_completion_count - other_branch.flow_entry_count
+    class TrivialBranch < Node::EmptyBody
+      def initialize(condition, other_branch, position: true)
+        @condition = condition
+        @other_branch = other_branch
+        super(nil, parent: condition.parent, position: position)
       end
-      alias_method :flow_completion_count, :flow_entry_count
-      alias_method :execution_count, :flow_entry_count
-      def executable?
-        true
+
+      def flow_entry_count
+        @condition.flow_completion_count - @other_branch.flow_entry_count
       end
     end
 

data/lib/deep_cover/node/def.rb

@@ -7,7 +7,7 @@ module DeepCover
     has_child method_name: Symbol
     has_child signature: Args
     has_child body: Node,
-      rewrite: '%{method_call_tracker};%{local}=nil;%{node};',
+      rewrite: '%{method_call_tracker};%{local}=nil;%{node}',
       can_be_empty: -> { base_node.loc.end.begin },
       is_statement: true,
       flow_entry_count: :method_call_tracker_hits
@@ -25,7 +25,7 @@ module DeepCover
     has_child method_name: Symbol
     has_child signature: Args
     has_child body: Node,
-      rewrite: '%{method_call_tracker};%{local}=nil;%{node};',
+      rewrite: '%{method_call_tracker};%{local}=nil;%{node}',
       can_be_empty: -> { base_node.loc.end.begin },
       is_statement: true,
       flow_entry_count: :method_call_tracker_hits

data/lib/deep_cover/node/empty_body.rb

@@ -2,7 +2,6 @@ module DeepCover
   class Node::EmptyBody < Node
     def initialize(base_node, parent: raise, index: 0, position: ChildCanBeEmpty.last_empty_position)
       @position = position
-      @position = parent.expression.begin if @position == true # Some random position... don't rewrite!
       super(base_node, parent: parent, index: index, base_children: [])
     end
 
@@ -11,6 +10,7 @@ module DeepCover
     end
 
     def loc_hash
+      return {} if @position == true
       {expression: @position}
     end
 

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

@@ -15,8 +15,7 @@ module DeepCover
           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
-
+          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

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

@@ -25,17 +25,20 @@ module DeepCover
         nil
       end
 
-      def executed_locs
+      def executed_loc_hash
+        h = Tools.slice(loc_hash, *executed_loc_keys)
         if (keys = parent.child_executed_loc_keys(self))
-          inherited = parent.loc_hash.values_at(*keys)
+          h.merge!(Tools.slice(parent.loc_hash, *keys))
         end
-        [  *loc_hash.values_at(*executed_loc_keys),
-           *inherited
-        ].compact
+        h.reject{|k, v| v.nil? }
+      end
+
+      def executed_locs
+        executed_loc_hash.values
       end
 
       def loc_hash
-        @loc_hash ||= base_node.location.to_hash
+        @loc_hash ||= (base_node.respond_to?(:location) ? base_node.location.to_hash : {}).freeze
       end
 
       def expression

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

@@ -3,14 +3,9 @@ module DeepCover
     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
-
+      CHILDREN = {}
+      CHILDREN_TYPES = {}
 
       def initialize(*)
         super
@@ -25,18 +20,25 @@ module DeepCover
       end
 
       module ClassMethods
-        def has_child(rest: false, **h)
+        def has_child(_rest: false, _refine: 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)
+          update_children_const(name, rest: _rest) unless _refine
+          define_accessor(name) unless _refine
           add_runtime_check(name, types)
           self
         end
 
         def has_extra_children(**h)
-          has_child(**h, rest: true)
+          has_child(**h, _rest: true)
+        end
+
+        def refine_child(child_name = nil, **h)
+          if child_name
+            h = {child_name => self::CHILDREN_TYPES.fetch(child_name), **h}
+          end
+          has_child(**h, _refine: true)
         end
 
         def child_index_to_name(index, nb_children)
@@ -91,14 +93,11 @@ module DeepCover
         end
 
         def inherited(subclass)
-          HasChild.setup_constants(subclass)
+          subclass.const_set :CHILDREN, self::CHILDREN.dup
+          subclass.const_set :CHILDREN_TYPES, self::CHILDREN_TYPES.dup
           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
@@ -124,7 +123,7 @@ module DeepCover
           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}]
+              children[CHILDREN.fetch(#{name.inspect})]
             end
           end_eval
         end

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

@@ -3,12 +3,8 @@ module DeepCover
     module HasTracker
       def self.included(base)
         base.extend ClassMethods
-        setup_constants(base)
-      end
-
-      def self.setup_constants(base)
-        base.const_set :TRACKERS, {}
       end
+      TRACKERS = {}
 
       def initialize(*)
         @tracker_offset = covered_code.allocate_trackers(self.class::TRACKERS.size).begin
@@ -23,8 +19,8 @@ module DeepCover
 
       module ClassMethods
         def inherited(base)
+          base.const_set :TRACKERS, self::TRACKERS.dup
           super
-          HasTracker.setup_constants(base)
         end
 
         def has_tracker(name)