deep-cover 0.6.4 → 0.7.0

data/lib/deep_cover/cli/exec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module CLI
-    class Exec
-      class Option
-        def keep_file_descriptors?
-        end
-      end
-
-      def initialize(argv, **options)
-        @argv = argv
-        @options = options
-      end
-
-      def run
-        require 'yaml'
-        require 'deep_cover/backports'
-        env_var = {'DEEP_COVER' => 't',
-                   'DEEP_COVER_OPTIONS' => YAML.dump(@options.slice(*DEFAULTS.keys)),
-                  }
-
-        system(env_var, *@argv)
-      end
-    end
-  end
-end

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require 'tmpdir'
-
-module DeepCover
-  require 'deep-cover'
-  require_relative '../dump_covered_code'
-  bootstrap
-
-  module CLI
-    class InstrumentedCloneReporter
-      include Tools
-      # matches regular files, .files, ..files, but not '.' or '..'
-      GLOB_ALL_CONTENT = '{,.[^.],..?}*'
-
-      def initialize(source_path, **options)
-        @options = CLI_DEFAULTS.merge(options)
-        @root_path = @source_path = Pathname.new(source_path).expand_path
-        unless @root_path.join('Gemfile').exist?
-          # E.g. rails/activesupport
-          @root_path = @root_path.dirname
-          raise "Can't find Gemfile in #{@root_path}" unless @root_path.join('Gemfile').exist?
-        end
-        path = Pathname('~/test_deep_cover').expand_path
-        if path.exist?
-          @dest_root = path.join(@source_path.basename)
-          @dest_root.mkpath
-        else
-          @dest_root = Pathname.new(Dir.mktmpdir('deep_cover_test'))
-        end
-
-        gem_relative_path = @source_path.relative_path_from(@root_path)
-        @main_path = @dest_root.join(gem_relative_path)
-        singleton_class.include self.class.const_get(Tools.camelize(style))
-      end
-
-      def clear
-        FileUtils.rm_rf(Dir.glob("#{@dest_root}/#{GLOB_ALL_CONTENT}"))
-      end
-
-      def copy
-        return true if @copied
-        puts 'Cloning...'
-        FileUtils.cp_r(Dir.glob("#{@root_path}/#{GLOB_ALL_CONTENT}"), @dest_root)
-        @copied = true
-      end
-
-      def patch_ruby_file(ruby_file)
-        content = ruby_file.read
-        # Insert our code after leading comments:
-        content.sub!(/^(#.*\n+)*/) { |header| "#{header}require 'deep_cover/auto_run';DeepCover::AutoRun.run! '#{@dest_root}';" }
-        ruby_file.write(content)
-      end
-
-      def style
-        if @source_path.join('config/environments/test.rb').exist?
-          :rails
-        elsif @source_path.join('lib').exist?
-          :single_gem
-        else # Rails style
-          :gem_collection
-        end
-      end
-
-      # Style specific functionality
-      module Gem
-        def each_main_ruby_files(&block)
-          each_gem_path do |dest_path|
-            main = dest_path.join('lib/*.rb')
-            Pathname.glob(main).select(&:file?).each(&block)
-          end
-        end
-
-        def each_dir_to_cover
-          each_gem_path do |dest_path|
-            yield dest_path.join('lib')
-          end
-        end
-      end
-
-      module SingleGem
-        include Gem
-        def each_gem_path
-          yield @main_path
-        end
-      end
-
-      module GemCollection
-        include Gem
-        def each_gem_path
-          Pathname.glob(@main_path.join('*/lib')).each { |p| yield p.dirname }
-        end
-      end
-
-      module Rails
-        def each_main_ruby_files
-          yield @main_path.join('config/environments/test.rb')
-        end
-
-        def each_dir_to_cover
-          yield @main_path.join('app')
-          yield @main_path.join('lib')
-        end
-      end
-
-      # Back to global functionality
-      def patch_main_ruby_files
-        each_main_ruby_files do |main|
-          puts "Patching #{main}"
-          patch_ruby_file(main)
-        end
-      end
-
-      def patch_gemfile
-        gemfile = @dest_root.join('Gemfile')
-        require 'bundler'
-        deps = Bundler::Definition.build(gemfile, nil, nil).dependencies
-
-        return if deps.find { |e| e.name.start_with? 'deep-cover' }
-
-        content = File.read(gemfile)
-        puts "Patching Gemfile #{gemfile}"
-        File.write(gemfile, [
-                              '# This file was modified by DeepCover',
-                              content,
-                              "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
-                              "gem 'deep-cover-core', path: '#{File.expand_path(__dir__ + '/../../../core_gem')}'",
-                              '',
-                            ].join("\n"))
-      end
-
-      def patch_rubocop
-        path = @dest_root.join('.rubocop.yml')
-        return unless path.exist?
-        puts 'Patching .rubocop.yml'
-        config = YAML.load(path.read.gsub(/(?<!\w)lib(?!\w)/, 'lib_original'))
-        ((config['AllCops'] ||= {})['Exclude'] ||= []) << 'lib/**/*' << 'app/**/*'
-        path.write("# This file was modified by DeepCover\n" + YAML.dump(config))
-      end
-
-      def patch
-        patch_gemfile
-        patch_rubocop
-        patch_main_ruby_files
-      end
-
-      def cover
-        coverage = Coverage.new(tracker_global: ::DeepCover.config.tracker_global)
-        each_dir_to_cover do |to_cover|
-          FileUtils.cp_r(to_cover, to_cover.sub_ext('_original'))
-          Tools.dump_covered_code(to_cover,
-                                  coverage: coverage,
-                                  dest_path: to_cover)
-        end
-        coverage.save(@dest_root.to_s)
-      end
-
-      def process
-        Bundler.with_clean_env do
-          system({'DISABLE_SPRING' => 'true'}, "cd #{@main_path} && #{@options[:command]}")
-        end
-      end
-
-      def restore
-        each_dir_to_cover do |to_cover|
-          FileUtils.mv(to_cover, to_cover.sub_ext('_instrumented'))
-          FileUtils.mv(to_cover.sub_ext('_original'), to_cover)
-        end
-      end
-
-      def report
-        coverage = Coverage.load @dest_root.to_s
-        puts coverage.report(dir: @dest_root.to_s, **@options)
-      end
-
-      def bundle
-        puts 'Running `bundle install`'
-        Bundler.with_clean_env do
-          `cd #{@dest_root} && bundle`
-        end
-      end
-
-      def run
-        if @options[:process]
-          clear
-          copy
-          cover
-          patch
-          bundle if @options[:bundle]
-          process
-          restore
-        end
-        report
-      end
-    end
-  end
-end

data/lib/deep_cover/cli/runner.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  require 'slop'
-  require 'deep-cover'
-  bootstrap
-
-  module CLI
-    module SlopExtension
-      attr_accessor :stopped
-      attr_reader :ignored
-
-      def try_process(*)
-        @ignored ||= 0
-        return if stopped
-        o = super
-        @ignored += 1 unless o
-        o
-      end
-    end
-    ::Slop::Parser.prepend SlopExtension
-
-    module Runner
-      extend self
-
-      def show_version
-        require 'deep_cover/version'
-        require 'parser'
-        puts "deep-cover v#{DeepCover::VERSION}; parser v#{Parser::VERSION}"
-      end
-
-      def show_help
-        puts menu
-      end
-
-      class OptionParser < Struct.new(:delegate)
-        def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissing
-          options = args.last
-          if options.is_a?(Hash) && options.has_key?(:default)
-            args[-2] += " [#{options[:default]}]"
-          end
-          delegate.public_send(method, *args, &block)
-        end
-      end
-
-      def parse
-        Slop.parse do |o|
-          yield OptionParser.new(o)
-        end
-      end
-
-      def menu
-        @menu ||= parse do |o|
-          o.banner = ['usage: deep-cover [options] exec <command ...>',
-                      '   or  deep-cover [options] [path/to/app/or/gem]',
-                     ].join("\n")
-          o.separator ''
-          o.string '-o', '--output', 'output folder', default: DeepCover.config.output
-          o.string '--reporter', 'reporter', default: DeepCover.config.reporter
-          o.bool '--open', 'open the output coverage', default: CLI_DEFAULTS[:open]
-
-          o.separator 'Coverage options'
-          @ignore_uncovered_map = OPTIONALLY_COVERED.map do |option|
-            default = DeepCover.config.ignore_uncovered.include?(option)
-            o.bool "--ignore-#{dasherize(option)}", '', default: default
-            [:"ignore_#{option}", option]
-          end.to_h
-
-          o.separator "\nWhen not using ’exec’:"
-          o.string '-c', '--command', 'command to run tests', default: CLI_DEFAULTS[:command]
-          o.bool '--bundle', 'run bundle before the tests', default: CLI_DEFAULTS[:bundle]
-          o.bool '--process', 'turn off to only redo the reporting', default: CLI_DEFAULTS[:process]
-
-          o.separator "\nFor testing purposes:"
-          o.bool '--profile', 'use profiler' unless RUBY_PLATFORM == 'java'
-          o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
-          o.bool '-d', '--debug', 'enter debugging after cover'
-
-          o.separator "\nOther available commands:"
-          o.on('--version', 'print the version') do
-            show_version
-            exit
-          end
-          o.boolean('-h', '--help')
-
-          o.boolean('exec', '', help: false) do
-            o.parser.stopped = true if o.parser.ignored == 0
-          end
-        end
-      end
-
-      def convert_options(options)
-        iu = options[:ignore_uncovered] = []
-        @ignore_uncovered_map.each do |cli_option, option|
-          iu << option if options.delete(cli_option)
-        end
-        options[:output] = false if ['false', 'f', ''].include?(options[:output])
-        options
-      end
-
-      def go
-        options = convert_options(menu.to_h)
-        if options[:help]
-          show_help
-        elsif options[:expression]
-          require_relative 'debugger'
-          Debugger.new(options[:expression], **options).show
-        elsif menu.parser.stopped
-          require_relative 'exec'
-          Exec.new(menu.arguments, **options).run
-        else
-          require_relative 'instrumented_clone_reporter'
-          path = menu.arguments.first || '.'
-          InstrumentedCloneReporter.new(path, **options).run
-        end
-      end
-
-      private
-
-      # Poor man's dasherize. 'an_example' => 'an-example'
-      def dasherize(string)
-        string.to_s.tr('_', '-')
-      end
-    end
-  end
-end

data/lib/deep_cover/dump_covered_code.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  silence_warnings do
-    require 'with_progress'
-  end
-  module Tools::DumpCoveredCode
-    def dump_covered_code(source_path, coverage:, dest_path: Dir.mktmpdir)
-      source_path = File.join(File.expand_path(source_path), '')
-      dest_path = File.join(File.expand_path(dest_path), '')
-      skipped = []
-      file_paths = Dir.glob("#{source_path}**/*.rb").select { |p| File.file?(p) }
-      file_paths.each.with_progress(title: 'Rewriting') do |path|
-        new_path = Pathname(path.gsub(source_path, dest_path))
-        begin
-          covered_code = coverage.covered_code(path)
-        rescue Parser::SyntaxError
-          skipped << path
-          next
-        end
-        new_path.dirname.mkpath
-        new_path.write(covered_code.covered_source)
-      end
-      unless skipped.empty?
-        warn [
-               "#{skipped.size} files could not be instrumented because of syntax errors:",
-               *skipped.first(3),
-               ('...' if skipped.size > 3),
-             ].compact.join("\n")
-      end
-      dest_path
-    end
-  end
-
-  Tools.extend Tools::DumpCoveredCode
-end

data/lib/deep_cover_entry.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-# This empty file is just a hack so we can self-cover our exe/deep-cover