deep-cover-core 0.6.3.pre

data/lib/deep_cover/core_ext/autoload_overrides.rb

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

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

@@ -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/instruction_sequence_load_iseq.rb

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

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

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

data/lib/deep_cover/coverage/analysis.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DeepCover
+  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 stat_map
+        analyser_map.transform_values { |a| a.transform_values(&:stats) }
+      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
+
+      def self.template
+        {node: Analyser::Node, per_char: Analyser::PerChar, branch: Analyser::Branch}
+      end
+
+      private
+
+      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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require 'securerandom'
+  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
+
+      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_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
+
+      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
+
+      # 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
+        end
+      end
+
+      # 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
+      # rubocop:enable Security/MarshalLoad
+
+      def tracker_files
+        basename = format(TRACKER_TEMPLATE, unique: '*')
+        Pathname.glob(dir_path.join(basename))
+      end
+
+      def delete_trackers
+        tracker_files.each(&:delete)
+      end
+    end
+  end
+end

data/lib/deep_cover/coverage.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+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 covered_code_or_warn(path, **options)
+      covered_code(path, **options)
+    rescue Parser::SyntaxError => e
+      if e.message =~ /contains escape sequences incompatible with UTF-8/
+        warn "Can't cover #{path} because of incompatible encoding (see issue #9)"
+      else
+        warn "The file #{path} can't be instrumented"
+      end
+      nil
+    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
+end

data/lib/deep_cover/covered_code.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+  load_parser
+
+  class CoveredCode
+    attr_accessor :covered_source, :buffer, :tracker_storage, :local_var, :path
+
+    def initialize(
+      path: nil,
+      source: nil,
+      lineno: 1,
+      tracker_global: DEFAULTS[:tracker_global],
+      tracker_storage: TrackerBucket[tracker_global].create_storage,
+      local_var: '_temp'
+    )
+      raise 'Must provide either path or source' unless path || source
+
+      @path = path &&= Pathname(path)
+      @buffer = Parser::Source::Buffer.new('', lineno)
+      @buffer.source = source || path.read
+      @tracker_count = 0
+      @tracker_storage = tracker_storage
+      @local_var = local_var
+      @covered_source = instrument_source
+    end
+
+    def lineno
+      @buffer.first_line
+    end
+
+    def nb_lines
+      lines = buffer.source_lines
+      if lines.empty?
+        0
+      else
+        lines.size - (lines.last.empty? ? 1 : 0)
+      end
+    end
+
+    def execute_code(binding: DeepCover::GLOBAL_BINDING.dup)
+      eval(@covered_source, binding, (@path || '<raw_code>').to_s, lineno) # rubocop:disable Security/Eval
+      self
+    end
+
+    def execute_code_or_warn(*args)
+      warn_instead_of_syntax_error do
+        execute_code(*args)
+      end
+    end
+
+    def cover
+      global[nb] ||= Array.new(@tracker_count, 0)
+    end
+
+    def line_coverage(**options)
+      Analyser::PerLine.new(self, **options).results
+    end
+
+    def char_cover(**options)
+      Analyser::PerChar.new(self, **options).results
+    end
+
+    def tracker_hits(tracker_id)
+      cover.fetch(tracker_id)
+    end
+
+    def covered_ast
+      root.main
+    end
+
+    def comments
+      root
+      @comments
+    end
+
+    def root
+      @root ||= begin
+        ast, @comments = parser.parse_with_comments(@buffer)
+        Node::Root.new(ast, self)
+      end
+    end
+
+    def each_node(*args, &block)
+      covered_ast.each_node(*args, &block)
+    end
+
+    def instrument_source
+      rewriter = Parser::Source::TreeRewriter.new(@buffer)
+      covered_ast.each_node(:postorder) do |node|
+        node.rewriting_rules.each do |range, rule|
+          prefix, _node, suffix = rule.partition('%{node}')
+          prefix = yield prefix, node, range.begin, :prefix if block_given? && !prefix.empty?
+          suffix = yield suffix, node, range.end, :suffix if block_given? && !suffix.empty?
+          rewriter.wrap(range, prefix, suffix)
+        end
+      end
+      rewriter.process
+    end
+
+    def compile
+      RubyVM::InstructionSequence.compile(covered_source, path.to_s, path.to_s)
+    end
+
+    def compile_or_warn
+      warn_instead_of_syntax_error do
+        compile
+      end
+    end
+
+    def freeze
+      unless frozen? # Guard against reentrance
+        super
+        root.each_node(&:freeze)
+      end
+      self
+    end
+
+    def inspect
+      %{#<DeepCover::CoveredCode "#{path}">}
+    end
+    alias_method :to_s, :inspect
+
+    def warn_instead_of_syntax_error # &block
+      yield
+    rescue ::SyntaxError => e
+      warn Tools.strip_heredoc(<<-MSG)
+          DeepCover is getting confused with the file #{path} and it won't be instrumented.
+          Please report this error and provide the source code around the following lines:
+          #{e}
+      MSG
+      nil
+    end
+
+    private
+
+    def parser
+      Parser::CurrentRuby.new.tap do |parser|
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings      = true
+      end
+    end
+  end
+end