deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/config_setter.rb

@@ -7,6 +7,7 @@ module DeepCover
     end
 
     def config(notify = self)
+      raise ArgumentError, 'config does not accept an argument. 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/autoload_overrides.rb

@@ -1,25 +1,93 @@
 # frozen_string_literal: true
 
-# We need to override autoload, because MRI has special behaviors associated with it
-# that we can't reuse, hence we need to do workarounds.
+# Autoload is quite difficult to hook into to do what we need to do.
 #
-# Basically, when trying to use a constant set to be autoloaded in an optionnal way, like:
-#   * module A; ...; end
-#   * A ||= 1
-# When autoloading the file, the above won't work and will raise a "uninitialized constant A"
-# because ruby doesn't understand that custom require is currently requiring the correct file.
+# We create a temporary file that gets set as path for autoloads. The file then does a require of the
+# autoloaded file. We also keep track of autoloaded constants and files and change the autoload's target when
+# those files get required (or when we guess they are being).
+#
+# Doing it this way solves:
+#
+# * When autoload is triggered, it doesn't always call `require`. In Ruby 2.1 and 2.2, it just loads the
+#   file somehow without using require, this means we can't instrument autoloaded files. Using an intercept
+#   file means that the intercept is not covered (we don't care) and then the manual require will
+#   allow us to instrument the real target.
+#
+# * When autoload is triggered, there are special states setup internal to ruby to allow constants to
+#   be used conditionally. If the target file is not actually required (such as when using our custom requirer),
+#   then the state is not correct and we can't do simple things such as `A ||= 1` or `module A; ...; end`.
+#   This problem was happening when all we did was use the custom require that does get called for Ruby 2.3+.
+#
+#   To solve the issues, we keep track of all the autoloads, and when we detect that a file is being autoloaded,
+#   we change the state so that ruby thinks the file was already loaded.
+#
+# * An issue with the interceptor files is that if some code manually requires a file that is the target of
+#   autoloading, ruby would not disable the autoload behavior, and would end up trying to autoload once the constant
+#   is reached.
+#
+#   To solve this, every require, we check if it is for a file that is is meant to autoload a constant, and if so,
+#   we remove that autoload.
+#
+# * To make matter more complicated, when loading gems without bundle's setup, the $LOAD_PATH is filled by RubyGems
+#   as part of a monkey-patch of Kernel#require. Because of this, we can't always find the file that will be required,
+#   even though a file will indeed be required.
+#
+#   However, if nothing is done, the autoload can cause problems on that built-in require (as explained in a previous
+#   point). So when we don't find the target, we check if it's a require that will go through the $LOAD_PATH,
+#   meaning that require's parameter is not an absolute path, and isn't relative to the current directory (so doesn't
+#   start with './' or '../').
+#
+#   When a require does go through $LOAD_PATH, we do a best effort to deactivate the autoloads that seem to match
+#   to match this require by comparing the required path (as it is received) to all the autoload path we have, and
+#   deactivating those that match. This is only an issue when there is an autoload made which will load a different
+#   gem. This is pretty rare (but deep-cover does it...)
+#
+# * All of this changing autoloads means that for modules/classes that are frozen, we can't handle the situation, since
+#   we can't change the autoload stuff.
+#
+#   We don't resolve this problem. However, we could work around it by always calling the real require for these
+#   files (which means we wouldn't cover them), and by not creating interceptor files for the autoloads. Since we
+#   can't know when the #autoload call is made, if the constant will be frozen later on, we would have to instead
+#   monkey-patch #freeze on modules and classes to remove the interceptor file before things get frozen.
+#
+# * Kernel#autoload uses the caller's `Module.nesting` instead of using self.
+#   This means that if we intercept the autoload, then we cannot call the original Kernel#autoload because it will
+#   now use our Module instead if our caller's. The only reliable solution we've found to this is to use binding_of_caller
+#   to get the correct object to call autoload on.
+#
+#   (This is not a problem with Module#autoload and Module.autoload)
+#
+#   A possible solution to investigate is to make a simple C extension, to do the work of our monkey-patch, this way,
+#   the check for the caller doesn't find our callstack
+#
+# Some situations where Module.nesting of the caller is different from self in Kernel#autoload:
+# * When in the top-level: (self: main) vs (Module.nesting: nil, which we default to Object)
+# * When called from a method defined on a module that is included:
+#     module A
+#       def begin_autoload
+#         # `Kernel.autoload` would have the same result
+#         autoload :A1, 'hello'
+#       end
+#     end
+#     class B
+#       include A
+#     end
+#   Calling `B.new.begin_autoload` is equivalent to:
+#     A.autoload :A1, 'hello'
+#   NOT this:
+#     B.autoload :A1, 'hello'
 #
-# Our solution is to track autoloads ourself, and when requiring a path that has autoloads,
-# we remove the autoloads from the constants first.
-
 require 'binding_of_caller'
+require 'tempfile'
 
 module DeepCover
+  load_all
+
   module KernelAutoloadOverride
     def autoload(name, path)
       mod = binding.of_caller(1).eval('Module.nesting').first || Object
-      DeepCover.autoload_tracker.add(mod, name, path)
-      mod.autoload_without_deep_cover(name, path)
+      autoload_path = DeepCover.autoload_tracker.autoload_path_for(mod, name, path)
+      mod.autoload_without_deep_cover(name, autoload_path)
     end
 
     extend ModuleOverride
@@ -28,8 +96,8 @@ module DeepCover
 
   module ModuleAutoloadOverride
     def autoload(name, path)
-      DeepCover.autoload_tracker.add(self, name, path)
-      autoload_without_deep_cover(name, path)
+      autoload_path = DeepCover.autoload_tracker.autoload_path_for(self, name, path)
+      autoload_without_deep_cover(name, autoload_path)
     end
 
     extend ModuleOverride

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -4,13 +4,32 @@
 
 module DeepCover
   module CoverageReplacement
+    OLD_COVERAGE_SENTINEL = Object.new
+    ALL_COVERAGES = {lines: true, branches: true, methods: true}.freeze
+
     class << self
       def running?
         DeepCover.running?
       end
 
-      def start
-        return if running?
+      def start(targets = OLD_COVERAGE_SENTINEL)
+        if targets == OLD_COVERAGE_SENTINEL
+          # Do nothing
+        elsif targets == :all
+          targets = ALL_COVERAGES
+        else
+          targets = targets.to_hash.slice(*ALL_COVERAGES.keys).select { |_, v| v }
+          targets = targets.map { |k, v| [k, !!v] }.to_h
+          raise 'no measuring target is specified' if targets.empty?
+        end
+
+        if DeepCover.running?
+          raise 'cannot change the measuring target during coverage measurement' if @started_args != targets
+          return
+        end
+
+        @started_args = targets
+
         DeepCover.start
         nil
       end
@@ -23,9 +42,19 @@ module DeepCover
 
       def peek_result
         raise 'coverage measurement is not enabled' unless running?
-        DeepCover.coverage.covered_codes.map do |covered_code|
-          [covered_code.path, covered_code.line_coverage(allow_partial: false)]
-        end.to_h
+        if @started_args == OLD_COVERAGE_SENTINEL
+          DeepCover.coverage.covered_codes.map do |covered_code|
+            [covered_code.path.to_s, covered_code.line_coverage(allow_partial: false)]
+          end.to_h
+        else
+          DeepCover.coverage.covered_codes.map do |covered_code|
+            cov = {}
+            cov[:branches] = DeepCover::Analyser::Ruby25LikeBranch.new(covered_code).results if @started_args[:branches]
+            cov[:lines] = covered_code.line_coverage(allow_partial: false) if @started_args[:lines]
+            cov[:methods] = {} if @started_args[:methods]
+            [covered_code.path.to_s, cov]
+          end.to_h
+        end
       end
     end
   end

data/lib/deep_cover/core_ext/exec_callbacks.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../module_override'
+
+# Adds a functionality to add callbacks before an `exec`
+
+module DeepCover
+  module ExecCallbacks
+    class << self
+      attr_reader :callbacks
+
+      def before_exec(&block)
+        self.active = true
+        (@callbacks ||= []) << block
+      end
+    end
+
+    def exec(*args)
+      ExecCallbacks.callbacks.each(&:call)
+      exec_without_deep_cover(*args)
+    end
+
+    extend ModuleOverride
+    override ::Kernel, ::Kernel.singleton_class
+    self.active = true
+  end
+end

data/lib/deep_cover/core_ext/load_overrides.rb

@@ -10,12 +10,10 @@ module DeepCover
     def load(path, wrap = false)
       return load_without_deep_cover(path, wrap) if wrap
 
-      result = catch(:use_fallback) { DeepCover.custom_requirer.load(path) }
-      result = load_without_deep_cover(path) if result.is_a? Symbol
-      result
+      DeepCover.custom_requirer.load(path) { load_without_deep_cover(path) }
     end
-  end
 
-  extend ModuleOverride
-  override ::Kernel, ::Kernel.singleton_class
+    extend ModuleOverride
+    override ::Kernel, ::Kernel.singleton_class
+  end
 end

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -11,9 +11,7 @@ module DeepCover
 
   module RequireOverride
     def require(path)
-      result = catch(:use_fallback) { DeepCover.custom_requirer.require(path) }
-      result = require_without_deep_cover(path) if result.is_a? Symbol
-      result
+      DeepCover.custom_requirer.require(path) { require_without_deep_cover(path) }
     end
 
     def require_relative(path)

data/lib/deep_cover/coverage.rb

@@ -3,8 +3,111 @@
 module DeepCover
   bootstrap
 
+  require_relative_dir 'coverage'
+
+  # A collection of CoveredCode
   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])
+    end
+
+    def covered_codes
+      each.to_a
+    end
+
+    def line_coverage(filename, **options)
+      covered_code(filename).line_coverage(**options)
+    end
+
+    def covered_code?(path)
+      @covered_code_index.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)
+    end
+
+    def each
+      return to_enum unless block_given?
+      @tracker_storage_per_path.each_key do |path|
+        begin
+          cov_code = covered_code(path)
+        rescue Parser::SyntaxError
+          next
+        end
+        yield cov_code
+      end
+      self
+    end
+
+    def report(**options)
+      case (reporter = options.fetch(:reporter, DEFAULTS[:reporter]).to_sym)
+      when :html
+        msg = if (output = options.fetch(:output, DEFAULTS[:output]))
+                Reporter::HTML.report(self, **options)
+                "HTML generated: open #{output}/index.html"
+              else
+                'No HTML generated'
+              end
+        Reporter::Text.report(self, **options) + "\n\n" + msg
+      when :istanbul
+        if Reporter::Istanbul.available?
+          Reporter::Istanbul.report(self, **options)
+        else
+          warn 'nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`'
+        end
+      when :text
+        Reporter::Text.report(self, **options)
+      else
+        raise ArgumentError, "Unknown reporter: #{reporter}"
+      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.saved?(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).saved?
+    end
+
+    def save(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).save(self)
+      self
+    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 tracker_global
+      @options.fetch(:tracker_global, DEFAULTS[:tracker_global])
+    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
+    end
   end
-  require_relative_dir 'coverage'
-  Coverage.include Coverage::Istanbul
 end

data/lib/deep_cover/coverage/analysis.rb

@@ -1,40 +1,42 @@
 # frozen_string_literal: true
 
 module DeepCover
-  class Coverage::Analysis < Struct.new(:covered_codes, :options)
-    include Memoize
-    memoize :analyser_map, :stat_map
+  class Coverage
+    class Analysis < Struct.new(:covered_codes, :options)
+      include Memoize
+      memoize :analyser_map, :stat_map
 
-    def analyser_map
-      covered_codes.map do |covered_code|
-        [covered_code, compute_analysers(covered_code)]
-      end.to_h
-    end
+      def analyser_map
+        covered_codes.map do |covered_code|
+          [covered_code, compute_analysers(covered_code)]
+        end.to_h
+      end
 
-    def stat_map
-      analyser_map.transform_values { |a| a.transform_values(&:stats) }
-    end
+      def stat_map
+        analyser_map.transform_values { |a| a.transform_values(&:stats) }
+      end
 
-    def self.template
-      {node: Analyser::Node, per_char: Analyser::PerChar, branch: Analyser::Branch}
-    end
+      def overall
+        return 100 if stat_map.empty?
+        node, branch = Tools.merge(*stat_map.values, :+).values_at(:node, :branch)
+        (node + branch).percent_covered
+      end
 
-    private
+      def self.template
+        {node: Analyser::Node, per_char: Analyser::PerChar, branch: Analyser::Branch}
+      end
 
-    def compute_analysers(covered_code)
-      base = Analyser::Node.new(covered_code, **options)
-      {node: base}.merge!(
-          {
-            per_char: Analyser::PerChar,
-            branch: Analyser::Branch,
-          }.transform_values { |klass| klass.new(base, **options) }
-      )
-    end
-  end
+      private
 
-  class Coverage
-    def analysis(**options)
-      Analysis.new(covered_codes, options)
+      def compute_analysers(covered_code)
+        base = Analyser::Node.new(covered_code, **options)
+        {node: base}.merge!(
+            {
+              per_char: Analyser::PerChar,
+              branch: Analyser::Branch,
+            }.transform_values { |klass| klass.new(base, **options) }
+        )
+      end
     end
   end
 end

data/lib/deep_cover/coverage/persistence.rb

@@ -2,93 +2,83 @@
 
 module DeepCover
   require 'securerandom'
-  class Coverage::Persistence
-    BASENAME = 'coverage.dc'
-    TRACKER_TEMPLATE = 'trackers%{unique}.dct'
+  class Coverage
+    class Persistence
+      BASENAME = 'coverage.dc'
+      TRACKER_TEMPLATE = 'trackers%{unique}.dct'
 
-    attr_reader :dir_path
-    def initialize(dest_path, dirname)
-      @dir_path = Pathname(dest_path).join(dirname).expand_path
-    end
+      attr_reader :dir_path
+      def initialize(dest_path, dirname)
+        @dir_path = Pathname(dest_path).join(dirname).expand_path
+      end
 
-    def load(with_trackers: true)
-      saved?
-      load_trackers if with_trackers
-      load_coverage
-    end
+      def load(with_trackers: true)
+        saved?
+        cov = load_coverage
+        cov.tracker_storage_per_path.tracker_hits_per_path = load_trackers if with_trackers
+        cov
+      end
 
-    def save(coverage)
-      create_if_needed
-      delete_trackers
-      save_coverage(coverage)
-    end
+      def save(coverage)
+        create_if_needed
+        delete_trackers
+        save_coverage(coverage)
+      end
 
-    def save_trackers(global)
-      saved?
-      trackers = eval(global) # rubocop:disable Security/Eval
-      # Some testing involves more than one process, some of which don't run any of our covered code.
-      # Don't save anything if that's the case
-      return if trackers.nil?
-      basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
-      dir_path.join(basename).binwrite(Marshal.dump(
-                                           version: DeepCover::VERSION,
-                                           global: global,
-                                           trackers: trackers,
-      ))
-    end
+      def save_trackers(tracker_hits_per_path)
+        saved?
+        basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
+        dir_path.join(basename).binwrite(Marshal.dump(
+                                             version: DeepCover::VERSION,
+                                             tracker_hits_per_path: tracker_hits_per_path,
+        ))
+      end
 
-    def saved?
-      raise "Can't find folder '#{dir_path}'" unless dir_path.exist?
-      self
-    end
+      def saved?
+        raise "Can't find folder '#{dir_path}'" unless dir_path.exist?
+        self
+      end
 
-    private
+      private
 
-    def create_if_needed
-      dir_path.mkpath
-    end
-
-    def save_coverage(coverage)
-      dir_path.join(BASENAME).binwrite(Marshal.dump(
-                                           version: DeepCover::VERSION,
-                                           coverage: coverage,
-      ))
-    end
+      def create_if_needed
+        dir_path.mkpath
+      end
 
-    # rubocop:disable Security/MarshalLoad
-    def load_coverage
-      Marshal.load(dir_path.join(BASENAME).binread).tap do |version:, coverage:|
-        raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
-        return coverage
+      def save_coverage(coverage)
+        dir_path.join(BASENAME).binwrite(Marshal.dump(
+                                             version: DeepCover::VERSION,
+                                             coverage: coverage,
+        ))
       end
-    end
 
-    def load_trackers
-      tracker_files.each do |full_path|
-        Marshal.load(full_path.binread).tap do |version:, global:, trackers:|
+      # rubocop:disable Security/MarshalLoad
+      def load_coverage
+        Marshal.load(dir_path.join(BASENAME).binread).tap do |version:, coverage:|
           raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
-          merge_trackers(eval("#{global} ||= {}"), trackers) # rubocop:disable Security/Eval
+          return coverage
         end
       end
-    end
-    # rubocop:enable Security/MarshalLoad
 
-    def merge_trackers(hash, to_merge)
-      hash.merge!(to_merge) do |_key, current, to_add|
-        unless current.empty? || current.size == to_add.size
-          warn "Merging trackers of different sizes: #{current.size} vs #{to_add.size}"
-        end
-        to_add.zip(current).map { |a, b| a + b }
+      # returns a TrackerHitsPerPath
+      def load_trackers
+        tracker_files.map do |full_path|
+          Marshal.load(full_path.binread).yield_self do |version:, tracker_hits_per_path:|
+            raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
+            tracker_hits_per_path
+          end
+        end.inject(:merge!)
       end
-    end
+      # rubocop:enable Security/MarshalLoad
 
-    def tracker_files
-      basename = format(TRACKER_TEMPLATE, unique: '*')
-      Pathname.glob(dir_path.join(basename))
-    end
+      def tracker_files
+        basename = format(TRACKER_TEMPLATE, unique: '*')
+        Pathname.glob(dir_path.join(basename))
+      end
 
-    def delete_trackers
-      tracker_files.each(&:delete)
+      def delete_trackers
+        tracker_files.each(&:delete)
+      end
     end
   end
 end