deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/basics.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# Basic constants without any dependencies are here
-module DeepCover
-  DEFAULTS = {
-               ignore_uncovered: [].freeze,
-               paths: %w[./app ./lib].freeze,
-               allow_partial: false,
-               tracker_global: '$_cov',
-               reporter: :html,
-               output: './coverage',
-             }.freeze
-
-  CLI_DEFAULTS = {
-                   command: 'bundle exec rake',
-                   bundle: true,
-                   process: true,
-                   open: false,
-                 }.freeze
-
-  OPTIONALLY_COVERED = %i[case_implicit_else default_argument raise trivial_if warn]
-end

data/lib/deep_cover/builtin_takeover.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../deep_cover'
-require_relative 'coverage'
-require_relative 'core_ext/coverage_replacement'
-
-require 'coverage'
-BuiltinCoverage = Coverage
-Object.send(:remove_const, 'Coverage')
-Coverage = DeepCover::CoverageReplacement.dup

data/lib/deep_cover/config.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  class Config
-    def initialize(notify = nil)
-      @notify = notify
-      @options = DEFAULTS.dup
-    end
-
-    def to_hash
-      @options.dup
-    end
-    alias_method :to_h, :to_hash
-
-    def ignore_uncovered(*keywords, &block)
-      if block
-        raise ArgumentError, "wrong number of arguments (given #{keywords.size}, expected 0..1)" if keywords.size > 1
-        keywords << Node.unique_filter if keywords.empty?
-        Node.create_filter(keywords.first, &block)
-      end
-      if keywords.empty?
-        @options[:ignore_uncovered]
-      else
-        keywords = check_uncovered(keywords)
-        change(:ignore_uncovered, @options[:ignore_uncovered] | keywords)
-      end
-    end
-
-    def detect_uncovered(*keywords)
-      raise ArgumentError, 'No block is accepted' if block_given?
-      if keywords.empty?
-        OPTIONALLY_COVERED - @options[:ignore_uncovered]
-      else
-        keywords = check_uncovered(keywords)
-        change(:ignore_uncovered, @options[:ignore_uncovered] - keywords)
-      end
-    end
-
-    def paths(paths = nil)
-      if paths
-        change(:paths, Array(paths).dup)
-      else
-        @options[:paths]
-      end
-    end
-
-    def tracker_global(tracker_global = nil)
-      if tracker_global
-        change(:tracker_global, tracker_global)
-      else
-        @options[:tracker_global]
-      end
-    end
-
-    def reporter(reporter = nil)
-      if reporter
-        change(:reporter, reporter)
-      else
-        @options[:reporter]
-      end
-    end
-
-    def output(path_or_false = nil)
-      if path_or_false != nil
-        change(:output, path_or_false)
-      else
-        @options[:output]
-      end
-    end
-
-    def reset
-      DEFAULTS.each do |key, value|
-        change(key, value)
-      end
-      self
-    end
-
-    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
-    end
-
-    private
-
-    def check_uncovered(keywords)
-      keywords = keywords.first if keywords.size == 1 && keywords.first.is_a?(Array)
-      unknown = keywords - OPTIONALLY_COVERED
-      raise ArgumentError, "unknown options: #{unknown.join(', ')}" unless unknown.empty?
-      keywords
-    end
-
-    def change(option, value)
-      if @options[option] != value
-        @options[option] = value.freeze
-        @notify.config_changed(option) if @notify.respond_to? :config_changed
-      end
-      self
-    end
-  end
-end

data/lib/deep_cover/config_setter.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module ConfigSetter
-    def config_queue
-      @config_queue ||= []
-    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
-      @config
-    end
-
-    def configure(&block)
-      raise 'Must provide a block' unless block
-      @config ||= nil # avoid warning
-      if @config == nil
-        config_queue << block
-      else
-        case block.arity
-        when 0
-          @config.instance_eval(&block)
-        when 1
-          block.call(@config)
-        end
-      end
-      self
-    end
-  end
-end

data/lib/deep_cover/core_ext/autoload_overrides.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-# Autoload is quite difficult to hook into to do what we need to do.
-#
-# 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'
-#
-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
-      autoload_path = DeepCover.autoload_tracker.autoload_path_for(mod, name, path)
-      mod.autoload_without_deep_cover(name, autoload_path)
-    end
-
-    extend ModuleOverride
-    override ::Kernel, ::Kernel.singleton_class
-  end
-
-  module ModuleAutoloadOverride
-    def autoload(name, path)
-      autoload_path = DeepCover.autoload_tracker.autoload_path_for(self, name, path)
-      autoload_without_deep_cover(name, autoload_path)
-    end
-
-    extend ModuleOverride
-    override Module
-  end
-
-  module AutoloadOverride
-    def self.active=(flag)
-      KernelAutoloadOverride.active = ModuleAutoloadOverride.active = flag
-    end
-  end
-end

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-# This is a complete replacement for the builtin Coverage module of Ruby
-
-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(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
-
-      def result
-        r = peek_result
-        DeepCover.stop
-        r
-      end
-
-      def peek_result
-        raise 'coverage measurement is not enabled' unless running?
-        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
-end

data/lib/deep_cover/core_ext/exec_callbacks.rb

@@ -1,27 +0,0 @@
-# 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/instruction_sequence_load_iseq.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  load_all
-
-  module InstructionSequenceLoadIseq
-    def load_iseq(path)
-      compiled = InstructionSequenceLoadIseq.load_iseq_logic(path)
-
-      return compiled if compiled
-
-      # By default there is no super, but if bootsnap is there, and things are in the right order,
-      # we could possibly fallback to it as usual to keep the perf gain. Same for other possible
-      # tools using #load_iseq
-      super if defined?(super)
-    end
-
-    def self.load_iseq_logic(path)
-      return unless DeepCover.running?
-      return unless DeepCover.within_lookup_paths?(path)
-
-      covered_code = DeepCover.coverage.covered_code_or_warn(path)
-      return unless covered_code
-
-      covered_code.compile_or_warn
-    end
-  end
-end
-
-class << RubyVM::InstructionSequence
-  prepend DeepCover::InstructionSequenceLoadIseq
-end

data/lib/deep_cover/core_ext/load_overrides.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-# These are the monkeypatches to replace the default #load in order
-# to instrument the code before it gets run.
-# For now, this is not used, and may never be. The tracking and reporting for things can might be
-# loaded multiple times can be complex and is beyond the current scope of the project.
-
-module DeepCover
-  module LoadOverride
-    def load(path, wrap = false)
-      return load_without_deep_cover(path, wrap) if wrap
-
-      DeepCover.custom_requirer.load(path) { load_without_deep_cover(path) }
-    end
-
-    extend ModuleOverride
-    override ::Kernel, ::Kernel.singleton_class
-  end
-end

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-# These are the monkeypatches to replace the default #require and
-# #require_relative in order to instrument the code before it gets run.
-# Kernel.require and Kernel#require must both have their version because
-# each can have been already overwritten individually. (Rubygems only
-# overrides Kernel#require)
-
-module DeepCover
-  load_all
-
-  module RequireOverride
-    def require(path)
-      DeepCover.custom_requirer.require(path) { require_without_deep_cover(path) }
-    end
-
-    def require_relative(path)
-      base = caller(1..1).first[/[^:]+/]
-      raise LoadError, 'cannot infer basepath' unless base
-      base = File.dirname(base)
-
-      require(File.absolute_path(path, base))
-    end
-
-    extend ModuleOverride
-    override ::Kernel, ::Kernel.singleton_class
-  end
-end