deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/analyser/statement.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'subset'
-
-module DeepCover
-  class Analyser::Statement < Analyser
-    include Analyser::Subset
-    # Returns a map of Range => runs
-    def results
-      each_node.map do |node|
-        [node.expression, node_runs(node)]
-      end.to_h
-    end
-
-    private
-
-    def in_subset?(node, parent)
-      is_statement = node.is_statement
-      if node.expression.nil?
-        false
-      elsif is_statement != :if_incompatible
-        is_statement
-      else
-        !compatible_runs?(node_runs(parent), node_runs(node))
-      end
-    end
-
-    def compatible_runs?(expression_runs, sub_expression_runs)
-      sub_expression_runs.nil? ||
-        (sub_expression_runs == 0) == (expression_runs == 0)
-    end
-  end
-end

data/lib/deep_cover/analyser/stats.rb

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

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

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

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

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

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