deep-cover 0.6.4 → 0.7.0

data/lib/deep_cover/cli/commands/clear.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    desc 'clear [OPTIONS]', 'Clear coverage data and reports'
+    def clear
+      DeepCover.persistence.clear_directory
+    end
+  end
+end

data/lib/deep_cover/cli/commands/clone.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+module DeepCover
+  class CLI
+    desc 'clone [OPTIONS] [COMMAND TO RUN]', 'Gets the coverage using clone mode'
+    option '--output', desc: 'output folder', type: :string, default: DeepCover.config.output, aliases: '-o'
+    option '--reporter', desc: 'reporter to use', type: :string, default: DeepCover.config.reporter
+    option '--open', desc: 'open the output coverage', type: :boolean, default: CLI_DEFAULTS[:open]
+
+    def clone(*command_parts)
+      if command_parts.empty?
+        command_parts = CLI_DEFAULTS[:command]
+        puts "No command specified, using default of: #{command_parts.join(' ')}"
+      end
+
+      require_relative '../../instrumented_clone_reporter'
+      InstrumentedCloneReporter.new(**processed_options.merge(command: command_parts)).run
+    end
+  end
+end

data/lib/deep_cover/cli/commands/exec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    # Stop parsing and treat everything as positional argument if
+    # we encounter an unknown option or a positional argument.
+    # `check_unknown_options!` (defined in cli.rb) happens first,
+    # so we just stop on a positional argument.
+    stop_on_unknown_option! :exec
+
+    desc 'exec [OPTIONS] [COMMAND TO RUN]', 'Execute the command with coverage activated'
+    option '--output', desc: 'output folder', type: :string, default: DeepCover.config.output, aliases: '-o'
+    option '--reporter', desc: 'reporter to use', type: :string, default: DeepCover.config.reporter
+    option '--open', desc: 'open the output coverage', type: :boolean, default: CLI_DEFAULTS[:open]
+
+    def exec(*command_parts)
+      if command_parts.empty?
+        command_parts = CLI_DEFAULTS[:command]
+        puts "No command specified, using default of: #{command_parts.join(' ')}"
+      end
+
+      DeepCover.config.set(**processed_options.slice(*DEFAULTS.keys))
+
+      require 'yaml'
+      env_var = {'DEEP_COVER' => 'gather',
+                 'DEEP_COVER_OPTIONS' => YAML.dump(DeepCover.config.to_hash_for_serialize),
+      }
+
+      DeepCover.delete_trackers
+      system(env_var, *command_parts)
+      exit_code = $?.exitstatus
+      coverage = Coverage.load
+      puts coverage.report(**processed_options)
+      exit(exit_code)
+    end
+  end
+end

data/lib/deep_cover/cli/commands/gather.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    # Stop parsing and treat everything as positional argument if
+    # we encounter an unknown option or a positional argument.
+    # `check_unknown_options!` (defined in cli.rb) happens first,
+    # so we just stop on a positional argument.
+    stop_on_unknown_option! :gather
+
+    desc 'gather [OPTIONS] COMMAND TO RUN', 'Execute the command and gather the coverage data'
+    def gather(*command_parts)
+      if command_parts.empty?
+        warn set_color('`gather` needs a command to run', :red)
+        exit(1)
+      end
+
+      require 'yaml'
+      env_var = {'DEEP_COVER' => 'gather',
+                 'DEEP_COVER_OPTIONS' => YAML.dump(processed_options.slice(*DEFAULTS.keys)),
+      }
+
+      # Clear inspiration from Bundler's kernel_exec
+      # https://github.com/bundler/bundler/blob/d44d803357506895555ff97f73e60d593820a0de/lib/bundler/cli/exec.rb#L50
+      begin
+        Kernel.exec(env_var, *command_parts)
+      rescue Errno::EACCES, Errno::ENOEXEC
+        warn set_color("not executable: #{command_parts.first}", :red)
+        exit 126 # Default exit code for that
+      rescue Errno::ENOENT
+        warn set_color("command not found: #{command_parts.first}", :red)
+        exit 127 # Default exit code for that
+      end
+    end
+  end
+end

data/lib/deep_cover/cli/commands/help.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    # Thor comes with a built-in help command. When displaying full help, it calls the class' help
+    # We override it to make it more to our taste.
+
+    # Copied from Thor's default one, then customized
+    def self.help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+      list.sort! { |a, b| a[0] <=> b[0] }
+
+      main_commands, list = Tools.extract_commands_for_help(list, :exec, :clone)
+
+      shell.say 'Main commands:'
+      shell.print_table(main_commands, indent: 2, truncate: true)
+
+      lower_level_commands, list = Tools.extract_commands_for_help(list, :gather, :report, :clear, :merge)
+      shell.say
+      shell.say 'Lower-level commands:'
+      shell.print_table(lower_level_commands, indent: 2, truncate: true)
+
+      shell.say
+      shell.say 'Misc commands:'
+      shell.print_table(list, indent: 2, truncate: true)
+
+      shell.say
+      class_options_help(shell)
+    end
+  end
+end

data/lib/deep_cover/cli/commands/merge.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    desc 'merge [OPTIONS]', 'Merge all multiple coverage data into one (for easier moving around)'
+    def merge
+      DeepCover.persistence.merge_persisted_trackers
+    end
+  end
+end

data/lib/deep_cover/cli/commands/report.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    desc 'report [OPTIONS]', 'Generates report from coverage data that was gathered by previous commands'
+    option '--output', desc: 'output folder', type: :string, default: DeepCover.config.output, aliases: '-o'
+    option '--reporter', desc: 'reporter to use', type: :string, default: DeepCover.config.reporter
+    option '--open', desc: 'open the output coverage', type: :boolean, default: CLI_DEFAULTS[:open]
+    def report
+      coverage = Coverage.load
+      puts coverage.report(**processed_options)
+    end
+  end
+end

data/lib/deep_cover/cli/commands/run_expression.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    desc "run-expression [OPTIONS] 'ruby code'", 'Show coverage results for the given ruby expression'
+    option '--profile', desc: 'use profiler', type: :boolean if RUBY_PLATFORM != 'java'
+    option '--debug', aliases: '-d', desc: 'opens an interactive console for debugging', type: :boolean
+    def run_expression(expression)
+      require_relative '../expression_debugger'
+      ExpressionDebugger.new(expression, **options.transform_keys(&:to_sym)).show
+    end
+  end
+end

data/lib/deep_cover/cli/commands/short_help.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    desc 'short-help', 'Display a short help. Same as just `deep-cover`'
+    def short_help
+      self.class.short_help(shell)
+    end
+
+    def self.short_help(shell)
+      list = printable_commands(true, false)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+
+      main_commands, _ignored = Tools.extract_commands_for_help(list, :exec, :clone)
+
+      shell.say 'Main command:'
+      shell.print_table(main_commands, indent: 2, truncate: true)
+
+      shell.say
+      shell.say 'Use `deep-cover help` for a full help with a list of lower-level commands'
+      shell.say 'and information on the available options'
+    end
+  end
+end

data/lib/deep_cover/cli/commands/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    # Add some top-level aliases for this command
+    # So it's possible to do `deep-cover -v` or `deep-cover --version`
+    map %w(-v --version) => :version
+
+    desc 'version', "Print deep-cover's version"
+    def version
+      require 'deep_cover/version'
+      puts "deep-cover version #{DeepCover::VERSION}"
+    end
+  end
+end

data/lib/deep_cover/cli/tools.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class CLI
+    module Tools
+      # Extracts the commands for the help by name, in same order as the names.
+      # This make handling the output of printable_commands more easily.
+      # Returns the matching and the remaining commands.
+      def self.extract_commands_for_help(commands, *names)
+        matching = names.map do |name|
+          commands.detect { |usage, desc| usage.start_with?("deep-cover #{name}") }
+        end
+        remains = commands - matching
+        [matching, remains]
+      end
+    end
+  end
+end

data/lib/deep_cover/cover_cloned_tree.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module DeepCover
+  Tools.silence_warnings do
+    require 'with_progress'
+  end
+  module Tools::CoverClonedTree
+    def cover_cloned_tree(original_paths, original_root:, clone_root:) # &block
+      # Make sure the directories end with a '/' for safe replacing
+      original_root = File.join(File.expand_path(original_root), '')
+      clone_root = File.join(File.expand_path(clone_root), '')
+
+      paths_with_bad_syntax = []
+      original_paths, paths_not_in_root = original_paths.partition { |path| path.start_with?(original_root) }
+
+      original_paths.each.with_progress(title: 'Rewriting') do |original_path|
+        clone_path = Pathname(original_path.sub(original_root, clone_root))
+        begin
+          source = clone_path.read
+          # We need to use the original_path so that the tracker_paths inserted in the files
+          # during the instrumentation are for the original paths
+          covered_code = DeepCover.coverage.covered_code(original_path, source: source)
+        rescue Parser::SyntaxError
+          paths_with_bad_syntax << original_path
+          next
+        end
+
+        # Allow a passed block to edit the source that will be written
+        covered_source = covered_code.covered_source
+        covered_source = yield covered_source, original_path, clone_path if block_given?
+
+        clone_path.dirname.mkpath
+        clone_path.write(covered_source)
+      end
+
+      unless paths_with_bad_syntax.empty?
+        warn [
+               "#{paths_with_bad_syntax.size} files could not be instrumented because of syntax errors:",
+               *paths_with_bad_syntax.first(3),
+               ('...' if paths_with_bad_syntax.size > 3),
+             ].compact.join("\n")
+      end
+
+      unless paths_not_in_root.empty?
+        warn [
+               "#{paths_not_in_root.size} files could not be instrumented because they are not within the directory being cloned.",
+               "(Consider configuring DeepCover's paths to to avoid those files being included)",
+               *paths_not_in_root.first(5),
+               ('...' if paths_not_in_root.size > 5),
+             ].compact.join("\n")
+      end
+
+      nil
+    end
+  end
+
+  Tools.extend Tools::CoverClonedTree
+end

data/lib/deep_cover/expression_debugger.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class ExpressionDebugger
+    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
+
+    attr_reader :options
+    def initialize(source, filename: '(source)', lineno: 1, debug: false, **options)
+      @source = source
+      @filename = filename
+      @lineno = lineno
+      @debug = debug
+      @options = options
+    end
+
+    def show
+      Tools.profile(options[:profile]) do
+        execute
+        covered_code.freeze # Our output relies on the counts, so better freeze. See [#13]
+        if @debug
+          show_line_coverage
+          show_instrumented_code
+          show_ast
+        end
+        show_char_coverage
+      end
+      pry if @debug
+      finish
+    end
+
+    def show_line_coverage
+      output { "Line Coverage: Builtin | DeepCover | DeepCover Strict:\n" }
+      begin
+        builtin_line_coverage = builtin_coverage(@source, @filename, @lineno)
+        our_line_coverage = our_coverage(@source, @filename, @lineno, **options)
+        our_strict_line_coverage = our_coverage(@source, @filename, @lineno, allow_partial: false, **options)
+        output do
+          lines = format(builtin_line_coverage, our_line_coverage, our_strict_line_coverage, source: @source)
+          number_lines(lines, lineno: @lineno)
+        end
+      rescue Exception => e
+        output { "Can't run coverage: #{e.class}: #{e}\n#{e.backtrace.join("\n")}" }
+        @failed = true
+      end
+    end
+
+    def show_instrumented_code
+      output { "\nInstrumented code:\n" }
+      output { format_generated_code(covered_code) }
+    end
+
+    def show_ast
+      output { "\nParsed code:\n" }
+      Node.prepend ColorAST
+      output { covered_code.covered_ast }
+    end
+
+    def show_char_coverage
+      output { "\nNode coverage:\n" }
+
+      output { format_char_cover(covered_code, show_whitespace: !!ENV['W'], **options) }
+    end
+
+    def pry
+      a = covered_code.covered_ast
+      b = a.children.first
+      ::DeepCover.load_pry
+      binding.pry
+    end
+
+    def finish
+      exit(!@failed)
+    end
+
+    def covered_code
+      @covered_code ||= CoveredCode.new(source: @source, path: @filename, lineno: @lineno)
+    end
+
+    def execute
+      execute_sample(covered_code)
+    # output { trace_counts }  # Keep for low-level debugging purposes
+    rescue Exception => e
+      output { "Can't `execute_sample`:#{e.class}: #{e}\n#{e.backtrace.join("\n")}" }
+      @failed = true
+    end
+
+    def trace_counts
+      all = []
+      trace = TracePoint.new(:call) do |tr|
+        if %i[flow_entry_count flow_completion_count execution_count].include? tr.method_id
+          node = tr.self
+          str = "#{node.type} #{(node.value if node.respond_to?(:value))} #{tr.method_id}"
+          all << str unless all.last == str
+        end
+      end
+      trace.enable { covered_code.freeze }
+      all
+    end
+
+    def output
+      Tools.dont_profile do
+        puts yield
+      end
+    end
+  end
+end

data/lib/deep_cover/instrumented_clone_reporter.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+module DeepCover
+  require_relative 'cover_cloned_tree'
+
+  class InstrumentedCloneReporter
+    include Tools
+    # matches regular files, .files, ..files, but not '.' or '..'
+    GLOB_ALL_CONTENT = '{,.[^.],..?}*'
+
+    def initialize(**options)
+      @options = CLI_DEFAULTS.merge(options)
+      @root_path = @source_path = Pathname.new('.').expand_path
+      if !@root_path.join('Gemfile').exist? && @root_path.dirname.join('Gemfile').exist?
+        # E.g. rails/activesupport
+        @root_path = @root_path.dirname
+      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)
+    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 create_entry_point_file
+      require 'tempfile'
+      file = Tempfile.new(['deep_cover_entry_point', '.rb'])
+      template = File.read(DeepCover::CORE_GEM_LIB_DIRECTORY + '/deep_cover/setup/clone_mode_entry_template.rb')
+
+      cache_directory = DeepCover.config.cache_directory.to_s
+      tracker_global = DeepCover.config.tracker_global
+
+      # Those are the fake global variables that we actually replace as we copy the template over
+      template.gsub!('$_cache_directory', cache_directory.inspect)
+      template.gsub!('$_global_name', tracker_global.inspect)
+      template.gsub!('$_core_gem_lib_directory', DeepCover::CORE_GEM_LIB_DIRECTORY.inspect)
+
+      file.write(template)
+      file.close
+
+      # We dont want the file to be removed, this way it stays as long as the clones directory does.
+      ObjectSpace.undefine_finalizer(file)
+
+      file.path
+    end
+
+    def patch_rubocop
+      path = @dest_root.join('.rubocop.yml')
+      return unless path.exist?
+      puts 'Patching .rubocop.yml'
+      config = YAML.load(path.read)
+      all_cop_excludes = ((config['AllCops'] ||= {})['Exclude'] ||= [])
+
+      # Ensure they end with a '/'
+      original_root = File.join(File.expand_path(@root_path), '')
+      clone_root = File.join(File.expand_path(@dest_root), '')
+
+      paths_to_ignore = DeepCover.all_tracked_file_paths
+      paths_to_ignore.select! { |p| p.start_with?(original_root) }
+      paths_to_ignore.map! { |p| p.sub(original_root, clone_root) }
+
+      all_cop_excludes.concat(paths_to_ignore)
+      path.write("# This file was modified by DeepCover\n" + YAML.dump(config))
+    end
+
+    def patch
+      patch_rubocop
+    end
+
+    def remove_deep_cover_config
+      path = @dest_root.join('.deep_cover.rb')
+      return unless path.exist?
+      File.delete(path)
+    end
+
+    def cover
+      entry_point_path = create_entry_point_file
+      Tools.cover_cloned_tree(DeepCover.all_tracked_file_paths,
+                              clone_root: @dest_root,
+                              original_root: @root_path) do |source|
+        source.sub(/\A(#.*\n|\s+)*/) do |header|
+          "#{header}require #{entry_point_path.inspect};"
+        end
+      end
+    end
+
+    def process
+      DeepCover.delete_trackers
+      system({'DISABLE_SPRING' => 'true', 'DEEP_COVER_OPTIONS' => nil}, *@options[:command], chdir: @main_path)
+      $?.exitstatus
+    end
+
+    def report
+      coverage = Coverage.load
+      puts coverage.report(**@options)
+    end
+
+    def run
+      clear
+      copy
+      cover
+      patch
+      remove_deep_cover_config
+      exit_code = process
+      report
+      exit(exit_code)
+    end
+  end
+end