deep-cover-core 0.6.3.pre

data/lib/deep_cover/analyser/stats.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::StatsBase
+    DECIMALS = 2
+    include Memoize
+    memoize :to_h, :total
+
+    VALUES = %i[executed not_executed not_executable ignored].freeze # All are exclusive
+
+    attr_reader(*VALUES)
+
+    def to_h
+      VALUES.map { |val| [val, public_send(val)] }.to_h
+    end
+
+    def initialize(executed: 0, not_executed: 0, not_executable: 0, ignored: 0)
+      @executed = executed
+      @not_executed = not_executed
+      @not_executable = not_executable
+      @ignored = ignored
+      freeze
+    end
+
+    def +(other)
+      self.class.new(to_h.merge(other.to_h) { |k, a, b| a + b })
+    end
+
+    def total
+      to_h.values.inject(:+)
+    end
+
+    def with(**values)
+      self.class.new(to_h.merge(values))
+    end
+
+    def potentially_executable
+      total - not_executable
+    end
+
+    def percent_covered
+      return 100 if potentially_executable == 0
+      (100 * (1 - not_executed.fdiv(potentially_executable))).round(DECIMALS)
+    end
+  end
+
+  class Analyser::Stats < Analyser::StatsBase
+    memoize :percent
+
+    def percent
+      Analyser::StatsBase.new(to_h.transform_values { |v| (100 * v).fdiv(total).round(DECIMALS) })
+    end
+  end
+end

data/lib/deep_cover/analyser/subset.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeepCover
+  # A module to create a subset from a criteria called `in_subset?`
+  # Including classes can refine it, or specify SUBSET_CLASSES
+  module Analyser::Subset
+    def node_children(node)
+      find_children(node)
+    end
+
+    private
+
+    def find_children(from, parent = from)
+      @source.node_children(from).flat_map do |node|
+        if in_subset?(node, parent)
+          [node]
+        else
+          find_children(node, parent)
+        end
+      end
+    end
+
+    def in_subset?(node, _parent)
+      self.class::SUBSET_CLASSES.any? { |klass| node.is_a?(klass) }
+    end
+  end
+end

data/lib/deep_cover/analyser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # An analyser works on a subset of the original Node AST.
+  # The Root node is always considered part of the subset.
+  # One can iterate this subset with `each_node`, or ask
+  # the analyser for information about a node's children
+  # (i.e. with respect to this subset), or runs for any node
+  # in this subset.
+
+  # An analyser can summarize information with `results`.
+  # While CoveredCodeSource is based on a CoveredCode, all
+  # other analysers are based on another source analyser.
+
+  class Analyser
+  end
+
+  require_relative_dir 'analyser'
+
+  Analyser.include Analyser::Base
+end

data/lib/deep_cover/auto_run.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'core_ext/exec_callbacks'
+
+module DeepCover
+  module AutoRun
+    class Runner
+      def initialize(covered_path)
+        @covered_path = covered_path
+        @saved = !(DeepCover.respond_to?(:running?) && DeepCover.running?)
+      end
+
+      def run!
+        after_tests { save }
+        ExecCallbacks.before_exec { save }
+        self
+      end
+
+      def report!(**options)
+        after_tests { puts report(**options) }
+        self
+      end
+
+      private
+
+      def saved?
+        @saved
+      end
+
+      def coverage
+        @coverage ||= if saved?
+                        Coverage.load(@covered_path, with_trackers: false)
+                      else
+                        DeepCover.coverage
+                      end
+      end
+
+      def save
+        require_relative '../deep_cover'
+        coverage.save(@covered_path) unless saved?
+        coverage.save_trackers(@covered_path)
+      end
+
+      def report(**options)
+        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!
+    end
+  end
+end

data/lib/deep_cover/autoload_tracker.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'weakref'
+
+# TODO: if a constant is removed, AutoloadEntries should be removed
+
+module DeepCover
+  class AutoloadTracker
+    AutoloadEntry = Struct.new(:weak_mod, :name, :target_path, :interceptor_path) do
+      # If the ref is dead, will return nil
+      # If the target is frozen, will warn and return nil
+      # Otherwise return the target
+      def mod_if_available
+        mod = weak_mod.__getobj__
+        if mod.frozen?
+          AutoloadTracker.warn_frozen_module(mod)
+          nil
+        else
+          mod
+        end
+      rescue WeakRef::RefError
+        nil
+      end
+    end
+
+    attr_reader :autoloads_by_basename, :interceptor_files_by_path
+    def initialize
+      @autoloads_by_basename = {}
+      @interceptor_files_by_path = {}
+    end
+
+    def autoload_path_for(mod, name, path)
+      interceptor_path = setup_interceptor_for(mod, name, path)
+
+      if DeepCover.custom_requirer.is_being_required?(path)
+        already_loaded_feature
+      else
+        interceptor_path
+      end
+    end
+
+    def possible_autoload_target?(requested_path)
+      basename = basename_without_extension(requested_path)
+      autoloads = @autoloads_by_basename[basename]
+      autoloads && !autoloads.empty?
+    end
+
+    def wrap_require(requested_path, absolute_path_found) # &block
+      entries = entries_for_target(requested_path, absolute_path_found)
+
+      begin
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          mod.autoload_without_deep_cover(entry.name, already_loaded_feature)
+        end
+
+        yield
+      ensure
+        entries = entries_for_target(requested_path, absolute_path_found)
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          # Putting the autoloads back back since we couldn't complete the require
+          mod.autoload_without_deep_cover(entry.name, entry.interceptor_path)
+        end
+      end
+    end
+
+    # This is only used on MRI, so ObjectSpace is alright.
+    def initialize_autoloaded_paths(mods = ObjectSpace.each_object(Module)) # &do_autoload_block
+      mods.each do |mod|
+        # Module's constants are shared with Object. But if you set autoloads directly on Module, they
+        # appear on multiple classes. So just skip, Object will take care of those.
+        next if mod == Module
+
+        if mod.frozen?
+          if mod.constants.any? { |name| mod.autoload?(name) }
+            self.class.warn_frozen_module(mod)
+          end
+          next
+        end
+
+        mod.constants.each do |name|
+          path = mod.autoload?(name)
+          next unless path
+          interceptor_path = setup_interceptor_for(mod, name, path)
+          yield mod, name, interceptor_path
+        end
+      end
+    end
+
+    # We need to remove the interceptor hooks, otherwise, the problem if manually requiring
+    # something that is autoloaded will cause issues.
+    def remove_interceptors # &do_autoload_block
+      @autoloads_by_basename.each do |basename, entries|
+        entries.each do |entry|
+          mod = entry.mod_if_available
+          next unless mod
+          # Module's constants are shared with Object. But if you set autoloads directly on Module, they
+          # appear on multiple classes. So just skip, Object will take care of those.
+          next if mod == Module
+          yield mod, entry.name, entry.target_path
+        end
+      end
+
+      @autoloaded_paths = {}
+      @interceptor_files_by_path = {}
+    end
+
+    class << self
+      attr_accessor :warned_for_frozen_module
+    end
+    self.warned_for_frozen_module = false
+
+    # Using frozen modules/classes is almost unheard of, but a warning makes things easier if someone does it
+    def self.warn_frozen_module(mod)
+      return if warned_for_frozen_module
+      self.warned_for_frozen_module ||= true
+      warn "There is an autoload on a frozen module/class: #{mod}, DeepCover cannot handle those, failure is probable. " \
+           "This warning won't be displayed again (even for different module/class)"
+    end
+
+    protected
+
+    def setup_interceptor_for(mod, name, path)
+      interceptor_path = autoload_interceptor_for(path)
+      entry = AutoloadEntry.new(WeakRef.new(mod), name, path, interceptor_path)
+
+      basename = basename_without_extension(path)
+
+      @autoloads_by_basename[basename] ||= []
+      @autoloads_by_basename[basename] << entry
+      interceptor_path
+    end
+
+    def entries_for_target(requested_path, absolute_path_found)
+      basename = basename_without_extension(requested_path)
+      autoloads = @autoloads_by_basename[basename] || []
+
+      if absolute_path_found
+        autoloads.select { |entry| entry_is_target?(entry, requested_path, absolute_path_found) }
+      elsif requested_path == File.absolute_path(requested_path)
+        []
+      elsif requested_path.start_with?('./', '../')
+        []
+      else
+        # We didn't find a path that goes through the $LOAD_PATH
+        # It's possible that RubyGems will actually add the $LOAD_PATH and require an actual file
+        # So we must make a best-guest for possible matches
+        requested_path_to_compare = without_extension(requested_path)
+        autoloads.select { |entry| requested_path_to_compare == without_extension(entry.target_path) }
+      end
+    end
+
+    def entry_is_target?(entry, requested_path, absolute_path_found)
+      return true if entry.target_path == requested_path
+      target_path_rb = with_rb_extension(entry.target_path)
+      return true if target_path_rb == requested_path
+
+      # Even though this is not efficient, it's safer to resolve entries' target_path each time
+      # instead of storing the result, in case subsequent changes to $LOAD_PATH gives different results
+      entry_absolute_path = DeepCover.custom_requirer.resolve_path(entry.target_path)
+      return true if entry_absolute_path == absolute_path_found
+      false
+    end
+
+    def basename_without_extension(path)
+      without_extension(File.basename(path))
+    end
+
+    def with_rb_extension(path)
+      path += '.rb' unless has_supported_extension?(path)
+      path
+    end
+
+    def without_extension(path)
+      path = path[0...-3] if has_supported_extension?(path)
+      path
+    end
+
+    def has_supported_extension?(path)
+      path.end_with?('.rb', '.so')
+    end
+
+    # It is not possible to simply remove an autoload. So, instead, we must change the
+    # autoload to an already loaded path.
+    # The autoload will be set back to what it was once the require returns. This is
+    # needed in case that required path wasn't the one that fulfilled the autoload, or
+    # if the constant and $LOADED_FEATURES gets removed, since in that situation,
+    # the autoload is supposed to be active again.
+    def already_loaded_feature
+      $LOADED_FEATURES.first
+    end
+
+    def autoload_interceptor_for(path)
+      existing_files = @interceptor_files_by_path[path] || []
+      reusable_file = existing_files.detect { |f| !$LOADED_FEATURES.include?(f.path) }
+      return reusable_file.path if reusable_file
+
+      new_file = Tempfile.new([File.basename(path), '.rb'])
+      # Need to store all the tempfiles so that they are not GCed, which would delete the files themselves.
+      # Keeping them by path allows us to reuse them.
+      @interceptor_files_by_path[path] ||= []
+      @interceptor_files_by_path[path] << new_file
+      new_file.write(<<-RUBY)
+# Intermediary file for ruby's autoload made by deep-cover
+require #{path.to_s.inspect}
+      RUBY
+      new_file.close
+
+      new_file.path
+    end
+  end
+end

data/lib/deep_cover/backports.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# We use a few features newer than our target of Ruby 2.1+:
+class Module
+  public :define_method
+end
+require 'pathname'
+class Pathname
+  def write(*args)
+    File.write(to_path, *args)
+  end unless method_defined? :write
+  def binwrite(*args)
+    File.binwrite(to_path, *args)
+  end unless method_defined? :binwrite
+end # nocov
+require 'backports/2.4.0/false_class/dup'
+require 'backports/2.4.0/true_class/dup'
+require 'backports/2.4.0/hash/transform_values'
+require 'backports/2.4.0/enumerable/sum'
+require 'backports/2.5.0/hash/slice'
+require 'backports/2.5.0/hash/transform_keys'
+require 'backports/2.5.0/kernel/yield_self'

data/lib/deep_cover/base.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Base
+    def running?
+      @started ||= false # rubocop:disable Naming/MemoizedInstanceVariableName [#5648]
+    end
+
+    def start
+      return if running?
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+        # Autoload is not supported in JRuby. We currently need to use binding_of_caller
+        # and that is not available in JRuby. An extension may be able to replace this requirement.
+        # require_relative 'core_ext/autoload_overrides'
+        # AutoloadOverride.active = true
+        require_relative 'core_ext/load_overrides'
+        require_relative 'core_ext/require_overrides'
+        LoadOverride.active = RequireOverride.active = true
+      elsif RUBY_VERSION >= '2.3.0'
+        require_relative 'core_ext/instruction_sequence_load_iseq'
+      else
+        require_relative 'core_ext/autoload_overrides'
+        require_relative 'core_ext/load_overrides'
+        require_relative 'core_ext/require_overrides'
+        AutoloadOverride.active = LoadOverride.active = RequireOverride.active = true
+        autoload_tracker.initialize_autoloaded_paths { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
+      end
+
+      config # actualize configuration
+      @lookup_paths = nil
+      @started = true
+    end
+
+    def stop
+      if defined? AutoloadOverride
+        AutoloadOverride.active = false
+        autoload_tracker.remove_interceptors { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
+      end
+      RequireOverride.active = false if defined? RequireOverride
+
+      @started = false
+    end
+
+    def line_coverage(filename)
+      coverage.line_coverage(handle_relative_filename(filename), **config.to_h)
+    end
+
+    def covered_code(filename)
+      coverage.covered_code(handle_relative_filename(filename))
+    end
+
+    def cover(paths: nil)
+      if paths
+        prev = config.paths
+        config.paths(paths)
+      end
+      start
+      yield
+    ensure
+      stop
+      config.paths(prev) if paths
+    end
+
+    def config_changed(what)
+      case what
+      when :paths
+        warn "Changing DeepCover's paths after starting coverage is highly discouraged" if running?
+        @lookup_paths = nil
+      when :tracker_global
+        raise NotImplementedError, "Changing DeepCover's tracker global after starting coverage is not supported" if running?
+        @coverage = nil
+      end
+    end
+
+    def reset
+      stop if running?
+      @coverage = @custom_requirer = @autoload_tracker = @lookup_paths = nil
+      config.reset
+      self
+    end
+
+    def coverage
+      @coverage ||= Coverage.new(tracker_global: config.tracker_global)
+    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
+    end
+
+    def within_lookup_paths?(path)
+      lookup_paths.any? { |lookup_path| path.start_with?(lookup_path) }
+    end
+
+    def custom_requirer
+      @custom_requirer ||= CustomRequirer.new
+    end
+
+    def autoload_tracker
+      @autoload_tracker ||= AutoloadTracker.new
+    end
+
+    private
+
+    def handle_relative_filename(filename)
+      unless Pathname.new(filename).absolute?
+        relative_to = File.dirname(caller(2..2).first.partition(/\.rb:\d/).first)
+        filename = File.absolute_path(filename, relative_to)
+      end
+      filename += '.rb' unless filename =~ /\.rb$/
+      filename
+    end
+  end
+end

data/lib/deep_cover/basics.rb

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,104 @@
+# 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

@@ -0,0 +1,33 @@
+# 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