deep-cover 0.6.2 → 0.6.3.pre

data/lib/deep_cover/coverage.rb

@@ -1,125 +0,0 @@
-# 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/coverage/analysis.rb

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

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

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

data/lib/deep_cover/custom_requirer.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  class CustomRequirer
-    attr_reader :load_paths, :loaded_features, :filter
-    def initialize(load_paths: $LOAD_PATH, loaded_features: $LOADED_FEATURES, &filter)
-      @load_paths = load_paths
-      @loaded_features = loaded_features
-      @filter = filter
-      @paths_being_required = Set.new
-
-      # A Set of the loaded_features for faster access
-      @loaded_features_set = Set.new
-      # A dup of the loaded_features as they are expected to be for the Set to be valid
-      # If this is different from loaded_features, the set should be refreshed
-      @duped_loaded_features_used_for_set = []
-    end
-
-    # Returns a path to an existing file or nil if none can be found.
-    # The search follows how ruby search for files using the $LOAD_PATH, but limits
-    # those it checks based on the LoadPathsSubset.
-    #
-    # An absolute path is returned directly if it exists, otherwise nil is returned
-    # without searching anywhere else.
-    def resolve_path(path, extensions_to_try = ['.rb', '.so'])
-      if extensions_to_try
-        extensions_to_try = [''] if extensions_to_try.any? { |ext| path.end_with?(ext) }
-      else
-        extensions_to_try = ['']
-      end
-
-      abs_path = File.absolute_path(path)
-      path = abs_path if path.start_with?('./', '../')
-
-      paths_with_ext = extensions_to_try.map { |ext| path + ext }
-
-      refresh_loaded_features_set
-
-      # Doing this check in every case instead of only for absolute_path because ruby has some
-      # built-in $LOADED_FEATURES which aren't an absolute path. Ex: enumerator.so, thread.rb
-      path_from_loaded_features = first_path_from_loaded_features_set(paths_with_ext)
-      return path_from_loaded_features if path_from_loaded_features
-
-      if path == abs_path
-        paths_with_ext.each do |path_with_ext|
-          return path_with_ext if File.exist?(path_with_ext)
-        end
-      else
-        possible_paths = paths_with_load_paths(paths_with_ext)
-        path_from_loaded_features = first_path_from_loaded_features_set(possible_paths)
-        return path_from_loaded_features if path_from_loaded_features
-
-        possible_paths.each do |possible_path|
-          next unless File.exist?(possible_path)
-          # Ruby 2.5 changed some behaviors of require related to symlinks in $LOAD_PATH
-          # https://bugs.ruby-lang.org/issues/10222
-          return File.realpath(possible_path) if RUBY_VERSION >= '2.5'
-          return possible_path
-        end
-      end
-      nil
-    end
-
-    # Homemade #require to be able to instrument the code before it gets executed.
-    # Returns true when everything went right. (Same as regular ruby)
-    # Returns false when the found file was already required. (Same as regular ruby)
-    # Calls &fallback_block with the reason as parameter if the work couldn't be done.
-    # The possible reasons are:
-    #  - :not_found if the file couldn't be found.
-    #  - :not_in_covered_paths if the file is not in the paths to cover
-    #  - :cover_failed if DeepCover couldn't apply instrumentation the file found.
-    #  - :not_supported for files that are not supported (such as .so files)
-    #  - :skipped if the filter block returned `true`
-    # Exceptions raised by the required code bubble up as normal, except for
-    # SyntaxError, which is turned into a :cover_failed which calls the fallback_block.
-    def require(path) # &fallback_block
-      path = path.to_s
-
-      found_path = resolve_path(path)
-
-      if found_path
-        return false if @loaded_features.include?(found_path)
-        return false if @paths_being_required.include?(found_path)
-      end
-
-      DeepCover.autoload_tracker.wrap_require(path, found_path) do
-        begin
-          # Either a problem with resolve_path, or a gem that will be added to the load_path by RubyGems
-          return yield(:not_found) unless found_path
-
-          @paths_being_required.add(found_path)
-          return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
-          return yield(:not_supported) if found_path.end_with?('.so')
-          return yield(:skipped) if filter && filter.call(found_path)
-
-          cover_and_execute(found_path) { |reason| return yield(reason) }
-
-          @loaded_features << found_path
-        ensure
-          @paths_being_required.delete(found_path)
-          add_last_loaded_feature_to_set
-        end
-      end
-      true
-    end
-
-    # Homemade #load to be able to instrument the code before it gets executed.
-    # Note, this doesn't support the `wrap` parameter that ruby's #load has.
-    # Same yield/return behavior as CustomRequirer#require, except that it
-    # cannot return false #load doesn't care about a file already being executed.
-    def load(path) # &fallback_block
-      path = path.to_s
-
-      found_path = resolve_path(path, nil)
-
-      if found_path.nil?
-        # #load has a final fallback of always trying relative to current work directory
-        possible_path = File.absolute_path(path)
-        found_path = possible_path if File.exist?(possible_path)
-      end
-
-      return yield(:not_found) unless found_path
-      return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
-
-      cover_and_execute(found_path) { |reason| return yield(reason) }
-
-      true
-    end
-
-    def is_being_required?(path)
-      found_path = resolve_path(path)
-      @paths_being_required.include?(found_path)
-    end
-
-    protected
-
-    # updates the loaded_features_set if it needs it
-    def refresh_loaded_features_set
-      return if @duped_loaded_features_used_for_set == @loaded_features
-
-      @duped_loaded_features_used_for_set = @loaded_features.dup
-      @loaded_features_set = Set.new(@duped_loaded_features_used_for_set)
-    end
-
-    # Returns the first path found in the loaded_features_set
-    # Should be called after doing a #refresh_loaded_features_set
-    def first_path_from_loaded_features_set(paths)
-      paths.detect { |path| @loaded_features_set.include?(path) }
-    end
-
-    # Called after a require, adds the last entry of loaded_features to the
-    # loaded_features_set and the clone used to check for a need to refresh
-    # the loaded_features_set. Doing this allows us to never need to update
-    # the loaded_feature_set from scratch (almost? this is a safety precaution)
-    def add_last_loaded_feature_to_set
-      loaded_feature = @loaded_features.last
-      unless @loaded_features_set.include?(loaded_feature)
-        @duped_loaded_features_used_for_set << loaded_feature
-        @loaded_features_set << loaded_feature
-      end
-    end
-
-    def paths_with_load_paths(paths)
-      paths.flat_map do |path|
-        @load_paths.map do |load_path|
-          File.absolute_path(path, load_path)
-        end
-      end
-    end
-
-    def cover_and_execute(path) # &fallback_block
-      covered_code = DeepCover.coverage.covered_code_or_warn(path)
-      if covered_code.nil?
-        yield(:cover_failed)
-        raise "The fallback_block is supposed to either return or break, but didn't do either"
-      end
-
-      success = covered_code.execute_code_or_warn
-      unless success
-        yield(:cover_failed)
-        raise "The fallback_block is supposed to either return or break, but didn't do either"
-      end
-
-      covered_code
-    end
-  end
-end