deep-cover-core 0.6.4 → 0.7.0

data/lib/deep_cover/coverage.rb

@@ -9,12 +9,8 @@ module DeepCover
   class Coverage
     include Enumerable
 
-    attr_reader :tracker_storage_per_path
-
-    def initialize(**options)
-      @covered_code_index = {}
-      @options = options
-      @tracker_storage_per_path = TrackerStoragePerPath.new(TrackerBucket[tracker_global])
+    def initialize
+      @covered_code_per_path = {}
     end
 
     def covered_codes
@@ -26,15 +22,13 @@ module DeepCover
     end
 
     def covered_code?(path)
-      @covered_code_index.include?(path)
+      @covered_code_per_path.include?(path)
     end
 
     def covered_code(path, **options)
       raise 'path must be an absolute path' unless Pathname.new(path).absolute?
-      @covered_code_index[path] ||= CoveredCode.new(path: path,
-                                                    tracker_storage: @tracker_storage_per_path[path],
-                                                    **options,
-                                                    **@options)
+      @covered_code_per_path[path] ||= CoveredCode.new(path: path,
+                                                       **options)
     end
 
     def covered_code_or_warn(path, **options)
@@ -51,7 +45,7 @@ module DeepCover
 
     def each
       return to_enum unless block_given?
-      @tracker_storage_per_path.each_key do |path|
+      @covered_code_per_path.each_key do |path|
         begin
           cov_code = covered_code(path)
         rescue Parser::SyntaxError
@@ -62,8 +56,36 @@ module DeepCover
       self
     end
 
-    def report(**options)
-      case (reporter = options.fetch(:reporter, DEFAULTS[:reporter]).to_sym)
+    # If a file wasn't required, it won't be in the trackers. This adds those mossing files
+    def add_missing_covered_codes
+      top_level_path = DeepCover.config.paths.detect do |path|
+        next unless path.is_a?(String)
+        path = File.expand_path(path)
+        File.dirname(path) == path
+      end
+      if top_level_path
+        # One of the paths is a root path.
+        # Either a mistake, or the user wanted to check everything that gets loaded. Either way,
+        # we will probably hang from searching the files to load. (and then loading them, as there
+        # can be lots of ruby files) We prefer to warn the user and not do anything.
+        suggestion = "#{top_level_path}/**/*.rb"
+        warn ["Because the `paths` configured in DeepCover include #{top_level_path.inspect}, which is a root of your fs, ",
+              'DeepCover will not attempt to find Ruby files that were not required. Your coverage report will not include ',
+              'files that were not instrumented. This is to avoid extremely long wait times. If you actually want this to ',
+              "happen, then replace the specified `paths` with #{suggestion.inspect}.",
+             ].join
+        return
+      end
+
+      DeepCover.all_tracked_file_paths.each do |path|
+        covered_code(path, tracker_hits: :zeroes)
+      end
+      nil
+    end
+
+    def report(reporter: DEFAULTS[:reporter], **options)
+      add_missing_covered_codes
+      case reporter.to_sym
       when :html
         msg = if (output = options.fetch(:output, DEFAULTS[:output]))
                 Reporter::HTML.report(self, **options)
@@ -85,41 +107,29 @@ module DeepCover
       end
     end
 
-    def self.load(dest_path, dirname = 'deep_cover', with_trackers: true)
-      Persistence.new(dest_path, dirname).load(with_trackers: with_trackers)
-    end
+    def self.load(cache_directory = DeepCover.config.cache_directory)
+      tracker_hits_per_path = Persistence.new(cache_directory).load_trackers
+      coverage = Coverage.new
 
-    def self.saved?(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).saved?
-    end
+      tracker_hits_per_path.each do |path, tracker_hits|
+        coverage.covered_code(path, tracker_hits: tracker_hits)
+      end
 
-    def save(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).save(self)
-      self
+      coverage
     end
 
-    def save_trackers(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).save_trackers(@tracker_storage_per_path.tracker_hits_per_path)
-      self
-    end
+    def save_trackers
+      tracker_hits_per_path = @covered_code_per_path.map do |path, covered_code|
+        [path, covered_code.tracker_hits]
+      end
+      tracker_hits_per_path = tracker_hits_per_path.to_h
 
-    def tracker_global
-      @options.fetch(:tracker_global, DEFAULTS[:tracker_global])
+      DeepCover.persistence.save_trackers(tracker_hits_per_path)
+      self
     end
 
     def analysis(**options)
-      Analysis.new(covered_codes, options)
-    end
-
-    private
-
-    def marshal_dump
-      {options: @options, tracker_storage_per_path: @tracker_storage_per_path}
-    end
-
-    def marshal_load(options:, tracker_storage_per_path:)
-      initialize(**options)
-      @tracker_storage_per_path = tracker_storage_per_path
+      Analysis.new(covered_codes, **options)
     end
   end
 end

data/lib/deep_cover/covered_code.rb

@@ -5,25 +5,28 @@ module DeepCover
   load_parser
 
   class CoveredCode
-    attr_accessor :covered_source, :buffer, :tracker_storage, :local_var, :path
+    attr_accessor :buffer, :local_var, :path
 
     def initialize(
       path: nil,
       source: nil,
       lineno: 1,
-      tracker_global: DEFAULTS[:tracker_global],
-      tracker_storage: TrackerBucket[tracker_global].create_storage,
-      local_var: '_temp'
+      local_var: '_temp',
+      tracker_hits: nil
     )
       raise 'Must provide either path or source' unless path || source
 
       @path = path &&= Pathname(path)
       @buffer = Parser::Source::Buffer.new('', lineno)
       @buffer.source = source || path.read
-      @tracker_count = 0
-      @tracker_storage = tracker_storage
+      @index = nil # Set in #instrument_source
       @local_var = local_var
-      @covered_source = instrument_source
+      @covered_source = nil # Set in #covered_source
+      @tracker_hits = tracker_hits # Loaded from global in #tracker_hits, or when received right away when loading data
+      @nb_allocated_trackers = 0
+      # We parse the code now so that problems happen early
+      covered_ast
+      @tracker_hits = Array.new(@nb_allocated_trackers, 0) if @tracker_hits == :zeroes
     end
 
     def lineno
@@ -40,7 +43,7 @@ module DeepCover
     end
 
     def execute_code(binding: DeepCover::GLOBAL_BINDING.dup)
-      eval(@covered_source, binding, (@path || '<raw_code>').to_s, lineno) # rubocop:disable Security/Eval
+      eval(covered_source, binding, (@path || '<raw_code>').to_s, lineno) # rubocop:disable Security/Eval
       self
     end
 
@@ -50,10 +53,6 @@ module DeepCover
       end
     end
 
-    def cover
-      global[nb] ||= Array.new(@tracker_count, 0)
-    end
-
     def line_coverage(**options)
       Analyser::PerLine.new(self, **options).results
     end
@@ -62,10 +61,6 @@ module DeepCover
       Analyser::PerChar.new(self, **options).results
     end
 
-    def tracker_hits(tracker_id)
-      cover.fetch(tracker_id)
-    end
-
     def covered_ast
       root.main
     end
@@ -86,9 +81,45 @@ module DeepCover
       covered_ast.each_node(*args, &block)
     end
 
+    def setup_tracking_source
+      src = "(#{DeepCover.config.tracker_global}||={})[#{@index}]||=Array.new(#{@nb_allocated_trackers},0)"
+      src += ";(#{DeepCover.config.tracker_global}_p||={})[#{@index}]=#{path.to_s.inspect}" if path
+      src
+    end
+
+    def increment_tracker_source(tracker_id)
+      "#{DeepCover.config.tracker_global}[#{@index}][#{tracker_id}]+=1"
+    end
+
+    def allocate_trackers(nb_needed)
+      return @nb_allocated_trackers...@nb_allocated_trackers if nb_needed == 0
+      prev = @nb_allocated_trackers
+      @nb_allocated_trackers += nb_needed
+      prev...@nb_allocated_trackers
+    end
+
+    def tracker_hits
+      return @tracker_hits if @tracker_hits
+      global_trackers = DeepCover::GlobalVariables.trackers[@index]
+
+      return unless global_trackers
+
+      if global_trackers.size != @nb_allocated_trackers
+        raise "Cannot sync path: #{path.inspect}, global[#{@index}] is of size #{global_trackers.size} instead of expected #{@nb_allocated_trackers}"
+      end
+
+      @tracker_hits = global_trackers
+    end
+
+    def covered_source
+      @covered_source ||= instrument_source
+    end
+
     def instrument_source
+      @index ||= self.class.next_global_index
+
       rewriter = Parser::Source::TreeRewriter.new(@buffer)
-      covered_ast.each_node(:postorder) do |node|
+      covered_ast.each_node do |node|
         node.rewriting_rules.each do |range, rule|
           prefix, _node, suffix = rule.partition('%{node}')
           prefix = yield prefix, node, range.begin, :prefix if block_given? && !prefix.empty?
@@ -111,6 +142,7 @@ module DeepCover
 
     def freeze
       unless frozen? # Guard against reentrance
+        tracker_hits
         super
         root.each_node(&:freeze)
       end
@@ -133,6 +165,11 @@ module DeepCover
       nil
     end
 
+    def self.next_global_index
+      @last_allocated_global_index ||= -1
+      @last_allocated_global_index += 1
+    end
+
     private
 
     def parser

data/lib/deep_cover/custom_requirer.rb

@@ -22,12 +22,12 @@ module DeepCover
     #
     # An absolute path is returned directly if it exists, otherwise nil is returned
     # without searching anywhere else.
-    def resolve_path(path, extensions_to_try = ['.rb', '.so'])
-      if extensions_to_try
-        extensions_to_try = [''] if extensions_to_try.any? { |ext| path.end_with?(ext) }
-      else
-        extensions_to_try = ['']
-      end
+    def resolve_path(path, try_extensions: true)
+      extensions_to_try = if try_extensions && !REQUIRABLE_EXTENSIONS.include?(File.extname(path))
+                            REQUIRABLE_EXTENSION_KEYS
+                          else
+                            ['']
+                          end
 
       abs_path = File.absolute_path(path)
       path = abs_path if path.start_with?('./', '../')
@@ -89,8 +89,8 @@ module DeepCover
           return yield(:not_found) unless found_path
 
           @paths_being_required.add(found_path)
-          return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
-          return yield(:not_supported) if found_path.end_with?('.so')
+          return yield(:not_in_covered_paths) unless DeepCover.tracked_file_path?(found_path)
+          return yield(:not_supported) if REQUIRABLE_EXTENSIONS[File.extname(found_path)] == :native_extension
           return yield(:skipped) if filter && filter.call(found_path)
 
           cover_and_execute(found_path) { |reason| return yield(reason) }
@@ -111,7 +111,7 @@ module DeepCover
     def load(path) # &fallback_block
       path = path.to_s
 
-      found_path = resolve_path(path, nil)
+      found_path = resolve_path(path, try_extensions: false)
 
       if found_path.nil?
         # #load has a final fallback of always trying relative to current work directory
@@ -120,7 +120,7 @@ module DeepCover
       end
 
       return yield(:not_found) unless found_path
-      return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
+      return yield(:not_in_covered_paths) unless DeepCover.tracked_file_path?(found_path)
 
       cover_and_execute(found_path) { |reason| return yield(reason) }
 

data/lib/deep_cover/global_variables.rb

@@ -0,0 +1,32 @@
+# 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
+  module GlobalVariables
+    def self.trackers(global_name = nil)
+      @trackers ||= {}
+      global_name ||= DeepCover.config.tracker_global
+      @trackers[global_name] ||= eval("#{global_name} ||= {}") # rubocop:disable Security/Eval
+    end
+
+    def self.path_per_index(global_name = nil)
+      @path_per_index ||= {}
+      global_name ||= DeepCover.config.tracker_global
+      @path_per_index[global_name] ||= eval("#{global_name}_p ||= {}") # rubocop:disable Security/Eval
+    end
+
+    def self.tracker_hits_per_path(global_name = nil)
+      cur_trackers = self.trackers(global_name)
+      hits_per_path = path_per_index(global_name).map do |index, path|
+        [path, cur_trackers[index]]
+      end
+      hits_per_path.to_h
+    end
+  end
+end

data/lib/deep_cover/load.rb

@@ -4,9 +4,8 @@ module DeepCover
   module Load
     AUTOLOAD = %i[analyser autoload_tracker auto_run config
                   coverage covered_code custom_requirer
-                  tracker_hits_per_path tracker_storage_per_path
-                  flag_comment_associator memoize module_override node
-                  problem_with_diagnostic reporter tracker_bucket
+                  flag_comment_associator global_variables memoize module_override node
+                  persistence problem_with_diagnostic reporter
                  ]
 
     def load_absolute_basics
@@ -18,10 +17,27 @@ module DeepCover
         DeepCover.autoload(Tools::Camelize.camelize(module_name), "#{__dir__}/#{module_name}")
       end
       DeepCover.autoload :VERSION, "#{__dir__}/version"
-      Object.autoload :Term, 'term/ansicolor'
-      Object.autoload :Terminal, 'terminal-table'
-      Object.autoload :YAML, 'yaml'
+
       Object.autoload :Forwardable, 'forwardable'
+      Object.autoload :YAML, 'yaml'
+
+      # In ruby 2.2 and less, autoload doesn't work for gems which are not already on the `$LOAD_PATH`.
+      # The fix is to just require right away for those rubies
+      #
+      # Low-level: autoload not working for gems not on the `$LOAD_PATH` is because those rubies don't
+      # call the regular `#require` when triggering an autoload, and the gem system monkey-patches `#require`
+      # so that when a file is not found in the `$LOAD_PATH`, but can be found in an existing gem, that gem's
+      # path is added to the `$LOAD_PATH`
+      {JSON: 'json',
+       Term: 'term/ansicolor',
+       Terminal: 'terminal-table',
+      }.each do |const, require_path|
+        if RUBY_VERSION < '2.3'
+          require require_path
+        else
+          Object.autoload const, require_path
+        end
+      end
     end
 
     def bootstrap
@@ -35,7 +51,7 @@ module DeepCover
     def load_parser
       @parser_loaded ||= false # Avoid warning
       return if @parser_loaded
-      silence_warnings do
+      Tools.silence_warnings do
         require 'parser'
         require 'parser/current'
       end
@@ -44,8 +60,8 @@ module DeepCover
     end
 
     def load_pry
-      silence_warnings do # Avoid "WARN: Unresolved specs during Gem::Specification.reset"
-        require 'pry'     # after `pry` calls `Gem.refresh`
+      Tools.silence_warnings do # Avoid "WARN: Unresolved specs during Gem::Specification.reset"
+        require 'pry'           # after `pry` calls `Gem.refresh`
       end
     end
 

data/lib/deep_cover/node/base.rb

@@ -114,17 +114,17 @@ module DeepCover
     end
 
     def type
-      return base_node.type if base_node.respond_to? :type
+      return base_node.type if base_node
       self.class.name.split('::').last.to_sym
     end
 
-    def each_node(order = :postorder, &block)
-      return to_enum :each_node, order unless block_given?
-      yield self unless order == :postorder
+    # Yields its children and itself
+    def each_node(&block)
+      return to_enum :each_node unless block_given?
       children_nodes.each do |child|
-        child.each_node(order, &block)
+        child.each_node(&block)
       end
-      yield self if order == :postorder
+      yield self
       self
     end
 

data/lib/deep_cover/node/begin.rb

@@ -18,8 +18,7 @@ module DeepCover
         when 'else', '#{'
           %i[begin end]
         else
-          warn 'Unknown context for Begin node'
-          []
+          raise "Unknown context for Begin node: #{loc_hash[:begin].source}"
         end
       end
     end

data/lib/deep_cover/node/block.rb

@@ -38,8 +38,12 @@ module DeepCover
                 is_statement: true
       executed_loc_keys # none
 
+      def execution_count
+        call.execution_count
+      end
+
       def children_nodes_in_flow_order
-        [call, args] # Similarly to a def, the body is actually not part of the flow of this node...
+        [call] # Similarly to a def, the body (and Args) are actually not part of the flow of this node...
       end
 
       alias_method :rewrite_for_completion, :rewrite