deep-cover-core 0.6.3.pre

data/lib/deep_cover/tools/indent_string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::IndentString
+    # In-place implementation copied from active-support.
+    IMPLEMENTATION = ->(amount, indent_string = nil, indent_empty_lines = false) do
+      indent_string = indent_string || self[/^[ \t]/] || ' '
+      re = indent_empty_lines ? /^/ : /^(?!$)/
+      gsub!(re, indent_string * amount)
+    end
+
+    # Same as #indent! from active-support
+    # https://github.com/rails/rails/blob/10e1f1f9a129f2f197a44009a99b73b8ff9dbc0d/activesupport/lib/active_support/core_ext/string/indent.rb#L7
+    def indent_string!(string, *args)
+      string.instance_exec(*args, &IMPLEMENTATION)
+    end
+
+    # Same as #indent from active-support
+    # https://github.com/rails/rails/blob/10e1f1f9a129f2f197a44009a99b73b8ff9dbc0d/activesupport/lib/active_support/core_ext/string/indent.rb#L42
+    def indent_string(string, *args)
+      string = string.dup
+      indent_string!(string, *args)
+      string
+    end
+  end
+end

data/lib/deep_cover/tools/merge.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::Merge
+    def merge(*hashes)
+      if hashes.last.is_a?(Symbol)
+        oper = hashes.pop
+        merge(*hashes) { |a, b| a.public_send(oper, b) }
+      elsif !block_given?
+        merge(*hashes, &:last)
+      else
+        hashes.inject { |result, h| result.merge(h) { |key, a, b| yield [a, b] } }
+      end
+    end
+  end
+end

data/lib/deep_cover/tools/number_lines.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::NumberLines
+    def number_lines(lines, lineno: 1, bad_linenos: [])
+      max_lineno = lineno + lines.size - 1
+      nb_lineno_digits = max_lineno.to_s.size
+      lines.map.with_index do |line, i|
+        cur_lineno = lineno + i
+        cur_lineno_s = cur_lineno.to_s.rjust(nb_lineno_digits)
+        if bad_linenos.include?(cur_lineno)
+          cur_lineno_s = "*#{cur_lineno_s}" unless bad_linenos.empty?
+          prefix = Term::ANSIColor.red("#{cur_lineno_s} | ")
+        else
+          cur_lineno_s = " #{cur_lineno_s}" unless bad_linenos.empty?
+          prefix = Term::ANSIColor.white("#{cur_lineno_s} | ")
+        end
+        "#{prefix}#{line}"
+      end
+    end
+  end
+end

data/lib/deep_cover/tools/our_coverage.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::OurCoverage
+    def our_coverage(source, filename, lineno, **options)
+      covered_code = CoveredCode.new(source: source, path: filename, lineno: lineno)
+      Tools.execute_sample(covered_code)
+      covered_code.line_coverage(options)[(lineno - 1)..-1]
+    end
+  end
+end

data/lib/deep_cover/tools/profiling.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module DeepCover
+  module Tools::Profiling
+    # Simple forwarding to implementation
+    def start
+      profiler.start
+    end
+
+    def stop
+      @results = profiler.stop
+    end
+
+    def pause
+      profiler.pause
+    end
+
+    def resume
+      profiler.resume
+    end
+
+    def report
+      profiler.report(@results)
+    end
+
+    # Basic utilities using forwarding methods
+    def profile(do_start = true)
+      return yield unless do_start
+      start
+      yield
+      stop
+      report
+    end
+
+    def dont_profile
+      pause if profiler_loaded?
+      yield
+    ensure
+      resume if profiler_loaded?
+    end
+
+    def profiler_loaded?
+      !!@profiler
+    end
+
+    private
+
+    # Dependency injection
+    def profiler
+      @profiler = RubyProfProfiler.new
+    end
+
+    class RubyProfProfiler < SimpleDelegator
+      def initialize
+        raise 'Profiling is not available when using JRuby' if RUBY_PLATFORM == 'java'
+        require 'ruby-prof'
+        super(RubyProf)
+      end
+
+      def report(results)
+        printer = RubyProf::GraphPrinter.new(results)
+        printer.print(STDOUT, {})
+      end
+    end
+  end
+end

data/lib/deep_cover/tools/render_template.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::RenderTemplate
+    def render_template(template, bound_object)
+      require 'erb'
+      caller_path = Pathname.new(caller(1..1).first.partition(/\.rb:\d/).first).dirname
+      template = caller_path.join("template/#{template}.html.erb").read
+      erb = ERB.new(template)
+      erb.result(bound_object.instance_eval { binding })
+    end
+  end
+end

data/lib/deep_cover/tools/require_relative_dir.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::RequireRelativeDir
+    def require_relative_dir(dir_name, except: [])
+      dir = File.dirname(caller(1..1).first.partition(/\.rb:\d/).first)
+      Dir["#{dir}/#{dir_name}/*.rb"].sort.each do |file|
+        require file unless except.include? File.basename(file, '.rb')
+      end
+    end
+  end
+end

data/lib/deep_cover/tools/scan_match_datas.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::RequireRelativeDir
+    # Like String#scan, but return the MatchData object instead
+    def scan_match_datas(source, matcher)
+      source.to_enum(:scan, matcher).map { Regexp.last_match }
+    end
+  end
+end

data/lib/deep_cover/tools/silence_warnings.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::SilenceWarnings
+    # copied from: activesupport/lib/active_support/core_ext/kernel/reporting.rb
+    def silence_warnings
+      with_warnings(nil) { yield }
+    end
+
+    def with_warnings(flag)
+      old_verbose = $VERBOSE
+      $VERBOSE = flag
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/deep_cover/tools/slice.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::Slice
+    def slice(hash, *keys)
+      keys.each_with_object({}) { |k, h| h[k] = hash[k] if hash.has_key?(k) }
+    end
+  end
+end

data/lib/deep_cover/tools/strip_heredoc.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::StripHeredoc
+    # In-place implementation copied from active-support.
+    IMPLEMENTATION = -> do
+      gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, ''.freeze).tap do |stripped|
+        stripped.freeze if frozen?
+      end
+    end
+
+    # Same as #strip_heredoc from active-support
+    # https://github.com/rails/rails/blob/16574409f813e2197f88e4a06b527618d64d9ff0/activesupport/lib/active_support/core_ext/string/strip.rb#L22
+    def strip_heredoc(string)
+      string.instance_exec(&IMPLEMENTATION)
+    end
+  end
+end

data/lib/deep_cover/tools/truncate_backtrace.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::TruncateBacktrace
+    def truncate_backtrace(backtrace, extra_context: 10)
+      backtrace = backtrace.backtrace if backtrace.is_a?(Exception)
+      trace_lines = backtrace.uniq
+
+      keep_from_begin = 0
+      keep_from_end = backtrace.size - 1
+
+      trace_lines.each do |line|
+        from_begin = backtrace.index(line)
+        from_end = backtrace.rindex(line)
+        if from_begin <= backtrace.size - 1 - from_end
+          keep_from_begin = [keep_from_begin, from_begin].max
+        else
+          keep_from_end = [keep_from_end, from_end].min
+        end
+      end
+
+      keep_from_begin += extra_context
+      keep_from_end -= extra_context
+
+      return backtrace if keep_from_begin + 5 >= keep_from_end
+
+      result = backtrace[0..keep_from_begin]
+      result << "... #{keep_from_end - keep_from_begin - 1} levels..."
+      result.concat backtrace[keep_from_end..-1]
+    end
+  end
+end

data/lib/deep_cover/tools.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools
+  end
+
+  require_relative 'tools/require_relative_dir'
+  extend Tools::RequireRelativeDir
+  require_relative 'tools/silence_warnings'
+  extend Tools::SilenceWarnings
+  require_relative_dir 'tools'
+
+  # The functions defined in the submodules of Tools can be accessed
+  # either by extending the desired module, or all of them by extending
+  # Tools, or by calling them directly Tool.my_function.
+  module Tools
+    constants.each do |module_name|
+      include const_get(module_name)
+    end
+    extend self
+  end
+end

data/lib/deep_cover/tracker_bucket.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  require_relative 'tracker_storage'
+
+  # A holder for TrackerStorages, using some `global_name`.
+  class TrackerBucket
+    @@index = {}
+
+    def self.[](global_name)
+      raise ArgumentError, "'#{global_name}' is not a valid global name" unless global_name.start_with? '$'
+      @@index[global_name] ||= new(global_name)
+    end
+
+    def setup_source
+      "#{source} ||= {}"
+    end
+
+    def source
+      @global_name
+    end
+
+    class << self
+      alias_method :_load, :[]
+      private :_load, :new
+    end
+
+    def inspect
+      %{#<DeepCover::TrackerBucket "#{@global_name}">}
+    end
+
+    def create_storage(index = nil)
+      index ||= @global.size
+      TrackerStorage.new(bucket: self, array: @global[index] ||= [], index: index)
+    end
+
+    private
+
+    def initialize(global_name)
+      @global_name = global_name
+      @global = eval(setup_source) # rubocop:disable Security/Eval
+    end
+
+    def _dump(_level)
+      @global_name
+    end
+  end
+end

data/lib/deep_cover/tracker_hits_per_path.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # Should be seen as a hash like {path => tracker_hits, ...},
+  # where tracker_hits is simply an array of integers returned from
+  # TrackerStorage#tracker_hits.
+  # Make it easier to separate some concerns, as well as marshalling.
+  #
+  class TrackerHitsPerPath
+    extend Forwardable
+    def_delegators :@index, :each, :each_key, :map, :transform_values, :to_h, :to_hash
+
+    def initialize(index = {})
+      @index = index
+    end
+
+    def [](val)
+      @index[val] ||= []
+    end
+
+    def merge!(tracker_hits_per_path)
+      @index.merge!(tracker_hits_per_path) { |_h, actual, to_merge| merge_tracker_hits(actual, to_merge) }
+      self
+    end
+
+    private def merge_tracker_hits(hits, to_merge)
+      unless hits.size == to_merge.size
+        raise "Attempting to merge trackers of different sizes: #{hits.size} vs #{to_merge.size}"
+      end
+      hits.map!.with_index { |val, i| val + to_merge[i] }
+    end
+  end
+end

data/lib/deep_cover/tracker_storage.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # List of allocated trackers from a bucket.
+  # Should be thought of as a simple array of integers with
+  # a limited interface.
+  class TrackerBucket
+    class TrackerStorage
+      extend Forwardable
+      def_delegators :@array, :[], :size, :each, :map, :fetch
+
+      attr_reader :bucket
+
+      def initialize(bucket:, array:, index:)
+        @bucket = bucket
+        @array = array
+        @index = index
+        @allocated = 0
+      end
+
+      # Returns a range of tracker ids
+      def allocate_trackers(nb_needed)
+        prev = @allocated
+        @allocated += nb_needed
+        missing = @allocated - @array.size
+        @array.concat(Array.new(missing, 0)) if missing > 0
+        prev...@allocated
+      end
+
+      def setup_source
+        "(#{bucket.setup_source})[#{@index}]||=Array.new(#{size},0)"
+      end
+
+      def tracker_source(tracker_id)
+        "#{bucket.source}[#{@index}][#{tracker_id}]+=1"
+      end
+
+      def tracker_hits
+        @array.dup.freeze
+      end
+
+      def tracker_hits=(new_hits)
+        if new_hits.size != @array.size
+          warn 'Replacing tracker hits with array of different size'
+        end
+        @array.replace(new_hits)
+      end
+
+      private
+
+      def dump
+        {bucket: @bucket, index: @index, size: @array.size}
+      end
+
+      def _dump(_level)
+        Marshal.dump(dump)
+      end
+
+      class << self
+        private def load(bucket:, index:, size:)
+          storage = bucket.create_storage(index)
+          storage.allocate_trackers(size - storage.size)
+          storage
+        end
+
+        private def _load(data)
+          load(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+        end
+      end
+    end
+
+    private_constant :TrackerStorage
+  end
+end

data/lib/deep_cover/tracker_storage_per_path.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DeepCover
+  bootstrap
+
+  # Should be seen as a hash like {path => tracker_storage, ...}
+  # Make it easier to separate some concerns, as well as marshalling
+  #
+  class TrackerStoragePerPath
+    extend Forwardable
+    def_delegators :@index, :each, :each_key, :map, :transform_values
+
+    attr_reader :bucket
+
+    def initialize(bucket)
+      @bucket = bucket
+      @index = {}
+    end
+
+    def [](path)
+      @index[path] ||= @bucket.create_storage
+    end
+
+    def tracker_hits_per_path
+      TrackerHitsPerPath.new(@index.transform_values(&:tracker_hits))
+    end
+
+    def tracker_hits_per_path=(tracker_hits_per_path)
+      tracker_hits_per_path.each do |path, tracker_hits|
+        self[path].tracker_hits = tracker_hits
+      end
+    end
+  end
+end

data/lib/deep_cover/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeepCover
+  VERSION = '0.6.3.pre'
+end

data/lib/deep_cover.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DeepCover
+  require_relative 'deep_cover/load'
+
+  load_absolute_basics
+
+  extend Base
+  extend ConfigSetter
+end
+DeepCover::GLOBAL_BINDING = binding
+
+require './.deep_cover.rb' if File.exist?('./.deep_cover.rb')
+
+if ENV['DEEP_COVER_OPTIONS']
+  DeepCover.config.set(YAML.load(ENV['DEEP_COVER_OPTIONS']))
+end
+if %w[1 t true].include?(ENV['DEEP_COVER'])
+  DeepCover.start
+  require_relative 'deep_cover/auto_run'
+  DeepCover::AutoRun.run!('.').report!(**DeepCover.config)
+end