deep-cover-core 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786d0c79f687a02eefb1e3c9dc1af8c9b4b25d4c18fa86988d1c1a84d56f80e6
-  data.tar.gz: 6b3ef23fa825eb7f72673e4a4be0fe3889418c035d0b87c17323c2ceb97f5fba
+  metadata.gz: 26469b9b1a015b36a11d432d22d871647ba060fc272c4edd274175d7163dcceb
+  data.tar.gz: 51917845e6fdcc9e073e776fc13cade71a82d7f0806a01d36e1b653c52ee8b5f
 SHA512:
-  metadata.gz: 42806a5cf72180c3af74f5df4d03c067f52cade9d473adb2794db02416496de9aa6100390a4d3a597710378d8dd9bfbef783a65394cf9920adff115af53108cb
-  data.tar.gz: 20d7363fe8fa8c1195d0eaf98f21f91bbfeb2371383fde3b1bddc28f986b503da7ef397f4d1ac3f61a49790018fc08ae038bf9314edf4f0e77ffab0eafce8283
+  metadata.gz: fd179008eefe481fdcd29f5857228fda6cf1b364b027694309ca40e664a548be13ba404d168d3d1f34e7749b7d037f9d70a4cfaa11450615ccec4d7aa615a6c2
+  data.tar.gz: bc452e18b3ec005229d4c889c5396cffa2ddadb1daa9cd4132f9e66b126be6d2a305b76d54718e1fcea5c8f548ef4e6e518620a221c8712298bc318f4068b1ea

data/deep_cover_core.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   # Support
   spec.add_runtime_dependency 'backports', '>= 3.11.0'
   spec.add_runtime_dependency 'binding_of_caller'
+  spec.add_runtime_dependency 'term-ansicolor'
 
   # Reporters
   spec.add_runtime_dependency 'terminal-table'

data/lib/deep_cover.rb

@@ -1,22 +1,5 @@
 # frozen_string_literal: true
 
-module DeepCover
-  require_relative 'deep_cover/load'
-
-  load_absolute_basics
-
-  extend Base
-  extend ConfigSetter
-end
-DeepCover::GLOBAL_BINDING = binding
-
-require './.deep_cover.rb' if File.exist?('./.deep_cover.rb')
-
-if ENV['DEEP_COVER_OPTIONS']
-  DeepCover.config.set(YAML.load(ENV['DEEP_COVER_OPTIONS']))
-end
-if %w[1 t true].include?(ENV['DEEP_COVER'])
-  DeepCover.start
-  require_relative 'deep_cover/auto_run'
-  DeepCover::AutoRun.run!('.').report!(**DeepCover.config)
-end
+require_relative 'deep_cover/setup/deep_cover_without_config'
+require_relative 'deep_cover/setup/deep_cover_config'
+require_relative 'deep_cover/setup/deep_cover_auto_run'

data/lib/deep_cover/auto_run.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require_relative 'core_ext/exec_callbacks'
+require_relative 'tools/after_tests'
 
 module DeepCover
   module AutoRun
     class Runner
-      def initialize(covered_path)
-        @covered_path = covered_path
-        @saved = !(DeepCover.respond_to?(:running?) && DeepCover.running?)
+      include Tools::AfterTests
+      def initialize
+        @saved = false
       end
 
       def run!
@@ -23,49 +24,23 @@ module DeepCover
 
       private
 
-      def saved?
-        @saved
-      end
-
-      def coverage
-        @coverage ||= if saved?
-                        Coverage.load(@covered_path, with_trackers: false)
-                      else
-                        DeepCover.coverage
-                      end
-      end
-
       def save
+        return if @saved
         require_relative '../deep_cover'
-        coverage.save(@covered_path) unless saved?
-        coverage.save_trackers(@covered_path)
+        DeepCover.persistence.save_trackers(DeepCover::GlobalVariables.tracker_hits_per_path)
+        @saved = true
       end
 
       def report(**options)
+        save # Some of the hooks seem to do things in reverse order. Not sure if all of them.
+        coverage = Coverage.load
         coverage.report(**options)
       end
-
-      def after_tests
-        use_at_exit = true
-        if defined?(Minitest)
-          use_at_exit = false
-          Minitest.after_run { yield }
-        end
-        if defined?(Rspec)
-          use_at_exit = false
-          RSpec.configure do |config|
-            config.after(:suite) { yield }
-          end
-        end
-        if use_at_exit
-          at_exit { yield }
-        end
-      end
     end
 
     def self.run!(covered_path)
       @runners ||= {}
-      @runners[covered_path] ||= Runner.new(covered_path).run!
+      @runners[covered_path] ||= Runner.new.run!
     end
   end
 end

data/lib/deep_cover/autoload_tracker.rb

@@ -170,17 +170,21 @@ module DeepCover
     end
 
     def with_rb_extension(path)
-      path += '.rb' unless has_supported_extension?(path)
+      path += '.rb' unless find_requirable_extension(path)
       path
     end
 
     def without_extension(path)
-      path = path[0...-3] if has_supported_extension?(path)
-      path
+      if (ext = find_requirable_extension(path))
+        path[0...-ext.length]
+      else
+        path
+      end
     end
 
-    def has_supported_extension?(path)
-      path.end_with?('.rb', '.so')
+    private def find_requirable_extension(path)
+      ext = File.extname(path)
+      REQUIRABLE_EXTENSIONS[ext] && ext
     end
 
     # It is not possible to simply remove an autoload. So, instead, we must change the

data/lib/deep_cover/base.rb

@@ -27,7 +27,7 @@ module DeepCover
       end
 
       config # actualize configuration
-      @lookup_paths = nil
+      @lookup_globs = @all_tracked_file_paths = nil
       @started = true
     end
 
@@ -41,6 +41,10 @@ module DeepCover
       @started = false
     end
 
+    def delete_trackers
+      persistence.delete_trackers
+    end
+
     def line_coverage(filename)
       coverage.line_coverage(handle_relative_filename(filename), **config.to_h)
     end
@@ -65,7 +69,7 @@ module DeepCover
       case what
       when :paths
         warn "Changing DeepCover's paths after starting coverage is highly discouraged" if running?
-        @lookup_paths = nil
+        @lookup_globs = @all_tracked_file_paths = nil
       when :tracker_global
         raise NotImplementedError, "Changing DeepCover's tracker global after starting coverage is not supported" if running?
         @coverage = nil
@@ -74,25 +78,90 @@ module DeepCover
 
     def reset
       stop if running?
-      @coverage = @custom_requirer = @autoload_tracker = @lookup_paths = nil
+      @coverage = @custom_requirer = @autoload_tracker = @lookup_globs = @all_tracked_file_paths = nil
       config.reset
       self
     end
 
     def coverage
-      @coverage ||= Coverage.new(tracker_global: config.tracker_global)
+      @coverage ||= Coverage.new
+    end
+
+    def lookup_globs
+      return @lookup_globs if @lookup_globs
+      paths = Array(config.paths || :auto_detect).dup
+      paths.concat(auto_detected_paths) if paths.delete(:auto_detect)
+
+      paths = paths.map { |p| File.expand_path(p) }
+      paths = ['/'] if paths.include?('/')
+      globs = paths.map! do |path|
+        if File.directory?(path)
+          # File.join is needed to avoid //**/*.rb
+          File.join(path, '**/*.rb')
+        else
+          # Either a single file's path, a glob, or a path that doesn't exists
+          path
+        end
+      end
+      @lookup_globs = globs
     end
 
-    def lookup_paths
-      return @lookup_paths if @lookup_paths
-      lookup_paths = config.paths || Dir.getwd
-      lookup_paths = Array(lookup_paths).map { |p| File.expand_path(p) }
-      lookup_paths = ['/'] if lookup_paths.include?('/')
-      @lookup_paths = lookup_paths
+    # Auto detects path that we want to cover. This is used when :auto_detect is in the config.paths.
+    # If the results aren't what you expect, then specify the paths yourself.
+    # We want this to work for most project's struture:
+    # * Single gems: just a gem directly in the top-level
+    # * Multi gems: contains multiple gems, each in a dir of the top-level dir (the rails gem does that)
+    # * Hybrid gems: a gem in the top-level dir and one in sub-dirs (the deep-cover gem does that)
+    # * Rails application
+    #
+    # For gems and Rails application, normally, everything to check coverage for is in lib/, and app/.
+    # For other projects, we go for every directories except test/ spec/ bin/ exe/.
+    #
+    # If the current dir has a .gemspec file, we consider it a "root".
+    # In addition, if any sub-dir of the current dir (not recursive) has a .gemspec file, we also consider them as "roots"
+    # If the current dir looks like a Rails application, add it as a "root"
+    # For each "roots", the "tracked dirs" will be "#{root}/app" and "#{root}/lib"
+    #
+    # If no "tracked dirs" exist, fallback to everything in current directory except each of test/ spec/ bin/ exe/.
+    def auto_detected_paths
+      require_relative 'tools/looks_like_rails_project'
+
+      gemspec_paths = Dir['./*.gemspec'] + Dir['./*/*.gemspec']
+      root_paths = gemspec_paths.map!(&File.method(:dirname))
+      root_paths.uniq!
+      root_paths << '.' if !root_paths.include?('.') && Tools::LooksLikeRailsProject.looks_like_rails_project?('.')
+
+      tracked_paths = root_paths.flat_map { |p| [File.join(p, 'app'), File.join(p, 'lib')] }
+      tracked_paths.select! { |p| File.exist?(p) }
+
+      if tracked_paths.empty?
+        # So track every sub-dirs except a couple
+        # The final '/' in Dir[] makes it return directories only, but they will also end with a '/'
+        # So need to include that last '/' in the substracted paths.
+        # TODO: We probably want a cleaner way of filtering out some directories. But for now, that's what we got.
+        tracked_paths = Dir['./*/'] - %w(./autotest/ ./features/ ./spec/ ./test/ ./bin/ ./exe/)
+        # And track every ruby files in the top-level
+        tracked_paths << './*.rb'
+      end
+      tracked_paths
+      # path expansion is done in #lookup_globs
+    end
+
+    def tracked_file_path?(path)
+      # The flags are to make fnmatch match the same things as Dir.glob... This doesn't seem to be documented anywhere
+      # EXTGLOB: allow matching {lib,app} as either lib or app
+      # PATHNAME: Makes wildcard match not match /, and make /**/ (and pattern starting with **/) be any number of nested directory
+      lookup_globs.any? { |glob| File.fnmatch?(glob, path, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
     end
 
-    def within_lookup_paths?(path)
-      lookup_paths.any? { |lookup_path| path.start_with?(lookup_path) }
+    def all_tracked_file_paths
+      return @all_tracked_file_paths.dup if @all_tracked_file_paths
+      paths_found = Dir[*lookup_globs]
+      paths_found.select! { |path| path.end_with?('.rb') }
+      paths_found.select! { |path| File.file?(path) }
+      paths_found.uniq!
+      @all_tracked_file_paths = paths_found
+      @all_tracked_file_paths.dup
     end
 
     def custom_requirer
@@ -103,6 +172,10 @@ module DeepCover
       @autoload_tracker ||= AutoloadTracker.new
     end
 
+    def persistence
+      @persistence ||= Persistence.new(config.cache_directory)
+    end
+
     private
 
     def handle_relative_filename(filename)

data/lib/deep_cover/basics.rb

@@ -4,19 +4,31 @@
 module DeepCover
   DEFAULTS = {
                ignore_uncovered: [].freeze,
-               paths: %w[./app ./lib].freeze,
+               paths: [:auto_detect].freeze,
                allow_partial: false,
                tracker_global: '$_cov',
                reporter: :html,
                output: './coverage',
+               cache_directory: './deep_cover',
              }.freeze
 
   CLI_DEFAULTS = {
-                   command: 'bundle exec rake',
-                   bundle: true,
+                   command: %w(bundle exec rake),
                    process: true,
                    open: false,
                  }.freeze
 
   OPTIONALLY_COVERED = %i[case_implicit_else default_argument raise trivial_if warn]
+
+  REQUIRABLE_EXTENSIONS = {
+                            '.rb' => :ruby,
+                            ".#{RbConfig::CONFIG['DLEXT']}" => :native_extension,
+                          }
+  unless (RbConfig::CONFIG['DLEXT2'] || '').empty?
+    REQUIRABLE_EXTENSIONS[".#{RbConfig::CONFIG['DLEXT2']}"] = :native_extension
+  end
+  REQUIRABLE_EXTENSIONS.freeze
+  REQUIRABLE_EXTENSION_KEYS = REQUIRABLE_EXTENSIONS.keys.freeze
+
+  CORE_GEM_LIB_DIRECTORY = File.expand_path(__dir__ + '/..')
 end

data/lib/deep_cover/config.rb

@@ -3,8 +3,10 @@
 module DeepCover
   class Config
     def initialize(notify = nil)
+      @notify = nil
+      @options = {ignore_uncovered: []}
+      set(**DEFAULTS)
       @notify = notify
-      @options = DEFAULTS.dup
     end
 
     def to_hash
@@ -12,6 +14,23 @@ module DeepCover
     end
     alias_method :to_h, :to_hash
 
+    def to_hash_for_serialize
+      hash = to_hash
+      # TODO: (Max) I don't like mixup of configs being partly on DeepCover and Config like that...
+      hash[:paths] = DeepCover.lookup_globs
+      hash[:output] = hash[:output] ? File.expand_path(hash[:output]) : hash[:output]
+      hash[:cache_directory] = File.expand_path(hash[:cache_directory])
+      hash
+    end
+
+    def load_hash_for_serialize(hash)
+      @options.merge!(hash)
+      hash.each_key { |option| @notify.config_changed(option) } if @notify
+      # This was already transformed, it should all be absolute paths / globs, avoid doing it for nothing by setting it right away
+      # TODO: (Max) I don't like mixup of configs being partly on DeepCover and Config like that...
+      DeepCover.instance_variable_set(:@lookup_globs, hash[:paths])
+    end
+
     def ignore_uncovered(*keywords, &block)
       if block
         raise ArgumentError, "wrong number of arguments (given #{keywords.size}, expected 0..1)" if keywords.size > 1
@@ -68,6 +87,22 @@ module DeepCover
       end
     end
 
+    def cache_directory(cache_directory = nil)
+      if cache_directory
+        change(:cache_directory, cache_directory)
+      else
+        File.expand_path(@options[:cache_directory])
+      end
+    end
+
+    def allow_partial(allow_partial = nil)
+      if allow_partial != nil
+        change(:allow_partial, allow_partial)
+      else
+        @options[:allow_partial]
+      end
+    end
+
     def reset
       DEFAULTS.each do |key, value|
         change(key, value)
@@ -78,7 +113,6 @@ module DeepCover
     def set(**options)
       @options[:ignore_uncovered] = [] if options.has_key?(:ignore_uncovered)
       options.each do |key, value|
-        next if key == :allow_partial
         public_send key, value
       end
       self

data/lib/deep_cover/config_setter.rb

@@ -7,7 +7,7 @@ module DeepCover
     end
 
     def config(notify = self)
-      raise ArgumentError, 'config does not accept an argument. Did you mean `configure`?' if block_given?
+      raise ArgumentError, 'config does not accept a block. Did you mean `configure`?' if block_given?
       @config ||= Config.new(notify)
       config_queue.each { |block| configure(&block) }
       config_queue.clear

data/lib/deep_cover/core_ext/exec_callbacks.rb

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
-require_relative '../module_override'
+# 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
 
 # Adds a functionality to add callbacks before an `exec`
 
-module DeepCover
+module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
   module ExecCallbacks
     class << self
       attr_reader :callbacks
 
       def before_exec(&block)
-        self.active = true
         (@callbacks ||= []) << block
       end
     end
+  end
 
-    def exec(*args)
+  # We use #object_id of DeepCover to avoid possible overwrite between clone-mode and non-clone-mode
+  original_exec_name = :"exec_without_deep_cover_#{self.object_id}"
+  [::Kernel, ::Kernel.singleton_class].each do |mod|
+    mod.send(:alias_method, original_exec_name, :exec)
+    mod.send(:define_method, :exec) do |*args|
       ExecCallbacks.callbacks.each(&:call)
-      exec_without_deep_cover(*args)
+      send(original_exec_name, *args)
     end
-
-    extend ModuleOverride
-    override ::Kernel, ::Kernel.singleton_class
-    self.active = true
   end
+  ::Kernel.send :private, original_exec_name
 end

data/lib/deep_cover/core_ext/instruction_sequence_load_iseq.rb

@@ -17,7 +17,7 @@ module DeepCover
 
     def self.load_iseq_logic(path)
       return unless DeepCover.running?
-      return unless DeepCover.within_lookup_paths?(path)
+      return unless DeepCover.tracked_file_path?(path)
 
       covered_code = DeepCover.coverage.covered_code_or_warn(path)
       return unless covered_code