deep-cover-core 0.6.3.pre

data/lib/deep_cover/custom_requirer.rb

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

data/lib/deep_cover/flag_comment_associator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DeepCover
+  ##
+  # A processor which computes which lines to be considered flagged with the
+  # given lookup
+  #
+  class FlagCommentAssociator
+    ##
+    # @param [DeepCover::RootNode] ast
+    # @param [Array(Parser::Source::Comment)] comments
+    def initialize(covered_code, lookup = 'nocov')
+      @covered_code = covered_code
+      @lookup      = /^#[\s#*-]*#{lookup}[\s#*-]*$/
+      @ranges      = nil
+    end
+
+    def include?(range)
+      return false unless (exp = range.expression)
+      lineno = exp.line
+      ranges.any? { |r| r.cover? lineno }
+    end
+
+    def ranges
+      @ranges ||= compute_ranges
+    end
+
+    private
+
+    def compute_ranges
+      @ranges     = []
+      @flag_start = nil
+      index_ast_lines
+      @covered_code.comments.each { |comment| process(comment) }
+      toggle_flag(@covered_code.buffer.last_line) # handle end of file in case of opened flag
+      @ranges
+    end
+
+    def process(comment)
+      return unless comment.text =~ @lookup
+      ln = comment.location.expression.line
+      toggle_flag(ln) unless line_has_only_comments?(ln)
+      toggle_flag(ln + 1)
+    end
+
+    def toggle_flag(lineno)
+      if @flag_start
+        @ranges << (@flag_start..(lineno - 1))
+        @flag_start = nil
+      else
+        @flag_start = lineno
+      end
+    end
+
+    def index_ast_lines
+      @starts = []
+      @covered_code.each_node do |node|
+        if (exp = node.expression)
+          @starts[exp.line] = true
+        end
+      end
+    end
+
+    def line_has_only_comments?(line)
+      !@starts[line]
+    end
+  end
+end

data/lib/deep_cover/load.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Load
+    AUTOLOAD = %i[analyser autoload_tracker auto_run config
+                  coverage covered_code custom_requirer
+                  tracker_hits_per_path tracker_storage_per_path
+                  flag_comment_associator memoize module_override node
+                  problem_with_diagnostic reporter tracker_bucket
+                 ]
+
+    def load_absolute_basics
+      require_relative 'base'
+      require_relative 'basics'
+      require_relative 'config_setter'
+      require_relative 'tools/camelize'
+      AUTOLOAD.each do |module_name|
+        DeepCover.autoload(Tools::Camelize.camelize(module_name), "#{__dir__}/#{module_name}")
+      end
+      DeepCover.autoload :VERSION, "#{__dir__}/version"
+      Object.autoload :Term, 'term/ansicolor'
+      Object.autoload :Terminal, 'terminal-table'
+      Object.autoload :YAML, 'yaml'
+      Object.autoload :Forwardable, 'forwardable'
+    end
+
+    def bootstrap
+      @bootstrapped ||= false # Avoid warning
+      return if @bootstrapped
+      require_relative 'backports'
+      require_relative 'tools'
+      @bootstrapped = true
+    end
+
+    def load_parser
+      @parser_loaded ||= false # Avoid warning
+      return if @parser_loaded
+      silence_warnings do
+        require 'parser'
+        require 'parser/current'
+      end
+      require_relative_dir 'parser_ext'
+      @parser_loaded = true
+    end
+
+    def load_pry
+      silence_warnings do # Avoid "WARN: Unresolved specs during Gem::Specification.reset"
+        require 'pry'     # after `pry` calls `Gem.refresh`
+      end
+    end
+
+    def load_all
+      @all_loaded ||= false
+      return if @all_loaded
+      bootstrap
+      load_parser
+      AUTOLOAD.each do |module_name|
+        DeepCover.const_get(Tools::Camelize.camelize(module_name))
+      end
+      DeepCover.const_get(:VERSION)
+      @all_loaded = true
+    end
+  end
+
+  extend Load
+end

data/lib/deep_cover/memoize.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # Memoize is a quick way to prepend a module that defines
+  # the memoized methods as `@_cache ||= super.freeze`
+  # It also refines `freeze` to precache memoized methods
+  #
+  module Memoize
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def freeze
+      self.class.memoized.each do |method|
+        send method
+      end
+      super
+    end
+
+    module ClassMethods
+      def memoized
+        @memoized ||= [].freeze
+      end
+
+      def memoizer_module
+        @memoizer_module ||= begin
+          mod = const_set(:Memoizer, Module.new)
+          prepend mod
+          mod
+        end
+      end
+
+      def memoize(*methods)
+        @memoized = (memoized | methods).freeze
+
+        methods.each do |method|
+          memoizer_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}                    # def foo
+              @_#{method} ||= super.freeze   #   @_foo ||= super.freeze
+            end                              # end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/module_override.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DeepCover
+  # Helps redefine methods in overriden_modules.
+  # For each methods in Mod, this defines `<method>_with{out}_deep_cover`.
+  # Set `active` to true or false to alias <method> to one or the other.
+  module ModuleOverride
+    attr_reader :overriden_modules
+
+    def active=(active)
+      each do |mod, method_name|
+        mod.send :alias_method, method_name, :"#{method_name}_#{active ? 'with' : 'without'}_deep_cover"
+        if mod == ::Kernel
+          mod.send :private, method_name
+        end
+      end
+    end
+
+    def override(*modules)
+      @overriden_modules = modules
+      each do |mod, method_name|
+        mod.send :alias_method, :"#{method_name}_without_deep_cover", method_name
+        mod.send :define_method, :"#{method_name}_with_deep_cover", instance_method(method_name)
+        if mod == ::Kernel
+          mod.send :private, :"#{method_name}_without_deep_cover"
+          mod.send :private, :"#{method_name}_with_deep_cover"
+        end
+      end
+    end
+
+    def each(&block)
+      overriden_modules.each do |mod|
+        instance_methods(false).each do |method_name|
+          yield mod, method_name
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/arguments.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'assignments'
+
+module DeepCover
+  class Node
+    class Arg < Node
+      has_child name: Symbol
+      def executable?
+        false
+      end
+    end
+    Kwarg = Arg
+
+    class Restarg < Node
+      has_child name: [Symbol, nil]
+      def executable?
+        false
+      end
+    end
+    Kwrestarg = Restarg
+
+    class Optarg < Node
+      has_tracker :default
+      has_child name: Symbol
+      has_child default: Node, flow_entry_count: :default_tracker_hits, rewrite: '(%{default_tracker};%{node})'
+
+      def executable?
+        false
+      end
+    end
+    Kwoptarg = Optarg
+
+    # foo(&block)
+    class Blockarg < Node
+      has_child name: Symbol
+
+      def executable?
+        false
+      end
+    end
+
+    class Args < Node
+      has_extra_children arguments: [Arg, Optarg, Restarg, Kwarg, Kwoptarg, Kwrestarg, Blockarg, Mlhs]
+
+      def executable?
+        false
+      end
+    end
+  end
+end