deep-cover 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddf8729ec371781a34f8b9f333e12f5a8b447ad6768f12b1106ad07bfe7f69aa
-  data.tar.gz: 9de4ab46c4c64b1c174511c8359c2268cf5775bdc85640224deb9fcd90b52031
+  metadata.gz: 8b1f81b23d211ad08949890b4bc4267613e18b566b5e8129aa2ec575cc1cf28e
+  data.tar.gz: 3f80f743ba78813f2218aeed63bc9a8ba889447f446367f1df34a9054b59bb8b
 SHA512:
-  metadata.gz: 0153a2468094f09c14b9339dc7e5b5eb0132bc692b73255e5e1f28a1025f390d801bf5522f3ffee89ed2d801a6056a0b86a019d73adaee090d0f2aab07be88c7
-  data.tar.gz: 547dd15651dc7c896ed190d91ae2b5703239c883cda8037d8a3cf8d38711213abf1481197be5df0822e44cb9873b6232a4f7f72838936195a9629c7eefced66b
+  metadata.gz: e0763b964b08399a871dc36b4da0bd0b227a58eabf15c98b0144abae98222d0fb44a67ed4ea11cf91c64350bef1072d539c5f45f6075043f2b6a559a4cc6a24d
+  data.tar.gz: 342d74b8ffbc0c56c062635c66b799ae9926fecf060d3d62188adcb6aea09a957ae3a3d97b4662c1538ef407bbdc60888675930f3db4f2fc20b75c35eca3da82

data/.deep_cover.rb

@@ -5,4 +5,9 @@
 DeepCover.configure do
   tracker_global '$_dcg'
   ignore_uncovered :warn, :raise, :default_argument
+  # Statement analyser is only used for Istanbul output and is undertested.
+  # Ignore for now. TODO: test this, or get rid of StatementAnalyser
+  ignore_uncovered :is_statement_methods do
+    parent.is_a?(DeepCover::Node::Def) && parent.method_name == :is_statement
+  end
 end

data/.gitignore

@@ -1,6 +1,6 @@
 .bundle/
 .yardoc
-/Gemfile.lock
+Gemfile.lock
 /core_gem/Gemfile.lock
 /_yardoc/
 /coverage/
@@ -15,6 +15,9 @@
 # rspec failure tracking
 .rspec_status
 /Gemfile.local
-/spec/code_fixtures/covered_trivial_gem/deep_cover/
-/deep_cover
-/exe/deep_cover/
+*.dc
+*.dct
+.nyc_output/
+
+# Used in tests
+*.else

data/.rubocop.yml

@@ -109,6 +109,9 @@ Style/FrozenStringLiteralComment:
 Style/NegatedIf:
   Enabled: false
 
+Style/Next:
+  Enabled: false
+
 Style/NumericPredicate:
   Enabled: false
 
@@ -119,6 +122,9 @@ Style/PercentLiteralDelimiters:
 Style/RedundantSelf:
   Enabled: false
 
+Style/SpecialGlobalVars:
+  Enabled: false
+
 Style/StringLiterals:
   EnforcedStyle: single_quotes
 
@@ -188,6 +194,7 @@ Lint/Void:
   Enabled: true
   Exclude:
     - core_gem/spec/**/*
+    - spec/**/*
 
 Style/ClassVars:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.7.0
+
+* Switched CLI to rely on Thor instead of Slop
+* Added lower-level CLI commands: gather, merge, report, clear
+* Added `deep-cover clone`, it does what `deep-cover` without commands did.
+* Changed the default when using `deep-cover` without commands, it now shows a short help.
+  Use `deep-cover clone` to reproduce the previous default.
+* `deep-cover exec` now uses the same default command as `deep-cover clone`
+* Added global option -C (--change-directory) which basically executes a `cd` before executing deep-cover.
+  This replaces the default path parameter of `deep-cover clone`
+* `deep-cover clone` now receives an optional command as positional argument, just like `deep-cover exec`.
+  It's previous positional argument (path to run) is now the -C option.
+* `deep-cover` now display coverage information for files that were not loaded. This may lower your the coverage results.
+* The configuration for the paths to cover can now receive globs.
+* `deep-cover clone` no longer needs bundler. It still uses a Gemfile, if it finds one, to decide between
+  copying the current directory or the parent one.
+* `deep-cover clone` is more efficient and has less edge cases that would make some files not be covered.
+
+## 0.6.3
+
+* Split the gem into two: `deep-cover` and `deep-cover-core`.
+  `deep-cover` is the cli, and depends on `deep-cover-core`, so nothing special is needed.
+  Those that don't want to have the CLI (either for dependencies or because they don't use it)
+  may now avoid it.
+
+## 0.6.2
+
 * `#require` is much faster in MRI Ruby 2.1 and 2.2, resulting in much faster boot time for most applications when deep-cover is enabled.
 
 ## 0.6.1

data/Gemfile

@@ -9,6 +9,10 @@ gemspec
 
 eval_gemfile File.expand_path('Gemfile.local', __dir__) if File.exist?('Gemfile.local')
 
-gem 'deep-cover-core', path: 'core_gem'
+# This is a workaround for rubymine to stop treating the core_gem directory like an external library...
+# https://youtrack.jetbrains.com/issue/RUBY-18315#comment=27-1608735
+gem_name = 'deep-cover-core'
+gem_path = 'core_gem'
+gem gem_name, path: gem_path
 
 gem 'ruby-prof', platforms: :mri

data/README.md

@@ -54,7 +54,7 @@ Platform support   |  Ruby 2.5+ |  Ruby 2.1+, JRuby
 
 **Line coverage**: MRI doesn't cover some lines (e.g. `when some_value`).
 
-**Node coverage**: MRI provides no way to tell which parts of any line is evaluated. DeepCover covers everything.
+**Node coverage**: MRI provides no way to tell which parts of any line is evaluated (e.g. `0.times { never_run }`). DeepCover covers everything.
 
 **Method coverage**: MRI considers every method defined, including methods defined on objects or via `define_method`, `class_eval`, etc. For Istanbul output, DeepCover has a different approach and covers all `def` and all blocks.
 
@@ -72,81 +72,71 @@ easy to support it if needed.
 
 ## Installation
 
-    gem install deep-cover
-
-First we present the official way. There are also quick and dirty ways to try `deep-cover` without changing much your current setup, which we present afterwards.
-
-### Canonical installation
-
-*1* Add the `deep-cover` gem as a dependency:
-
-For a standalone project (Rails app), add `deep-cover` to your Gemfile:
+Do the appropriate of the installation of the gem, then follow the steps that correspond to your situation.
 
-    gem 'deep-cover', '~> 0.4', group: :test, require: false
+    # if the project is a gem, add this to your .gemspec and then run `bundle install`
+    spec.add_development_dependency 'deep-cover', '~> 0.7'
 
-Then run `bundle`
+    # otherwise if using a Gemfile, add this to it and then run `bundle install`
+    gem 'deep-cover', '~> 0.7', group: :test, require: false
 
-For a gem, you want to add `spec.add_development_dependency 'deep-cover', '~> 0.4'` to your `gemspec` file instead.
+    # otherwise just run:
+    gem install deep-cover
 
-*2* Require `deep-cover`
 
-You must call `require 'deep-cover'` *before* the code you want to cover is loaded.
+### Trying `deep-cover` quickly
 
-Typically, you want to insert that line in your `test/test_helper.rb` or `spec/spec_helper.rb` file at the right place. For example
+An easy way to try `deep-cover`, without any configuration needed:
 
-```
-ENV['RAILS_ENV'] ||= 'test'
-require 'deep-cover' # Must be before the environment is loaded on the next line
-require File.expand_path('../../config/environment', __FILE__)
-require 'rails/test_help'
-# ...
-```
+    deep-cover clone command to run test
+    # ex:
+    deep-cover clone rake test
 
-*3* Create a config file (optional)
+Check the produced `coverage/index.html`.
 
-You may want to create a config file `.deep-cover.rb` at the root of your project, where you can set the config as you wish.
+Note, this is a bit slower and may cause issues in your tests if your use relative paths that lead outside of the directory (Such as a dependency that is in a parent directory).
 
-```
-# File .deep-cover.rb
-DeepCover.config do
-  ignore :default_arguments
-  # ...
-end
-```
+### Regular setup
 
-*4* Launch it
+1. Require `deep-cover`
 
-Even after `DeepCover` is `require`d and configured, only a very minimal amount of code is actually loaded and coverage is *not started*.
+    You must call `require 'deep-cover'` **before** the code you want to cover is loaded.
 
-The easiest way to actually start it is to use `deep-cover exec` instead of `bundle exec`.
+    Typically, you want to insert that line **at the very top** of `test/test_helper.rb` or `spec/spec_helper.rb` . If `deep-cover` is required after your code, then it won't be able to detect the coverage.
 
-For example:
+2. Create a config file (optional)
 
-```
-$ deep-cover exec rspec
-# ...all the output of rspec
-# ...coverage report
-```
+    You may want to create a config file `.deep-cover.rb` at the root of your project, where you can set the config as you wish.
 
-### Command line interface (for a Rails app or a Gem):
+    ```
+    # File .deep-cover.rb
+    DeepCover.config do
+      ignore :default_arguments
+      # ...
+    end
+    ```
 
-An easy way to try `deep-cover`, without any configuration needed:
+3. Launch it
 
-    deep-cover /path/to/rails/app/or/gem
+    Even after `DeepCover` is `require`d and configured, only a very minimal amount of code is actually loaded and coverage is *not started*.
 
-This assumes your project has a `Gemfile`, and that your default `rake` task is set to execute all tests (otherwise set the `--command` option)
+    The easiest way to actually start it is to use `deep-cover exec`
 
-It also uses our builtin HTML reporter. Check the produced `coverage/index.html`.
+    For example:
 
-### Projects using builtin Coverage (including SimpleCov) users
+    ```
+    $ deep-cover exec rspec
+    # ...all the output of rspec
+    # ...coverage report
+    ```
 
-To make it easier to transition for projects already using the builtin `Coverage` library (or indirectly those using `SimpleCov`), there is a way to overwrite the `Coverage` library using `deep-cover`'s extended coverage.
+### Already using SimpleCov / builtin Coverage
 
-Add to your Gemfile `gem 'deep-cover', require: false`, then run `bundle`.
+To make it easier to transition for projects already using the builtin `Coverage` library (such as those using `SimpleCov`), `deep-cover` can inject itself into those tools so that, while you still only have line-by-line coverage information, it becomes stricter, only marking a line as executed if *everything* on it has been executed.
 
-Before you require `coverage` or `simplecov`, do a `require 'deep_cover/builtin_takeover'`.
+You must call `require 'deep-cover/builtin_takeover'` **before** you require the coverage tool that you normally use.
 
-For example, the `test/test_helper.rb` file for `simplecov` users will look like
+For example, the `test/test_helper.rb` file for `SimpleCov` users will look like
 
 ```
 require 'deep_cover/builtin_takeover'
@@ -155,6 +145,12 @@ SimpleCov.start
 # rest of `test_helper.rb`
 ```
 
+Once this is done, simply generate the coverage as you normally would. In order to get detailed information about why a line is not covered, you will need to the regular `deep-cover` mode.
+
+### Online coverage tools such as Code Climate, Coveralls, Codecov
+
+At the moment, those tools do not support deep-cover. It is however possible to use the takeover system to, at least, make them stricter. Follow the explanation in the above section for injecting into `SimpleCov`.
+
 ## Usage
 
 ### Configuration
@@ -172,8 +168,6 @@ end
 
 The file `.deep-cover.rb` is loaded automatically when requiring `deep-cover` and is the best place to put the configuration.
 
-*Note*: The configuration block is only executed when `deep-cover` is actually started.
-
 #### Custom filters
 
 `deep-cover` comes with a few filters that make it possible to ignore certain uncovered codes.

data/Rakefile

@@ -18,30 +18,34 @@ desc 'Build & release deep-cover and deep-cover-core to rubygems.org'
 task release: ['core:sass', 'core:release', 'global:release']
 
 ### Tests tasks
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
+begin
+  require 'rspec/core/rake_task'
+  require 'rubocop/rake_task'
 
-RuboCop::RakeTask.new(:rubocop) do |t|
-  t.options = ['-a'] unless ENV['TRAVIS']
-end
+  RuboCop::RakeTask.new(:rubocop) do |t|
+    t.options = ['-a'] unless ENV['TRAVIS']
+  end
 
-spec_path = 'spec/*_spec.rb, core_gem/spec/**/*_spec.rb'
-RSpec::Core::RakeTask.new(:spec).tap { |task| task.pattern = spec_path }
+  spec_path = 'spec/*_spec.rb, core_gem/spec/**/*_spec.rb'
+  RSpec::Core::RakeTask.new(:spec).tap { |task| task.pattern = spec_path }
 
-desc 'Run all tests'
-RSpec::Core::RakeTask.new('spec:all') do |task|
-  task.pattern = spec_path
-  task.rspec_opts = '-O .rspec_all'
-end
+  desc 'Run all tests'
+  RSpec::Core::RakeTask.new('spec:all') do |task|
+    task.pattern = spec_path
+    task.rspec_opts = '-O .rspec_all'
+  end
 
-multitask default: RUBY_VERSION > '2.1' ? [:rubocop, :spec] : :spec
-multitask 'test:all' => RUBY_VERSION > '2.1' ? [:rubocop, 'spec:all'] : 'spec:all'
+  multitask default: RUBY_VERSION > '2.1' ? [:rubocop, :spec] : :spec
+  multitask 'test:all' => RUBY_VERSION > '2.1' ? [:rubocop, 'spec:all'] : 'spec:all'
+rescue LoadError
+  puts 'Note: rspec or rubocop not installed'
+end
 
 #### Utilities
 namespace :dev do
   desc 'Self cover'
   task :cov do
-    command = "exe/deep-cover . --no-bundle --command 'rake spec:all'"
+    command = "exe/deep-cover clone --no-bundle --command 'rake spec:all'"
     puts command
     system command
   end
@@ -56,6 +60,7 @@ namespace :dev do
     commands << 'bundle install --gemfile=spec/code_fixtures/simple_rails42_app/Gemfile'
     commands << 'bundle install --gemfile=spec/code_fixtures/rails_like_gem/Gemfile'
     commands << 'bundle install --gemfile=core_gem/Gemfile'
+    commands << 'bundle install'
 
     commands.each do |command|
       puts "Running: #{command}"

data/deep_cover.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features|\w+_gem)/})
+    f.match(%r{^(test|spec|features|bin|\w+_gem)/})
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -29,8 +29,7 @@ Gem::Specification.new do |spec|
   # CLI
   spec.add_runtime_dependency 'bundler'
   spec.add_runtime_dependency 'highline'
-  spec.add_runtime_dependency 'slop', '~> 4.0'
-  spec.add_runtime_dependency 'term-ansicolor'
+  spec.add_runtime_dependency 'thor', '>= 0.20.3'
   spec.add_runtime_dependency 'with_progress'
 
   ### Dev dependencies

data/exe/deep-cover

@@ -3,12 +3,10 @@
 
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
-require_relative '../lib/deep_cover_entry'
-
 # HACK: tweak $LOAD_PATH when running from source
 local_gem_path = File.expand_path('../core_gem', __dir__)
 $LOAD_PATH.unshift "#{local_gem_path}/lib" if Dir.exist?(local_gem_path)
 
-require 'deep_cover/cli/runner'
+require_relative '../lib/deep_cover/cli'
 
-DeepCover::CLI::Runner.go
+DeepCover::CLI.start

data/lib/deep_cover/cli.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+
+module DeepCover
+  # can't use `#require_relative`: This is gem deep-cover requiring from gem deep-cover-core
+  # We don't want the config to be loaded right now, because we may move the current_work_dir somewhere else.
+  require 'deep_cover/setup/deep_cover_without_config'
+
+  bootstrap
+
+  class CLI < Thor
+    require_relative 'cli/tools'
+
+    # Just fail when you get an unknown option
+    check_unknown_options!
+
+    # If the default value of a option doesn't match its type, something is wrong.
+    check_default_type!
+
+    # Every top-level commands are defined in a different file, which add their method to this class
+    DeepCover.require_relative_dir 'cli/commands'
+
+    default_command :short_help
+
+    # Adding all of the ignore-something class options
+    OPTIONALLY_COVERED_MAP = OPTIONALLY_COVERED.map do |optional|
+      [:"ignore_#{optional}", optional]
+    end.to_h.freeze
+    OPTIONALLY_COVERED_MAP.each do |cli_option, short_name|
+      default = DeepCover.config.ignore_uncovered.include?(short_name)
+      class_option cli_option, type: :boolean, default: default
+    end
+
+    class_option :change_directory, desc: 'Runs as if deep-cover was started in <path>', type: :string, aliases: '-C', default: '.'
+
+    # exit_code should be non-zero when the parsing fails
+    def self.exit_on_failure?
+      true
+    end
+
+    no_commands do
+      # We have some special handling for some of the options
+      # We do this here, methods just need to call processed_options instead of options.
+      def processed_options
+        @processed_options ||= nil
+        return @processed_options if @processed_options
+
+        new_options = options.dup
+        new_options[:output] = false if ['false', 'f', ''].include?(new_options[:output])
+
+        # Turn all the ignore-x into entries in :ignore_uncovered
+        ignored = new_options[:ignore_uncovered] = []
+        OPTIONALLY_COVERED_MAP.each do |cli_option, option|
+          ignored << option if new_options.delete(cli_option)
+        end
+
+        @processed_options = new_options.transform_keys(&:to_sym)
+      end
+
+      # Before we actually execute any of the commands, we want to change directory if that option was given.
+      # And then we want to setup the configuration
+      def invoke_command(*args)
+        if options[:change_directory] != '.'
+          root_path = File.expand_path(options[:change_directory])
+          unless File.exist?(root_path)
+            warn set_color(DeepCover::Tools.strip_heredoc(<<-MSG), :red)
+              bad value for option --change_directory: #{root_path.inspect} is not a valid directory
+            MSG
+            exit(1)
+          end
+          Dir.chdir(root_path)
+          # TODO: We need way to turn on DEBUG
+          # warn "(in #{root_path})"
+        end
+
+        # We need to wait until now to setup the configuration, because it will store absolute paths
+        # in ENV['DEEP_COVER_OPTIONS'], so we must wait until the change_directory was applied.
+        require 'deep_cover/setup/deep_cover_config'
+        super
+      end
+    end
+  end
+end