deep-cover 0.1.1

data/lib/deep_cover/auto_run.rb

@@ -0,0 +1,49 @@
+require 'deep_cover'
+require 'pry'
+
+module DeepCover
+  module AutoRun
+    extend self
+
+    def detect
+      @covered_path = File.expand_path('./lib')
+      Coverage.saved? @covered_path
+    end
+
+    def load
+      @coverage = Coverage.load(@covered_path)
+    end
+
+    def save
+      @coverage.save_trackers(@covered_path)
+    end
+
+    def after_tests
+      use_at_exit = true
+      if defined?(Minitest)
+        puts "Registering with Minitest"
+        use_at_exit = false
+        Minitest.after_run { yield }
+      end
+      if defined?(Rspec)
+        use_at_exit = false
+        puts "Registering with Rspec"
+        RSpec.configure do |config|
+          config.after(:suite) { yield }
+        end
+      end
+      if use_at_exit
+        puts "Using at_exit"
+        at_exit { yield }
+      end
+    end
+
+    def run!
+      detect
+      load
+      after_tests { save }
+    end
+
+    run!
+  end
+end

data/lib/deep_cover/autoload_tracker.rb

@@ -0,0 +1,75 @@
+require 'weakref'
+
+module DeepCover
+  class AutoloadTracker
+    def initialize(autoloaded_paths = {})
+      @autoloaded_paths = autoloaded_paths
+    end
+
+    def add(const, name, path)
+      ext = File.extname(path)
+      # We don't care about .so files
+      return if ext == '.so'
+      path = path + '.rb' if ext != '.rb'
+
+      pairs = @autoloaded_paths[path] ||= []
+      pairs << [WeakRef.new(const), name]
+    end
+
+    def pairs_for_absolute_path(absolute_path)
+      paths = autoloaded_paths_matching_absolute(absolute_path)
+
+      paths.flat_map do |path|
+        pairs = @autoloaded_paths[path] || []
+        pairs = pairs.map{|weak_const, name| [self.class.value_from_weak_ref(weak_const), name] }
+        pairs.select!(&:first)
+        pairs
+      end
+    end
+
+    def wrap_require(absolute_path)
+      pairs = pairs_for_absolute_path(absolute_path)
+
+      begin
+        pairs.each do |const, name|
+          # Changing the autoload to an already loaded file (this one)
+          const.autoload_without_coverage(name, __FILE__)
+        end
+
+        yield
+      rescue Exception
+        pairs.each do |const, name|
+          # Changing the autoload to an already loaded file (this one)
+          const.autoload_without_coverage(name, absolute_path)
+        end
+
+        raise
+      end
+    end
+
+    def initialize_autoloaded_paths
+      @autoloaded_paths = {}
+      ObjectSpace.each_object(Module) do |mod|
+        mod.constants.each do |name|
+          if path = mod.autoload?(name)
+            add(mod, name, path)
+          end
+        end
+      end
+    end
+
+    # We need all the paths of autoloaded_path that match a given absolute_path
+    # Since this can happen a lot, a cache is made which only chan
+    def autoloaded_paths_matching_absolute(absolute_path)
+      @autoloaded_paths.keys.select do |path|
+        absolute_path == DeepCover.custom_requirer.resolve_path(path)
+      end
+    end
+
+    # A simple if the ref is dead, return nil.
+    # WTF ruby, why is there no such simple interface ?!
+    def self.value_from_weak_ref(weak_ref)
+      WeakRef.class_variable_get(:@@__map)[weak_ref]
+    end
+  end
+end

data/lib/deep_cover/backports.rb

@@ -0,0 +1,9 @@
+# We use a few features newer than our target of Ruby 2.0+:
+class Module
+  public :prepend # Public in Ruby 2.1+.
+end
+require 'backports/2.1.0/module/include'
+require 'backports/2.1.0/enumerable/to_h'
+require 'backports/2.4.0/false_class/dup'
+require 'backports/2.4.0/true_class/dup'
+require 'backports/2.4.0/hash/transform_values'

data/lib/deep_cover/base.rb

@@ -0,0 +1,55 @@
+module DeepCover
+  module Base
+    def start
+      return if @started
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+        # No issues with autoload in jruby, so no need to override it!
+      else
+        require_relative 'core_ext/autoload_overrides'
+        autoload_tracker.initialize_autoloaded_paths
+      end
+      require_relative 'core_ext/require_overrides'
+      @started = true
+    end
+
+    def stop
+      # TODO
+    end
+
+    def line_coverage(filename)
+      coverage.line_coverage(handle_relative_filename(filename), **@config)
+    end
+
+    def covered_code(filename)
+      coverage.covered_code(handle_relative_filename(filename))
+    end
+
+    def cover
+      start
+      yield
+    ensure
+      stop
+    end
+
+    def coverage
+      @coverage ||= Coverage.new
+    end
+
+    def custom_requirer
+      @custom_requirer ||= CustomRequirer.new
+    end
+
+    def autoload_tracker
+      @autoload_tracker ||= AutoloadTracker.new
+    end
+
+    def handle_relative_filename(filename)
+      unless Pathname.new(filename).absolute?
+        relative_to = File.dirname(caller[1].partition(/\.rb:\d/).first)
+        filename = File.absolute_path(filename, relative_to)
+      end
+      filename += '.rb' unless filename =~ /\.rb$/
+      filename
+    end
+  end
+end

data/lib/deep_cover/builtin_takeover.rb

@@ -0,0 +1,2 @@
+require_relative 'deep_cover'
+require_relative 'deep_cover/core_ext/coverage_replacement'

data/lib/deep_cover/cli/debugger.rb

@@ -0,0 +1,93 @@
+require 'term/ansicolor'
+
+module DeepCover
+  module CLI
+    class Debugger
+      include Tools
+
+      module ColorAST
+        def fancy_type
+          color = case
+          when !executable?
+            :faint
+          when !was_executed?
+            :red
+          when flow_interrupt_count > 0
+            :yellow
+          else
+            :green
+          end
+          Term::ANSIColor.send(color, super)
+        end
+      end
+
+      def initialize(source, filename: '(source)', lineno: 1, pry: false)
+        @source = source
+        @filename = filename
+        @lineno = lineno
+        @pry = pry
+      end
+
+      def show
+        show_line_coverage
+        show_instrumented_code
+        show_ast
+        show_char_coverage
+        pry if @pry
+        finish
+      end
+
+      def show_line_coverage
+        puts "Line Coverage: Builtin | DeepCover | DeepCover Strict:\n"
+        begin
+          builtin_line_coverage = builtin_coverage(@source, @filename, @lineno)
+          our_line_coverage = our_coverage(@source, @filename, @lineno)
+          our_strict_line_coverage = our_coverage(@source, @filename, @lineno, allow_partial: false)
+          lines = format(builtin_line_coverage, our_line_coverage, our_strict_line_coverage, source: @source)
+          puts number_lines(lines, lineno: @lineno)
+        rescue Exception => e
+          puts "Can't run coverage: #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"
+          @failed = true
+        end
+      end
+
+      def show_instrumented_code
+        puts "\nInstrumented code:\n"
+        puts format_generated_code(covered_code)
+      end
+
+      def show_ast
+        puts "\nParsed code:\n"
+        begin
+          execute_sample(covered_code)
+        rescue Exception => e
+          puts "Can't `execute_sample`:#{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"
+          @failed = true
+        end
+
+        Node.prepend ColorAST
+        puts covered_code.covered_ast
+      end
+
+      def show_char_coverage
+        puts "\nChar coverage:\n"
+
+        puts format_char_cover(covered_code, show_whitespace: !!ENV['W'])
+      end
+
+      def pry
+        a = covered_code.covered_ast
+        b = a.children.first
+        binding.pry
+      end
+
+      def finish
+        exit(!@failed)
+      end
+
+      def covered_code
+        @covered_code ||= CoveredCode.new(source: @source, path: @filename, lineno: @lineno)
+      end
+    end
+  end
+end

data/lib/deep_cover/cli/deep_cover.rb

@@ -0,0 +1,49 @@
+module DeepCover
+  require 'bundler/setup'
+  require 'slop'
+  require 'deep_cover'
+  require_relative_dir '.'
+
+  module CLI
+    module DeepCover
+      extend self
+
+      def show_version
+        puts "deep-cover v#{DeepCover::VERSION}; parser v#{Parser::Version}"
+      end
+
+      def show_help
+        puts options
+      end
+
+      def options
+        @options ||= Slop.parse do |o|
+          o.banner = "usage: deep-cover [options] [path/to/app/or/gem]"
+          o.separator ''
+          o.string '-o', '--output', 'output folder', default: './coverage'
+          o.string '-c', '--command', 'command to run tests', default: 'rake'
+
+          o.separator ''
+          o.separator 'For testing purposes:'
+          o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
+          o.bool '-d', '--debug', 'enter debugging after cover'
+
+          o.separator ''
+          o.separator 'Other available commands:'
+          o.on('--version', 'print the version') { version; exit }
+          o.on('-h', '--help') { help; exit }
+        end
+      end
+
+      def go
+        if options[:expression]
+          Debugger.new(options[:expression], pry: options[:debug]).show
+        elsif (path = options.arguments.first)
+          InstrumentedCloneReporter.new(path, **options).run
+        else
+          show_help
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -0,0 +1,105 @@
+require 'yaml'
+require 'tmpdir'
+
+module DeepCover
+  module CLI
+    class InstrumentedCloneReporter
+      include Tools
+      attr_reader :dest_path
+
+      def initialize(gem_path, command: 'rake', **options)
+        @command = command
+        @options = options
+        @root_path = File.expand_path(gem_path)
+        if File.exist?(File.join(@root_path, 'Gemfile'))
+          @gem_relative_path = '' # Typical case
+        else
+          # E.g. rails/activesupport
+          @gem_relative_path = File.basename(@root_path)
+          @root_path = File.dirname(@root_path)
+          raise "Can't find Gemfile" unless File.exist?(File.join(@root_path, 'Gemfile'))
+        end
+        @dest_root = File.expand_path('~/test_deep_cover')
+        @dest_root = Dir.mktmpdir("deep_cover_test") unless Dir.exist?(@dest_root)
+        `rm -rf #{@dest_root}/* #{@dest_root}/.*`
+        @dest_path = File.expand_path(File.join(@dest_root, @gem_relative_path))
+      end
+
+      def copy
+        @copy ||= `cp -r #{@root_path}/* #{@dest_root} && cp #{@root_path}/.* #{@dest_root}`
+      end
+
+      def patch_ruby_file(ruby_file)
+        content = File.read(ruby_file)
+        # Insert our code after leading comments:
+        content.sub!(/^((#.*\n+)*)/, '\1require "deep_cover/auto_run";')
+        File.write(ruby_file, content)
+      end
+
+      def patch_main_ruby_files
+        main = File.join(dest_path, 'lib/*.rb')
+        Dir.glob(main).each do |main|
+          puts "Patching #{main}"
+          patch_ruby_file(main)
+        end
+      end
+
+      def patch_gemfile
+        gemfile = File.expand_path(File.join(dest_path, 'Gemfile'))
+        gemfile = File.expand_path(File.join(dest_path, '..', 'Gemfile')) unless File.exist?(gemfile)
+        content = File.read(gemfile)
+        unless content =~ /gem 'deep-cover'/
+          puts "Patching Gemfile"
+          File.write(gemfile, [
+            "# This file was modified by DeepCover",
+            content,
+            "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
+            '',
+          ].join("\n"))
+        end
+        Bundler.with_clean_env do
+          `cd #{dest_path} && bundle`
+        end
+      end
+
+      def patch_rubocop
+        path = File.expand_path(File.join(dest_path, '.rubocop.yml'))
+        return unless File.exists?(path)
+        puts "Patching .rubocop.yml"
+        config = YAML.load(File.read(path).gsub(/(?<!\w)lib(?!\w)/, 'lib_original'))
+        ((config['AllCops'] ||= {})['Exclude'] ||= []) << 'lib/**/*'
+        File.write(path, "# This file was modified by DeepCover\n" + YAML.dump(config))
+      end
+
+      def patch
+        patch_gemfile
+        patch_rubocop
+        patch_main_ruby_files
+      end
+
+      def cover
+        `cp -R #{dest_path}/lib #{dest_path}/lib_original`
+        @covered_path = Tools.dump_covered_code(File.join(dest_path, 'lib_original'), File.join(dest_path, 'lib'))
+      end
+
+      def process
+        Bundler.with_clean_env do
+          system("cd #{dest_path} && #{@command}", out: $stdout, err: :out)
+        end
+      end
+
+      def report
+        coverage = Coverage.load @covered_path
+        puts coverage.report(dir: @covered_path, **@options)
+      end
+
+      def run
+        copy
+        cover
+        patch
+        process
+        report
+      end
+    end
+  end
+end

data/lib/deep_cover/config.rb

@@ -0,0 +1,52 @@
+module DeepCover
+  class Config
+    DEFAULTS = {
+      ignore_uncovered: [],
+      paths: %w[./app ./lib],
+      allow_partial: false,
+    }
+
+    def initialize
+      @options = copy(DEFAULTS)
+    end
+
+    def to_hash
+      copy(@options)
+    end
+    alias_method :to_h, :to_hash
+
+    def ignore_uncovered(*keywords)
+      @options[:ignore_uncovered] -= keywords
+      self
+    end
+
+    def detect_uncovered(*keywords)
+      @options[:ignore_uncovered] += keywords
+      self
+    end
+
+    def paths(paths)
+      @options[:paths] = paths
+      self
+    end
+
+    private
+    def copy(h)
+      h.dup.transform_values(&:dup)
+    end
+
+    module Setter
+      def configure(&block)
+        @config ||= Config.new
+
+        raise "Must provide a block" unless block
+        case block.arity
+        when 0
+          @config.instance_eval(&block)
+        when 1
+          block.call(@config)
+        end
+      end
+    end
+  end
+end