deep-cover 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c66eb6bae41cc00df8fab37daf462d07a7ca032f
-  data.tar.gz: c0df6acbd831fc6b3ce08ee8586c559d7f929e58
+SHA256:
+  metadata.gz: f6177553f2233c0751899ecb895cc73ae75777977f26330b76e51507e875eb05
+  data.tar.gz: 213472177be49d89c862b8e0c334c6e5d86ec97d9abc193f201b9ca863092d53
 SHA512:
-  metadata.gz: d1f1252d95b2078f50344e7403f7bb093784a9e5f94b27dfc0c2d11f905d954a321bfc2a99af7c32b0377b108accf550466bc2ca1a2a2d281cd55d90fa72d74c
-  data.tar.gz: 28b4540147ff286db023c82b6bfc477f8d87913eb46e3954622970d5b70e614ed5c1331da80e6a34a9697c9d93ef47684d625466a6baf515e58868a45f210daa
+  metadata.gz: 375e33c302f38bda95139adaf8ee2d4500e935ce980794e6dcd382bcd6af42ba8a58c1aa98c830cfd0974ed21763f17bc8341b5720f40900f855a9e7a584e9fd
+  data.tar.gz: b62f8dd1c0978a69b2c0b80850def8adcfda8c8c861dc8c33e803b670ea6cd779c726678f703037f53c0b93ec72c2868dfb73a447baa2bd5799e7d030b295bb7

data/.deep_cover.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file is executed only when deep_cover is covering itself.
+
+DeepCover.configure do
+  tracker_global '$_dcg'
+  ignore_uncovered :warn, :raise, :default_argument
+end

data/.gitignore

@@ -15,3 +15,4 @@
 /Gemfile.local
 /spec/cli_fixtures/covered_trivial_gem/deep_cover/
 /deep_cover
+/exe/deep_cover/

data/.rubocop.yml

@@ -26,6 +26,9 @@ Layout/IndentArray:
 Layout/IndentHash:
   EnforcedStyle: align_braces
 
+Layout/IndentHeredoc:
+  Enabled: false
+
 Layout/MultilineArrayBraceLayout:
   EnforcedStyle: new_line
 
@@ -127,7 +130,10 @@ Style/StringLiterals:
 Style/TrailingCommaInArguments:
   Enabled: false
 
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: consistent_comma
 
 Naming/VariableNumber:
@@ -236,3 +242,11 @@ Style/EvalWithLocation:
 
 Lint/BooleanSymbol:
   Enabled: false
+
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - spec/**/*
+
+Layout/SpaceInsideReferenceBrackets:
+  Exclude:
+    - spec/**/*

data/.travis.yml

@@ -10,6 +10,7 @@ rvm:
   - jruby-9.1.9.0
 before_install:
   - gem update --system
+  - gem install bundler
   - npm install -g nyc
 before_script:
   - bundle exec rake dev:install

data/README.md

@@ -41,6 +41,35 @@ These examples are direct outputs from our HTML reporter:
 * [Rails' `activesupport`](https://deep-cover.github.io/rails-cover/activesupport/)
 * [Rails' `activerecord`](https://deep-cover.github.io/rails-cover/activerecord/)
 
+## DeepCover vs builtin coverage
+
+Feature            | MRI        | DeepCover
+-------------------|:----------:|:--------:
+Line coverage      |  partial   |  ✓
+Statement coverage |  no        |  ✓
+Branch coverage    |  partial   |  ✓
+Method coverage    |  ✓         |  ~
+Slowdown           |  < 1%      |  ~20%
+Platform support   |  Ruby 2.5+ |  Ruby 2.1+, JRuby
+
+**Line coverage**: MRI doesn't cover some lines (e.g. `when some_value`).
+
+**Statement coverage**: MRI provides no way to tell which parts of any line is evaluated. 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.
+
+**Branch coverage**     | MRI | DeepCover
+------------------------|:---:|:--------:
+`if` / `unless` / `?:`  |  ✓  |    ✓
+`case` / `when`         |  ✓  |    ✓
+`❘❘` / `&&`             |  no |    ✓
+`foo&.bar`              |  ✓  |    ✓
+`{❘foo = 42, bar: 43❘}` |  no |    ✓
+`while` / `until`       |  ✓  |    !
+
+*Note on loops (!)*: DeepCover doesn't consider loops to be branches, but it's
+easy to support it if needed.
+
 ## Installation
 
     gem install deep-cover
@@ -115,7 +144,7 @@ To make it easier to transition for projects already using the builtin `Coverage
 
 Add to your Gemfile `gem 'deep-cover'`, then run `bundle`.
 
-Before you require `coverage` or `simplecov`, do a `require 'deep-cover/builtin_takeover'`.
+Before you require `coverage` or `simplecov`, do a `require 'deep_cover/builtin_takeover'`.
 
 For example, the `test/test_helper.rb` file for `simplecov` users will look like
 

data/Rakefile

@@ -4,7 +4,9 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 
-RuboCop::RakeTask.new
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ['-a']
+end
 
 RSpec::Core::RakeTask.new(:spec).tap { |task| task.pattern = 'spec/*_spec.rb, spec/*/*_spec.rb' }
 
@@ -18,6 +20,13 @@ multitask default: RUBY_VERSION > '2.1' ? [:rubocop, :spec] : :spec
 multitask 'test:all' => RUBY_VERSION > '2.1' ? [:rubocop, 'spec:all'] : 'spec:all'
 
 namespace :dev do
+  desc 'Self cover'
+  task :cov do
+    command = "exe/deep-cover . --no-bundle --command 'rake spec:all'"
+    puts command
+    system command
+  end
+
   desc 'Setup extra things required to run the spec suite'
   task :install do
     commands = []

data/bin/cov

@@ -2,7 +2,6 @@
 module DeepCover
   require 'bundler/setup'
 
-  $LOAD_PATH.unshift('../covered_deep_cover') if ENV['CC']
   require 'deep_cover'
   require_relative '../spec/specs_tools'
   require 'deep_cover/cli/debugger'
@@ -10,6 +9,7 @@ module DeepCover
   example = ARGV[0] || 'simple_if'
   fn = "./spec/samples/#{example}.rb"
   fn = "./spec/char_cover/#{example}.rb" unless File.exist?(fn)
+  fn = example unless File.exist?(fn)
   if File.exist?(fn)
     fn = File.absolute_path(fn)
     source = File.read(fn)

data/deep_cover.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'deep_cover/version'
 
@@ -26,14 +26,14 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.1.0'
 
   # Main dependency
-  spec.add_runtime_dependency 'parser'
-  spec.add_runtime_dependency 'parser_tree_rewriter'
+  spec.add_runtime_dependency 'parser', '~> 2.5.0'
 
   # Support
   spec.add_runtime_dependency 'backports', '>= 3.11.0'
   spec.add_runtime_dependency 'binding_of_caller'
 
   # CLI
+  spec.add_runtime_dependency 'bundler'
   spec.add_runtime_dependency 'highline'
   spec.add_runtime_dependency 'slop', '~> 4.0'
   spec.add_runtime_dependency 'term-ansicolor'
@@ -46,10 +46,9 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'pry'
 
   ### Dev dependencies
-  spec.add_development_dependency 'activesupport', '~> 4.0'
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'psych', '>= 2.0'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '0.52.1' # About every single release breaks something
+  spec.add_development_dependency 'rubocop', '0.53.0' # About every single release breaks something
 end

data/exe/deep-cover

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-require 'deep_cover/cli/deep_cover'
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
-DeepCover::CLI::DeepCover.go
+require_relative '../lib/deep_cover_entry'
+require 'deep_cover/cli/runner'
+
+DeepCover::CLI::Runner.go

data/lib/deep_cover.rb

@@ -18,5 +18,5 @@ end
 if %w[1 t true].include?(ENV['DEEP_COVER'])
   DeepCover.start
   require_relative 'deep_cover/auto_run'
-  DeepCover::AutoRun.run!('.').and_report!(**DeepCover.config)
+  DeepCover::AutoRun.run!('.').report!(**DeepCover.config)
 end

data/lib/deep_cover/analyser/node.rb

@@ -29,7 +29,7 @@ module DeepCover
 
     protected
 
-    def convert(node, **)
+    def convert(node, **) # rubocop:disable Naming/UncommunicativeMethodParamName [#5436]
       Analyser::CoveredCodeSource.new(node)
     end
 

data/lib/deep_cover/analyser/ruby25_like_branch.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Ruby25LikeBranch < Analyser
+    def self.human_name
+      'Ruby25 branches'
+    end
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Case, Node::Csend, Node::If, Node::ShortCircuit,
+                      Node::Until, Node::UntilPost, Node::While, Node::WhilePost,
+                     ].freeze
+
+    def initialize(*args)
+      super
+      @loc_index = 0
+    end
+
+    def results
+      extractor = NodeCoverageExtrator.new
+      each_node.map do |node|
+        extractor.branch_coverage(node)
+      end.to_h
+    end
+
+    # This is the class doing the work. Since everything is about the node, the class delegates
+    # missing methods to the node, simplifying the code.
+    class NodeCoverageExtrator < SimpleDelegator
+      def initialize(node = nil)
+        self.node = node
+        @loc_index = 0
+      end
+
+      alias_method :node=, :__setobj__
+      alias_method :node, :__getobj__
+
+      def branch_coverage(node)
+        self.node = node
+        case node
+        when Node::Case
+          handle_case
+        when Node::Csend
+          handle_csend
+        when Node::If
+          handle_if
+        when Node::ShortCircuit
+          handle_short_circuit
+        when Node::Until, Node::While, Node::UntilPost, Node::WhilePost
+          handle_until_while
+        end
+      end
+
+      def handle_case
+        cond_info = [:case, *node_loc_infos]
+
+        sub_keys = [:when] * (branches.size - 1) + [:else]
+        empty_fallbacks = whens.map { |w| (w.loc_hash[:begin] || w.loc_hash[:expression]).wrap_rwhitespace_and_comments.end }
+        empty_fallbacks.map!(&:begin)
+
+        if loc_hash[:else]
+          empty_fallbacks << loc_hash[:end].begin
+        else
+          # DeepCover manually inserts a `else` for Case when there isn't one for tracker purposes.
+          # The normal behavior of ruby25's branch coverage when there is no else is to return the loc of the node
+          # So we sent that fallback.
+          empty_fallbacks << expression
+        end
+
+        branches_locs = whens.map do |when_node|
+          next when_node.body if when_node.body.is_a?(Node::EmptyBody)
+
+          start_at = when_node.loc_hash[:begin]
+          start_at = start_at.wrap_rwhitespace_and_comments.end if start_at
+          start_at ||= when_node.body.expression.begin
+
+          end_at = when_node.body.expression.end
+          start_at.with(end_pos: end_at.end_pos)
+        end
+
+        branches_locs << node.else
+        clauses_infos = infos_for_branches(branches_locs, sub_keys, empty_fallbacks, execution_counts: branches.map(&:execution_count))
+
+        [cond_info, clauses_infos]
+      end
+
+      def handle_csend
+        cond_info = [:"&.", *node_loc_infos]
+        false_branch, true_branch = branches
+        [cond_info, {[:then, *node_loc_infos] => true_branch.execution_count,
+                     [:else, *node_loc_infos] => false_branch.execution_count,
+                    },
+        ]
+      end
+
+      def handle_if
+        key = style == :unless ? :unless : :if
+
+        node_range = extend_elsif_range
+        cond_info = [key, *node_loc_infos(node_range)]
+
+        sub_keys = [:then, :else]
+        if style == :ternary
+          empty_fallback_locs = [nil, nil]
+        else
+          else_loc = loc_hash[:else]
+
+          first_clause_fallback = loc_hash[:begin]
+          if first_clause_fallback
+            first_clause_fallback = first_clause_fallback.wrap_rwhitespace_and_comments.end
+          elsif else_loc
+            first_clause_fallback = else_loc.begin
+          end
+
+          if else_loc
+            second_clause_fallback = else_loc.wrap_rwhitespace_and_comments.end
+          end
+          end_loc = root_if_node.loc_hash[:end]
+          end_loc = end_loc.begin if end_loc
+
+          empty_fallback_locs = [first_clause_fallback || end_loc, second_clause_fallback || end_loc]
+        end
+        # loc can be nil if the clause can't be empty, such as ternary and modifer if/unless
+
+        if key == :unless
+          sub_keys.reverse!
+          empty_fallback_locs.reverse!
+        end
+
+        branches_locs = branches
+        execution_counts = branches_locs.map(&:execution_count)
+        branches_locs[1] = extend_elsif_range(branches_locs[1])
+
+        clauses_infos = infos_for_branches(branches_locs, sub_keys, empty_fallback_locs, execution_counts: execution_counts, node_range: node_range)
+        [cond_info, clauses_infos]
+      end
+
+      def handle_short_circuit
+        cond_info = [operator, *node_loc_infos]
+        sub_keys = [:then, :else]
+        sub_keys.reverse! if node.is_a?(Node::Or)
+
+        [cond_info, infos_for_branches(branches, sub_keys, [nil, nil])]
+      end
+
+      def handle_until_while
+        key = loc_hash[:keyword].source.to_sym
+        base_info = [key, *node_loc_infos]
+        body_node = if node.is_a?(Node::WhilePost) || node.is_a?(Node::UntilPost)
+                      if !body.instructions.empty?
+                        end_pos = body.instructions.last.expression.end_pos
+                        body.instructions.first.expression.with(end_pos: end_pos)
+                      else
+                        body.loc_hash[:end].begin
+                      end
+                    elsif body.is_a?(Node::Begin) && !node.body.expressions.empty?
+                      end_pos = body.expressions.last.expression.end_pos
+                      body.expressions.first.expression.with(end_pos: end_pos)
+                    else
+                      body
+                    end
+
+        [base_info, {[:body, *node_loc_infos(body_node)] => body.execution_count}]
+      end
+
+      protected
+
+      # If the actual else clause (final one) of an if...elsif...end is empty, then Ruby makes the
+      # node reach the `end` in its branch coverage output
+      def extend_elsif_range(possible_elsif = node)
+        return possible_elsif unless possible_elsif.is_a?(Node::If) && possible_elsif.style == :elsif
+        deepest_if = possible_elsif.deepest_elsif_node
+        if deepest_if.false_branch.is_a?(Node::EmptyBody)
+          return possible_elsif.expression.with(end_pos: possible_elsif.root_if_node.loc_hash[:end].begin_pos)
+        end
+        possible_elsif
+      end
+
+      def infos_for_branch(branch, key, empty_fallback_loc, execution_count: nil, node_range: node)
+        if !branch.is_a?(Node::EmptyBody)
+          loc = branch
+        elsif branch.expression
+          # There is clause, but it is empty
+          loc = empty_fallback_loc
+        else
+          # There is no clause
+          loc = node_range
+        end
+
+        execution_count ||= branch.execution_count
+        [[key, *node_loc_infos(loc)], execution_count]
+      end
+
+      def infos_for_branches(branches, keys, empty_fallback_locs, execution_counts: [], node_range: node)
+        branches_infos = branches.map.with_index do |branch, i|
+          infos_for_branch(branch, keys[i], empty_fallback_locs[i], execution_count: execution_counts[i], node_range: node_range)
+        end
+        branches_infos.to_h
+      end
+
+      def node_loc_infos(node_or_range = node)
+        source_range = node_or_range.is_a?(Node) ? node_or_range.expression : node_or_range
+
+        @loc_index += 1
+        [@loc_index, source_range.line, source_range.column, source_range.last_line, source_range.last_column]
+      end
+    end
+  end
+end

data/lib/deep_cover/auto_run.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require_relative '../deep_cover'
-require 'pry'
+require_relative 'core_ext/exec_callbacks'
 
 module DeepCover
   module AutoRun
     class Runner
       def initialize(covered_path)
         @covered_path = covered_path
+        @saved = !(DeepCover.respond_to?(:running?) && DeepCover.running?)
       end
 
       def run!
-        @coverage = load_coverage
         after_tests { save }
+        ExecCallbacks.before_exec { save }
         self
       end
 
@@ -23,22 +23,26 @@ module DeepCover
 
       private
 
-      def load_coverage
-        @not_saved = DeepCover.respond_to?(:running?) && DeepCover.running?
-        if @not_saved
-          DeepCover.coverage
-        else
-          Coverage.load(@covered_path, with_trackers: false)
-        end
+      def saved?
+        @saved
+      end
+
+      def coverage
+        @coverage ||= if saved?
+                        Coverage.load(@covered_path, with_trackers: false)
+                      else
+                        DeepCover.coverage
+                      end
       end
 
       def save
-        @coverage.save(@covered_path) if @not_saved
-        @coverage.save_trackers(@covered_path)
+        require_relative '../deep_cover'
+        coverage.save(@covered_path) unless saved?
+        coverage.save_trackers(@covered_path)
       end
 
       def report(**options)
-        @coverage.report(**options)
+        coverage.report(**options)
       end
 
       def after_tests
@@ -60,12 +64,8 @@ module DeepCover
     end
 
     def self.run!(covered_path)
-      @runner ||= Runner.new(covered_path).run!
-      self
-    end
-
-    def self.and_report!(**options)
-      @runner.report!(**options)
+      @runners ||= {}
+      @runners[covered_path] ||= Runner.new(covered_path).run!
     end
   end
 end