deep-cover-core 0.6.4 → 0.7.0

data/lib/deep_cover/node/case.rb

@@ -89,7 +89,7 @@ module DeepCover
         whens.map(&:body) << self.else
       end
 
-      def branches_summary(of_branches = branches)
+      def branches_summary(of_branches)
         texts = []
         n = of_branches.size
         if of_branches.include? self.else

data/lib/deep_cover/node/empty_body.rb

@@ -7,10 +7,6 @@ module DeepCover
       super(base_node, parent: parent, index: index, base_children: [])
     end
 
-    def type
-      :EmptyBody
-    end
-
     def loc_hash
       return {} if @position == true
       {expression: @position}
@@ -21,7 +17,7 @@ module DeepCover
     end
 
     # When parent rewrites us, the %{node} must always be at the beginning because our location can
-    # also be rewritten by out parent, and we want the rewrite to be after it.
+    # also be rewritten by our parent, and we want the rewrite to be after it.
     def rewriting_rules
       rules = super
       rules.map do |expression, rule|

data/lib/deep_cover/node/if.rb

@@ -19,7 +19,7 @@ module DeepCover
       executed_loc_keys :keyword, :question
 
       def child_can_be_empty(child, name)
-        return false if name == :condition || style == :ternary
+        raise 'Unexpected empty body' if name == :condition || style == :ternary
         if (name == :true_branch) == [:if, :elsif].include?(style)
           (base_node.loc.begin || base_node.children[0].loc.expression.succ).end
         elsif has_else?
@@ -33,7 +33,7 @@ module DeepCover
         [true_branch, false_branch]
       end
 
-      def branches_summary(of_branches = branches)
+      def branches_summary(of_branches)
         of_branches.map do |jump|
           "#{'implicit ' if jump.is_a?(EmptyBody) && !has_else?}#{jump == false_branch ? 'falsy' : 'truthy'} branch"
         end.join(' and ')
@@ -58,13 +58,12 @@ module DeepCover
       end
 
       def deepest_elsif_node
-        return if style != :elsif
+        raise 'Not an elsif' if style != :elsif
         return self if loc_hash[:else] && loc_hash[:else].source == 'else'
         return self if false_branch.is_a?(EmptyBody)
         false_branch.deepest_elsif_node
       end
 
-
       def has_else?
         !!base_node.loc.to_hash[:else]
       end

data/lib/deep_cover/node/loops.rb

@@ -4,7 +4,7 @@ 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 assignments: [Mlhs, VariableAssignment], flow_entry_count: -> { body.flow_entry_count }
       has_child iterable: [Node], flow_entry_count: -> { flow_entry_count }
       has_child body: Node,
                 can_be_empty: -> { base_node.loc.end.begin },

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

@@ -9,9 +9,7 @@ module DeepCover
 
       # 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
+        execution_count > 0
       end
 
       # Returns the control flow entered the node.
@@ -61,11 +59,6 @@ module DeepCover
           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

@@ -26,12 +26,12 @@ module DeepCover
       end
 
       module ClassMethods
-        def has_child(rest_: false, refine_: false, **args)
+        def has_child(rest_: 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_
+          update_children_const(name, rest: rest_)
+          define_accessor(name)
           add_runtime_check(name, types)
           self
         end
@@ -40,13 +40,6 @@ module DeepCover
           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) ||
@@ -91,8 +84,6 @@ module DeepCover
             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

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

@@ -56,11 +56,8 @@ module DeepCover
           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
+              raise NotImplementedError if arity < 0
+              send(action, *args[0...arity])
             end
           when Proc
             define_method(method_name, &action)

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

@@ -9,14 +9,10 @@ module DeepCover
       TRACKERS = {}
 
       def initialize(*)
-        @tracker_offset = tracker_storage.allocate_trackers(self.class::TRACKERS.size).begin
+        @tracker_offset = covered_code.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")]
@@ -33,10 +29,10 @@ module DeepCover
           i = self::TRACKERS[name] = self::TRACKERS.size
           class_eval <<-EVAL, __FILE__, __LINE__ + 1
             def #{name}_tracker_source
-              tracker_storage.tracker_source(@tracker_offset + #{i})
+              covered_code.increment_tracker_source(@tracker_offset + #{i})
             end
             def #{name}_tracker_hits
-              tracker_storage[@tracker_offset + #{i}]
+              covered_code.tracker_hits[@tracker_offset + #{i}]
             end
           EVAL
         end

data/lib/deep_cover/node/module.rb

@@ -21,46 +21,43 @@ module DeepCover
       end
     end
 
-    class Module < Node
+    def self.define_module_class
       check_completion
       has_tracker :body_entry
-      has_child const: {const: ModuleName}
+      yield
       has_child body: Node,
                 can_be_empty: -> { base_node.loc.end.begin },
-                rewrite: '%{body_entry_tracker};%{local}=nil;%{node}',
+                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
+      class_eval do
+        def execution_count # Overrides ExecutedAfterChildren
+          body_entry_tracker_hits
+        end
       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
+    class Module < Node
+      define_module_class do
+        has_child const: {const: ModuleName}
+      end
+    end
 
-      def execution_count
-        body_entry_tracker_hits
+    class Class < Node
+      define_module_class do
+        has_child const: {const: ModuleName}
+        has_child inherit: [Node, nil] # TODO
       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
+      define_module_class do
+        has_child object: Node
+      end
+      executed_loc_keys :keyword, :operator
     end
   end
 end

data/lib/deep_cover/node/root.rb

@@ -7,7 +7,7 @@ module DeepCover
               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}"
+                "#{covered_code.setup_tracking_source};%{root_tracker};%{local}=nil;%{node}"
               }
     attr_reader :covered_code
     alias_method :flow_entry_count, :root_tracker_hits

data/lib/deep_cover/node/send.rb

@@ -122,6 +122,9 @@ module DeepCover
 
       executed_loc_keys :dot
 
+      extend Forwardable
+      def_delegators :actual_send, :message, :arguments
+
       def has_block?
         parent.is_a?(Block) && parent.child_index_to_name(index) == :call
       end
@@ -134,17 +137,13 @@ module DeepCover
         receiver.flow_completion_count
       end
 
-      def message
-        actual_send.message
-      end
-
       def branches
         [TrivialBranch.new(condition: receiver, other_branch: actual_send),
          actual_send,
         ]
       end
 
-      def branches_summary(of_branches = branches)
+      def branches_summary(of_branches)
         of_branches.map do |jump|
           jump == actual_send ? 'safe send' : 'nil shortcut'
         end.join(' and ')

data/lib/deep_cover/node/short_circuit.rb

@@ -18,7 +18,7 @@ module DeepCover
         ]
       end
 
-      def branches_summary(of_branches = branches)
+      def branches_summary(of_branches)
         of_branches.map do |jump|
           if jump == conditional
             'right-hand side'

data/lib/deep_cover/persistence.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# This file is used by projects cloned with clone mode. As such, special care must be taken to
+# be compatible with any projects.
+# THERE MUST NOT BE ANY USE/REQUIRE OF DEPENDENCIES OF DeepCover HERE
+# See deep-cover/core_gem/lib/deep_cover/setup/clone_mode_entry_template.rb for explanation of
+# clone mode and of this top_level_module stuff.
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+
+module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
+  require 'securerandom'
+  class Persistence
+    BASENAME = 'coverage.dc'
+    TRACKER_TEMPLATE = 'trackers%{unique}.dct'
+
+    attr_reader :dir_path
+    def initialize(cache_directory)
+      @dir_path = Pathname(cache_directory).expand_path
+    end
+
+    def save_trackers(tracker_hits_per_path)
+      create_directory_if_needed
+      basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
+
+      dir_path.join(basename).binwrite(JSON.dump(
+                                           version: VERSION,
+                                           tracker_hits_per_path: tracker_hits_per_path,
+      ))
+    end
+
+    # returns a TrackerHitsPerPath
+    def load_trackers
+      tracker_hits_per_path_hashes = tracker_files.map do |full_path|
+        JSON.parse(full_path.binread).transform_keys(&:to_sym).yield_self do |version:, tracker_hits_per_path:|
+          raise "dump version mismatch: #{version}, currently #{VERSION}" unless version == VERSION
+          tracker_hits_per_path
+        end
+      end
+
+      self.class.merge_tracker_hits_per_paths(*tracker_hits_per_path_hashes)
+    end
+
+    def merge_persisted_trackers
+      tracker_hits_per_path = load_trackers
+      return if tracker_hits_per_path.empty?
+      tracker_files_before = tracker_files
+      save_trackers(tracker_hits_per_path)
+      tracker_files_before.each(&:delete)
+    end
+
+    def delete_trackers
+      tracker_files.each(&:delete)
+    end
+
+    def clear_directory
+      delete_trackers
+      begin
+        dir_path.rmdir
+      rescue SystemCallError # rubocop:disable Lint/HandleExceptions
+      end
+    end
+
+    def self.merge_tracker_hits_per_paths(*tracker_hits_per_path_hashes)
+      return {} if tracker_hits_per_path_hashes.empty?
+
+      result = tracker_hits_per_path_hashes[0].transform_values(&:dup)
+
+      tracker_hits_per_path_hashes[1..-1].each do |tracker_hits_per_path|
+        tracker_hits_per_path.each do |path, tracker_hits|
+          matching_result = result[path]
+          if matching_result.nil?
+            result[path] = tracker_hits.dup
+            next
+          end
+
+          if matching_result.size != tracker_hits.size
+            raise "Attempting to merge trackers of different sizes: #{matching_result.size} vs #{tracker_hits.size}, for path #{path}"
+          end
+
+          tracker_hits.each_with_index do |nb_hits, i|
+            matching_result[i] += nb_hits
+          end
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def create_directory_if_needed
+      dir_path.mkpath
+    end
+
+    def tracker_files
+      basename = format(TRACKER_TEMPLATE, unique: '*')
+      Pathname.glob(dir_path.join(basename))
+    end
+  end
+end

data/lib/deep_cover/problem_with_diagnostic.rb

@@ -49,11 +49,11 @@ module DeepCover
       first_index = line_range.begin - nb_context_line - buffer.first_line
       first_index = 0 if first_index < 0
       last_index = line_range.end + nb_context_line - buffer.first_line
-      last_index = 0 if last_index < 0
 
       lines = buffer.source_lines[first_index..last_index]
+      lines.pop if lines.last.empty?
 
-      Tools.number_lines(lines, lineno: buffer.first_line, bad_linenos: line_range.to_a)
+      Tools.number_lines(lines, lineno: buffer.first_line + first_index, bad_linenos: line_range.to_a)
     end
 
     def buffer

data/lib/deep_cover/setup/clone_mode_entry_template.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# This file is used by `deep-cover clone`.
+#
+# This is a template for the setup code that clone mode makes the cloned code execute.
+# We don't actually load deep-cover at all. We do need to little parts of it in a non name-clashing way,
+# so this file takes care of this.
+#
+# Clone mode will copy this file and gsub some "global variables" with their actual values.
+# The the fake global variables are: $_cache_directory, $_core_gem_lib_directory, $_global_name
+# This template is important because with the anonymous top-level module, it becomes problematic
+# to call the content of this file from the place that required it. Doing it with a template means
+# that it is not necessary to do anything beyond requiring the file. It feels cleaner than the
+# alternatives I thought of.
+#
+# It is important to avoid using any of deep-cover's dependencies (from other gems), because they may not be in
+# the Gemfile of the project being cloned, and so will not be found.
+#
+# In order to avoid any possible name clashing with a DeepCover that would be used in the program
+# being covered with clone mode, we create a unique top-level module under which we nest everything
+# that we need. (The main use-case for this is when doing coverage of DeepCover itself)
+top_level_module = Module.new
+
+module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
+  def self.setup
+    Tools::AfterTests.after_tests { save }
+    ExecCallbacks.before_exec { save }
+  end
+
+  def self.save
+    return if saved?
+
+    Persistence.new($_cache_directory).save_trackers(GlobalVariables.tracker_hits_per_path($_global_name))
+    @saved = true
+  end
+
+  def self.saved?
+    @saved ||= false
+  end
+end
+
+# The files that we need all use this top-level module when it is defined. We avoid any kind of race-condition
+# by using Thread.current instead of a global variable. (Think of what would happen if another thread decided to
+# require 'deep-cover' while this thread is loading it's special top-level dependencies)
+Thread.current['_deep_cover_top_level_module'] = top_level_module
+# To avoid any issue, we load the files instead of requiring them. Since this file is being required, the
+# result is the same, but if, for any reason, this file or another template gets executed again, then there will be
+# a new top-level module, so we must fill it correctly, which means loading the files again.
+load $_core_gem_lib_directory + '/deep_cover/global_variables.rb'
+load $_core_gem_lib_directory + '/deep_cover/persistence.rb'
+load $_core_gem_lib_directory + '/deep_cover/version.rb'
+load $_core_gem_lib_directory + '/deep_cover/core_ext/exec_callbacks.rb'
+load $_core_gem_lib_directory + '/deep_cover/tools/after_tests.rb'
+
+Thread.current['_deep_cover_top_level_module'] = nil
+
+Object.autoload :JSON, 'json'
+
+# This is really just to make debugging less of a pain, it gives a way to the code to access the anonymous top-level module
+module DeepCover
+  CLONE_MODE_ENTRY_TOP_LEVEL_MODULES ||= []
+end
+DeepCover::CLONE_MODE_ENTRY_TOP_LEVEL_MODULES << top_level_module
+
+# Activate everything!
+top_level_module::DeepCover.setup