deep-cover 0.1.1

data/lib/deep_cover/core_ext/autoload_overrides.rb

@@ -0,0 +1,40 @@
+# We need to override autoload, because MRI has special behaviors associated with it
+# that we can't reuse, hence we need to do workarounds.
+#
+# Basically, when trying to use a constant set to be autoloaded in an optionnal way, like:
+#   * module A; ...; end
+#   * A ||= 1
+# When autoloading the file, the above won't work and will raise a "uninitialized constant A"
+# because ruby doesn't understand that custom require is currently requiring the correct file.
+#
+# Our solution is to track autoloads ourself, and when requiring a path that has autoloads,
+# we remove the autoloads from the constants first.
+
+require 'binding_of_caller'
+
+class << Kernel
+  alias_method :autoload_without_coverage, :autoload
+  def autoload(name, path)
+    mod = binding.of_caller(1).eval('Module.nesting').first || Object
+    DeepCover.autoload_tracker.add(mod, name, path)
+    mod.autoload_without_coverage(name, path)
+  end
+end
+
+module Kernel
+  alias_method :autoload_without_coverage, :autoload
+  def autoload(name, path)
+    mod = binding.of_caller(1).eval('Module.nesting').first || Object
+    DeepCover.autoload_tracker.add(mod, name, path)
+    mod.autoload_without_coverage(name, path)
+  end
+end
+
+
+class Module
+  alias_method :autoload_without_coverage, :autoload
+  def autoload(name, path)
+    DeepCover.autoload_tracker.add(self, name, path)
+    autoload_without_coverage(name, path)
+  end
+end

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -0,0 +1,26 @@
+# This is a complete replacement for the builtin Coverage module of Ruby
+
+require 'coverage'
+BuiltinCoverage = Coverage
+Object.send(:remove_const, 'Coverage')
+
+module Coverage
+  def self.start
+    @started = true
+    DeepCover.start
+    DeepCover.coverage.reset
+  end
+
+  def self.result
+    raise 'coverage measurement is not enabled' unless @started
+    @started = false
+    self.peek
+  end
+
+  def self.peek
+    results = DeepCover.coverage.covered_codes.map do |filename, covered_code|
+      [filename, covered_code.line_coverage(allow_partial: false)]
+    end
+    Hash[results]
+  end
+end

data/lib/deep_cover/core_ext/load_overrides.rb

@@ -0,0 +1,24 @@
+# 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.
+
+class << Kernel
+  alias_method :load_without_coverage, :load
+  def load(path, wrap = false)
+    return load_without_coverage(path, wrap) if wrap
+
+    result = DeepCover.custom_requirer.load(path)
+    if [:not_found, :cover_failed, :not_supported].include?(result)
+      load_without_coverage(path)
+    else
+      result
+    end
+  end
+end
+
+module Kernel
+  def load(path, wrap = false)
+    Kernel.require(path, wrap)
+  end
+end

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -0,0 +1,36 @@
+# These are the monkeypatches to replace the default #require and
+# #require_relative in order to instrument the code before it gets run.
+
+class << Kernel
+  alias_method :require_without_coverage, :require
+  def require(path)
+    result = DeepCover.custom_requirer.require(path)
+    if [:not_found, :cover_failed, :not_supported].include?(result)
+      require_without_coverage(path)
+    else
+      result
+    end
+  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
+end
+
+module Kernel
+  def require(path)
+    Kernel.require(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
+end

data/lib/deep_cover/coverage.rb

@@ -0,0 +1,198 @@
+module DeepCover
+  require 'parser'
+  silence_warnings do
+    require 'parser/current'
+  end
+  require 'pry'
+  require 'pathname'
+  require_relative 'covered_code'
+  require 'securerandom'
+
+  # A collection of CoveredCode
+  class Coverage
+    include Enumerable
+
+    def initialize(**options)
+      @covered_codes = {}
+      @options = options
+    end
+
+    def covered_codes
+      @covered_codes.dup
+    end
+
+    def reset
+      @covered_codes = {}
+    end
+
+    def line_coverage(filename, **options)
+      covered_code(filename).line_coverage(**options)
+    end
+
+    def covered_code(path)
+      raise 'path must be an absolute path' unless Pathname.new(path).absolute?
+      @covered_codes[path] ||= CoveredCode.new(path: path, **@options)
+    end
+
+    def each
+      return to_enum unless block_given?
+      @covered_codes.each{|_path, covered_code| yield covered_code}
+      self
+    end
+
+    def to_istanbul(**options)
+      map do |covered_code|
+        next {} unless covered_code.has_executed?
+        covered_code.to_istanbul(**options)
+      end.inject(:merge)
+    end
+
+    def output_istanbul(dir: '.', name: ".nyc_output", **options)
+      path = Pathname.new(dir).expand_path.join(name)
+      path.mkpath
+      path.each_child(&:delete)
+      path.join('deep_cover.json').write(JSON.pretty_generate(to_istanbul(**options)))
+      path
+    end
+
+    def report_istanbul(output: nil, **options)
+      dir = output_istanbul(**options).dirname
+      if output
+        output = File.expand_path(output)
+        html = "--reporter=html --report-dir='#{output}' && open '#{output}/index.html'"
+      end
+      `cd #{dir} && nyc report --reporter=text #{html}`
+    end
+
+    def basic_report
+      missing = map do |covered_code|
+        if covered_code.has_executed?
+          missed = covered_code.line_coverage.each_with_index.map do |line_cov, line_index|
+            line_index + 1 if line_cov == 0
+          end.compact
+        else
+          missed = ['all']
+        end
+        [covered_code.buffer.name, missed] unless missed.empty?
+      end.compact.to_h
+      missing.map do |path, lines|
+        "#{File.basename(path)}: #{lines.join(', ')}"
+      end.join("\n")
+    end
+
+    def report(**options)
+      if Reporter::Istanbul.available?
+        report_istanbul(**options)
+      else
+        warn "nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`"
+        basic_report
+      end
+    end
+
+    def self.load(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).load
+    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_global)
+      self
+    end
+
+    def tracker_global
+      @options[:tracker_global]
+    end
+
+    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
+        saved?
+        load_trackers
+        load_coverage
+      end
+
+      def save(coverage)
+        create_if_needed
+        delete_trackers
+        save_coverage(coverage)
+      end
+
+      def save_trackers(global)
+        saved?
+        basename = TRACKER_TEMPLATE % {unique: SecureRandom.urlsafe_base64}
+        dir_path.join(basename).binwrite(Marshal.dump({
+          version: DeepCover::VERSION,
+          global: global,
+          trackers: eval(global),
+        }))
+      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
+
+      def load_coverage
+        Marshal.load(dir_path.join(BASENAME).binread).tap do |version: raise, coverage: raise|
+          raise "dump version mismatch: #{deep_cover}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
+          return coverage
+        end
+      end
+
+      def load_trackers
+        tracker_files.each do |full_path|
+          Marshal.load(full_path.binread).tap do |version: raise, global: raise, trackers: raise|
+            raise "dump version mismatch: #{deep_cover}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
+            merge_trackers(eval("#{global} ||= {}"), trackers)
+          end
+        end
+      end
+
+      def merge_trackers(hash, to_merge)
+        hash.merge!(to_merge) do |_key, current, to_add|
+          unless current.size == 0 || current.size == to_add.size
+            warn "Merging trackers of different sizes: #{current.size} vs #{to_add.size}"
+          end
+          to_add.zip(current).map{|a, b| a+b}
+        end
+      end
+
+      def tracker_files
+        basename = 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

@@ -0,0 +1,138 @@
+module DeepCover
+  class CoveredCode
+    attr_accessor :covered_source, :buffer, :tracker_global, :local_var
+    @@counter = 0
+    @@globals = Hash.new{|h, global| h[global] = eval("#{global} ||= {}") }
+
+    def initialize(path: nil, source: nil, lineno: nil, tracker_global: '$_cov', local_var: '_temp')
+      raise "Must provide either path or source" unless path || source
+
+      @buffer = ::Parser::Source::Buffer.new(path)
+      if source
+        @buffer.source = source
+      else
+        @buffer.read
+      end
+      @lineno = lineno
+      @tracker_count = 0
+      @tracker_global = tracker_global
+      @local_var = local_var
+      @covered_source = instrument_source
+    end
+
+    def path
+      @buffer.name || "(source: '#{@buffer.source[0..20]}...')"
+    end
+
+    def name
+      @buffer.name ? File.basename(@buffer.name) : "(source)"
+    end
+
+    def nb_lines
+      @nb_lines ||= begin
+        lines = buffer.source_lines
+        if lines.size == 0
+          0
+        else
+          lines.size - (lines.last.empty? ? 1 : 0)
+        end
+      end
+    end
+
+    def execute_code(binding: DeepCover::GLOBAL_BINDING.dup)
+      return if has_executed?
+      global[nb] = Array.new(@tracker_count, 0)
+      eval(@covered_source, binding, @buffer.name || '<raw_code>', @lineno || 1)
+      self
+    end
+
+    def cover
+      must_have_executed
+      global[nb]
+    end
+
+    def line_coverage(**options)
+      must_have_executed
+      Analyser::PerLine.new(self, **options).results
+    end
+
+    def to_istanbul(**options)
+      must_have_executed
+      Reporter::Istanbul.new(self, **options).convert
+    end
+
+    def char_cover(**options)
+      must_have_executed
+      Analyser::PerChar.new(self, **options).results
+    end
+
+    def nb
+      @nb ||= (@@counter += 1)
+    end
+
+    # Returns a range of tracker ids
+    def allocate_trackers(nb_needed)
+      prev = @tracker_count
+      @tracker_count += nb_needed
+      prev...@tracker_count
+    end
+
+    def tracker_source(tracker_id)
+      "#{tracker_global}[#{nb}][#{tracker_id}]+=1"
+    end
+
+    def trackers_setup_source
+      "(#{tracker_global}||={})[#{nb}]||=Array.new(#{@tracker_count},0)"
+    end
+
+    def tracker_hits(tracker_id)
+      cover.fetch(tracker_id)
+    end
+
+    def covered_ast
+      root.main
+    end
+
+    def root
+      @root ||= begin
+        ast = Parser::CurrentRuby.new.parse(@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::Rewriter.new(@buffer)
+      covered_ast.each_node do |node|
+        prefix, suffix = node.rewrite_prefix_suffix
+        unless prefix.empty?
+          expression = node.expression
+          prefix = yield prefix, node, expression.begin, :prefix if block_given?
+          rewriter.insert_before_multi expression, prefix rescue binding.pry
+        end
+        unless suffix.empty?
+          expression = node.expression
+          suffix = yield suffix, node, expression.end, :suffix if block_given?
+          rewriter.insert_after_multi  expression, suffix
+        end
+      end
+      rewriter.process
+    end
+
+    def has_executed?
+      global[nb] != nil
+    end
+
+    protected
+    def global
+      @@globals[tracker_global]
+    end
+
+    def must_have_executed
+      raise "cover for #{buffer.name} not available, file wasn't executed" unless has_executed?
+    end
+  end
+end