deep-cover 0.1.14 → 0.1.15

data/lib/deep_cover/cli/deep_cover.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   require 'bundler/setup'
   require 'slop'
@@ -9,7 +11,7 @@ module DeepCover
       extend self
 
       def show_version
-        puts "deep-cover v#{DeepCover::VERSION}; parser v#{Parser::Version}"
+        puts "deep-cover v#{::DeepCover::VERSION}; parser v#{::Parser::VERSION}"
       end
 
       def show_help
@@ -17,7 +19,7 @@ module DeepCover
       end
 
       class Parser < Struct.new(:delegate)
-        def method_missing(method, *args, &block)
+        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]}]"
@@ -34,7 +36,7 @@ module DeepCover
 
       def menu
         @menu ||= parse do |o|
-          o.banner = "usage: deep-cover [options] [path/to/app/or/gem]"
+          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: 'bundle exec rake'
@@ -43,18 +45,20 @@ module DeepCover
           o.separator 'Coverage options'
           @ignore_uncovered_map = Analyser.optionally_covered.map do |option|
             default = Config::DEFAULTS[:ignore_uncovered].include?(option)
-            o.bool "--ignore-#{Tools.dasherize(option)}", "", default: default
+            o.bool "--ignore-#{Tools.dasherize(option)}", '', default: default
             [:"ignore_#{option}", option]
           end.to_h
-          o.separator ''
-          o.separator 'For testing purposes:'
+          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 ''
-          o.separator 'Other available commands:'
-          o.on('--version', 'print the version') { version; exit }
-          o.on('-h', '--help') { help; exit }
+          o.separator "\nOther available commands:"
+          o.on('--version', 'print the version') do
+            show_version
+            exit
+          end
+          o.boolean('-h', '--help')
         end
       end
 
@@ -68,7 +72,9 @@ module DeepCover
 
       def go
         options = convert_options(menu.to_h)
-        if options[:expression]
+        if options[:help]
+          show_help
+        elsif options[:expression]
           Debugger.new(options[:expression], **options).show
         elsif (path = menu.arguments.first)
           InstrumentedCloneReporter.new(path, **options).run

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'tmpdir'
 
@@ -18,7 +20,7 @@ module DeepCover
           raise "Can't find Gemfile" unless @root_path.join('Gemfile').exist?
         end
         @dest_root = Pathname('~/test_deep_cover').expand_path
-        @dest_root = Pathname.new(Dir.mktmpdir("deep_cover_test")) unless @dest_root.exist?
+        @dest_root = Pathname.new(Dir.mktmpdir('deep_cover_test')) unless @dest_root.exist?
 
         gem_relative_path = @source_path.relative_path_from(@root_path)
         @main_path = @dest_root.join(gem_relative_path)
@@ -31,7 +33,7 @@ module DeepCover
 
       def copy
         return true if @copied
-        puts "Cloning..."
+        puts 'Cloning...'
         FileUtils.cp_r(Dir.glob("#{@root_path}/#{GLOB_ALL_CONTENT}"), @dest_root)
         @copied = true
       end
@@ -39,7 +41,7 @@ module DeepCover
       def patch_ruby_file(ruby_file)
         content = ruby_file.read
         # Insert our code after leading comments:
-        content.sub!(/^((#.*\n+)*)/, "#{$1}require 'deep_cover/auto_run';DeepCover::AutoRun.run! '#{@dest_root}';")
+        content.sub!(/^(#.*\n+)*/) { |header| "#{header}require 'deep_cover/auto_run';DeepCover::AutoRun.run! '#{@dest_root}';" }
         ruby_file.write(content)
       end
 
@@ -79,7 +81,7 @@ module DeepCover
       module GemCollection
         include Gem
         def each_gem_path
-          Pathname.glob(@main_path.join('*/lib')).each{|p| yield p.dirname}
+          Pathname.glob(@main_path.join('*/lib')).each { |p| yield p.dirname }
         end
       end
 
@@ -108,19 +110,19 @@ module DeepCover
         unless content =~ /gem 'deep-cover'/
           puts "Patching Gemfile #{gemfile}"
           File.write(gemfile, [
-            "# This file was modified by DeepCover",
-            content,
-            "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
-            '',
-          ].join("\n"))
+                                '# This file was modified by DeepCover',
+                                content,
+                                "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
+                                '',
+                              ].join("\n"))
         end
       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'))
+        puts 'Patching .rubocop.yml'
+        config = YAML.safe_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
@@ -137,8 +139,8 @@ module DeepCover
           original = to_cover.sub_ext('_original')
           FileUtils.cp_r(to_cover, original)
           Tools.dump_covered_code(original,
-            coverage: coverage, root_path: @dest_root.to_s,
-            dest_path: to_cover)
+                                  coverage: coverage, root_path: @dest_root.to_s,
+                                  dest_path: to_cover)
         end
         coverage.save(@dest_root.to_s)
       end
@@ -155,7 +157,7 @@ module DeepCover
       end
 
       def bundle
-        puts "Running `bundle install`"
+        puts 'Running `bundle install`'
         Bundler.with_clean_env do
           `cd #{@dest_root} && bundle`
         end

data/lib/deep_cover/config.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module DeepCover
   class Config
     DEFAULTS = {
-      ignore_uncovered: [],
-      paths: %w[./app ./lib],
-      allow_partial: false,
-    }
+                 ignore_uncovered: [],
+                 paths: %w[./app ./lib],
+                 allow_partial: false,
+               }.freeze
 
-    def initialize(**options)
+    def initialize(notify = nil, **options)
+      @notify = notify
       @options = copy(DEFAULTS.merge(options))
     end
 
@@ -17,38 +20,48 @@ module DeepCover
 
     def ignore_uncovered(*keywords)
       check_uncovered(keywords)
-      @options[:ignore_uncovered] += keywords
-      self
+      change(:ignore_uncovered, @options[:ignore_uncovered] | keywords)
     end
 
     def detect_uncovered(*keywords)
       check_uncovered(keywords)
-      @options[:ignore_uncovered] -= keywords
-      self
+      change(:ignore_uncovered, @options[:ignore_uncovered] - keywords)
     end
 
-    def paths(paths)
-      @options[:paths] = paths
-      self
+    def paths(paths = nil)
+      if paths
+        change(:paths, Array(paths).dup.freeze)
+      else
+        @options[:paths]
+      end
     end
 
     private
+
     def check_uncovered(keywords)
       unknown = keywords - Analyser.optionally_covered
       raise ArgumentError, "unknown options: #{unknown.join(', ')}" unless unknown.empty?
     end
 
+    def change(option, value)
+      if @options[option] != value
+        @options[option] = value
+        @notify.config_changed(option) if @notify.respond_to? :config_changed
+      end
+      self
+    end
+
     def copy(h)
-      h.dup.transform_values(&:dup)
+      h.dup.transform_values(&:dup).transform_values(&:freeze)
     end
 
     module Setter
-      def config
-        @config ||= Config.new
+      def config(notify = self)
+        @config ||= Config.new(notify)
       end
 
       def configure(&block)
-        raise "Must provide a block" unless block
+        raise 'Must provide a block' unless block
         case block.arity
         when 0
           config.instance_eval(&block)

data/lib/deep_cover/core_ext/autoload_overrides.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # We need to override autoload, because MRI has special behaviors associated with it
 # that we can't reuse, hence we need to do workarounds.
 #

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This is a complete replacement for the builtin Coverage module of Ruby
 
 require 'coverage'

data/lib/deep_cover/core_ext/load_overrides.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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
@@ -8,12 +10,9 @@ module DeepCover
     def load(path, wrap = false)
       return load_without_deep_cover(path, wrap) if wrap
 
-      result = DeepCover.custom_requirer.load(path)
-      if [:not_found, :cover_failed, :not_supported].include?(result)
-        load_without_deep_cover(path)
-      else
-        result
-      end
+      result = catch(:use_fallback) { DeepCover.custom_requirer.load(path) }
+      result = load_without_deep_cover(path) if result.is_a? Symbol
+      result
     end
   end
 

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # These are the monkeypatches to replace the default #require and
 # #require_relative in order to instrument the code before it gets run.
 # Kernel.require and Kernel#require must both have their version because
@@ -7,17 +9,14 @@
 module DeepCover
   module RequireOverride
     def require(path)
-      result = DeepCover.custom_requirer.require(path)
-      if [:not_found, :cover_failed, :not_supported].include?(result)
-        require_without_deep_cover(path)
-      else
-        result
-      end
+      result = catch(:use_fallback) { DeepCover.custom_requirer.require(path) }
+      result = require_without_deep_cover(path) if result.is_a? Symbol
+      result
     end
 
     def require_relative(path)
       base = caller(1..1).first[/[^:]+/]
-      raise LoadError, "cannot infer basepath" unless base
+      raise LoadError, 'cannot infer basepath' unless base
       base = File.dirname(base)
 
       require(File.absolute_path(path, base))

data/lib/deep_cover/coverage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepCover
   require 'parser'
   silence_warnings do
@@ -34,7 +36,7 @@ module DeepCover
 
     def each
       return to_enum unless block_given?
-      @covered_codes.each{|_path, covered_code| yield covered_code}
+      @covered_codes.each_value { |covered_code| yield covered_code }
       self
     end
 
@@ -45,7 +47,7 @@ module DeepCover
       end.inject(:merge)
     end
 
-    def output_istanbul(dir: '.', name: ".nyc_output", **options)
+    def output_istanbul(dir: '.', name: '.nyc_output', **options)
       path = Pathname.new(dir).expand_path.join(name)
       path.mkpath
       path.each_child(&:delete)
@@ -82,7 +84,7 @@ module DeepCover
       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`"
+        warn 'nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`'
         basic_report
       end
     end
@@ -110,6 +112,7 @@ module DeepCover
     end
 
     class Persistence
+      # rubocop:disable Security/MarshalLoad
       BASENAME = 'coverage.dc'
       TRACKER_TEMPLATE = 'trackers%{unique}.dct'
 
@@ -132,16 +135,16 @@ module DeepCover
 
       def save_trackers(global)
         saved?
-        trackers = eval(global)
+        trackers = eval(global) # rubocop:disable Security/Eval
         # Some testing involves more than one process, some of which don't run any of our covered code.
         # Don't save anything if that's the case
         return if trackers.nil?
-        basename = TRACKER_TEMPLATE % {unique: SecureRandom.urlsafe_base64}
-        dir_path.join(basename).binwrite(Marshal.dump({
-          version: DeepCover::VERSION,
-          global: global,
-          trackers: trackers,
-        }))
+        basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
+        dir_path.join(basename).binwrite(Marshal.dump(
+                                             version: DeepCover::VERSION,
+                                             global: global,
+                                             trackers: trackers,
+        ))
       end
 
       def saved?
@@ -156,10 +159,10 @@ module DeepCover
       end
 
       def save_coverage(coverage)
-        dir_path.join(BASENAME).binwrite(Marshal.dump({
-          version: DeepCover::VERSION,
-          coverage: coverage,
-        }))
+        dir_path.join(BASENAME).binwrite(Marshal.dump(
+                                             version: DeepCover::VERSION,
+                                             coverage: coverage,
+        ))
       end
 
       def load_coverage
@@ -173,22 +176,22 @@ module DeepCover
         tracker_files.each do |full_path|
           Marshal.load(full_path.binread).tap do |version: raise, global: raise, trackers: raise|
             raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
-            merge_trackers(eval("#{global} ||= {}"), trackers)
+            merge_trackers(eval("#{global} ||= {}"), trackers) # rubocop:disable Security/Eval
           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
+          unless current.empty? || 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}
+          to_add.zip(current).map { |a, b| a + b }
         end
       end
 
       def tracker_files
-        basename = TRACKER_TEMPLATE % { unique: '*' }
+        basename = format(TRACKER_TEMPLATE, unique: '*')
         Pathname.glob(dir_path.join(basename))
       end
 

data/lib/deep_cover/covered_code.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module DeepCover
   class CoveredCode
     DEFAULT_TRACKER_GLOBAL = '$_cov'
 
     attr_accessor :covered_source, :buffer, :tracker_global, :local_var, :name
     @@counter = 0
-    @@globals = Hash.new{|h, global| h[global] = eval("#{global} ||= {}") }
+    @@globals = Hash.new { |h, global| h[global] = eval("#{global} ||= {}") } # rubocop:disable Security/Eval
 
     def initialize(path: nil, source: nil, lineno: 1, tracker_global: DEFAULT_TRACKER_GLOBAL, local_var: '_temp', name: nil)
-      raise "Must provide either path or source" unless path || source
+      raise 'Must provide either path or source' unless path || source
 
       @buffer = ::Parser::Source::Buffer.new(path, lineno)
       @buffer.source = source ||= File.read(path)
@@ -27,20 +29,18 @@ module DeepCover
     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
+      lines = buffer.source_lines
+      if lines.empty?
+        0
+      else
+        lines.size - (lines.last.empty? ? 1 : 0)
       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)
+      eval(@covered_source, binding, @buffer.name || '<raw_code>', lineno) # rubocop:disable Security/Eval
       self
     end
 
@@ -71,7 +71,7 @@ module DeepCover
     # Returns a range of tracker ids
     def allocate_trackers(nb_needed)
       prev = @tracker_count
-      @tracker_count += nb_needed
+      @tracker_count += nb_needed if nb_needed > 0 # Avoid error if frozen and called with 0.
       prev...@tracker_count
     end
 
@@ -109,7 +109,7 @@ module DeepCover
           prefix, _node, suffix = rule.partition('%{node}')
           unless prefix.empty?
             prefix = yield prefix, node, range.begin, :prefix if block_given?
-            rewriter.insert_before_multi range, prefix rescue binding.pry
+            rewriter.insert_before_multi range, prefix
           end
           unless suffix.empty?
             suffix = yield suffix, node, range.end, :suffix if block_given?
@@ -124,7 +124,17 @@ module DeepCover
       global[nb] != nil
     end
 
+    def freeze
+      unless frozen? # Guard against reentrance
+        must_have_executed
+        super
+        root.each_node(&:freeze)
+      end
+      self
+    end
+
     protected
+
     def global
       @@globals[tracker_global]
     end