deep-cover 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3b9feb6fdad25312b0111faf653599e6019c51ddbcd31446ec2c45d7c5403f3
-  data.tar.gz: 18c532649cdc00a98690fc3d66ced732e11b1c97a2787ab36d0d5e3151e20601
+  metadata.gz: b07ad13bcfdc6616d61b1a80bd632d8b41e105a942b91e526b6a794a7b0315ba
+  data.tar.gz: 12c59e6a8ae6e161e1bf93306cebae6f0281204d3dc41241f6dc20f025102eb3
 SHA512:
-  metadata.gz: 1b68e3fc7a62f263f1971b7b50b753d5ca5472bee6231eba897771ff1e036efcc6f8cc5625b1e5b6ef3422a978f1e2876ba7b6f8488d176705e0b8f465d9786d
-  data.tar.gz: 9fcf65daa4618b3c9d056ed95fe1a3f7e9ae1e4d67768940989630fa9c1a45ff05c7504bffae5058e0597fea8f661e730d59fa0ec089446d2ad28ec5f4ab963c
+  metadata.gz: 1421c160b9eb370663025c4704ab69fb061686301d694d65554fd3cd8a10211e1376ca072a7744e3f1568bd93e851d2889ad4f1c09b8d86f0a19fe08d59b04c9
+  data.tar.gz: 0b3a75ff09297e170ffe800bcbe6fb4a0ad22e1bac1ca91d4b0d10fb8e79f96030e117845953c25f0a182708e1aace7e67ca7b97efccafbeb830d4a353df139c

data/lib/deep_cover/analyser/per_line.rb

@@ -3,22 +3,39 @@
 module DeepCover
   class Analyser::PerLine < Analyser
     # Returns an array of runs, one per line.
+    # allow_partial can be one of:
+    #   true: Allow any partial covering. Basically ruby's line coverage,
+    #         if any thing is executed, it is considered executed
+    #   branch: Only allow branches to be partially covered.
+    #           if a node is not executed, the line has to be marked as not executed, even if part of it was.
+    #   false: Allow nothing to be partially covered.
+    #          same as :branch, but also:
+    #          if an empty branch is not executed, the line has to be marked as not executed.
+    #          This is only for empty branches because, if they are not empty, there will already
+    #          be some red from the partial node covering. We don't everything to become red,
+    #          just want 100% coverage to be as hard as branch + node coverage.
     def results
-      disallow_partial = !options.fetch(:allow_partial, true)
+      allow_partial = options.fetch(:allow_partial, true)
       line_hits = Array.new(covered_code.nb_lines + covered_code.lineno - 1)
+      disallowed_lines = Set.new
       each_node do |node|
         next unless (runs = node_runs(node))
         node.executed_locs.each do |loc|
-          lineno = loc.line - 1
-          if disallow_partial
-            line_hits[lineno] = 0 if runs == 0
-            next if line_hits[lineno] == 0
-          end
-          line_hits[lineno] = [line_hits[lineno] || 0, runs].max
+          line_index = loc.line - 1
+
+          next if disallowed_lines.include?(line_index)
+          disallowed_lines << line_index if [nil, false, :branch].include?(allow_partial) && runs == 0
+          disallowed_lines << line_index if !allow_partial && missed_empty_branch?(node)
+
+          line_hits[line_index] = [line_hits[line_index] || 0, runs].max
         end
       end
-
+      disallowed_lines.each { |line_index| line_hits[line_index] = 0 }
       line_hits
     end
+
+    def missed_empty_branch?(node)
+      node.is_a?(Node::Branch) && node.branches.any? { |b| b.is_a?(Node::EmptyBody) && !Tools.covered?(node_runs(b)) }
+    end
   end
 end

data/lib/deep_cover/analyser/ruby25_like_branch.rb

@@ -85,10 +85,12 @@ module DeepCover
       end
 
       def handle_csend
-        cond_info = [:"&.", *node_loc_infos]
+        # csend wraps the comment but not the newlines
+        node_range = node.expression.wrap_rwhitespace_and_comments(whitespaces: /\A[ \t\r\f]+/)
+        cond_info = [:"&.", *node_loc_infos(node_range)]
         false_branch, true_branch = branches
-        [cond_info, {[:then, *node_loc_infos] => true_branch.execution_count,
-                     [:else, *node_loc_infos] => false_branch.execution_count,
+        [cond_info, {[:then, *node_loc_infos(node_range)] => true_branch.execution_count,
+                     [:else, *node_loc_infos(node_range)] => false_branch.execution_count,
                     },
         ]
       end

data/lib/deep_cover/base.rb

@@ -13,14 +13,16 @@ module DeepCover
         # and that is not available in JRuby. An extension may be able to replace this requirement.
         # require_relative 'core_ext/autoload_overrides'
         # AutoloadOverride.active = true
+        require_relative 'core_ext/load_overrides'
         require_relative 'core_ext/require_overrides'
-        RequireOverride.active = true
+        LoadOverride.active = RequireOverride.active = true
       elsif RUBY_VERSION >= '2.3.0'
         require_relative 'core_ext/instruction_sequence_load_iseq'
       else
         require_relative 'core_ext/autoload_overrides'
+        require_relative 'core_ext/load_overrides'
         require_relative 'core_ext/require_overrides'
-        AutoloadOverride.active = RequireOverride.active = true
+        AutoloadOverride.active = LoadOverride.active = RequireOverride.active = true
         autoload_tracker.initialize_autoloaded_paths { |mod, name, path| mod.autoload_without_deep_cover(name, path) }
       end
 

data/lib/deep_cover/custom_requirer.rb

@@ -97,21 +97,23 @@ module DeepCover
       true
     end
 
-    ### Not currently used ###
     # Homemade #load to be able to instrument the code before it gets executed.
     # Note, this doesn't support the `wrap` parameter that ruby's #load has.
-    # Same return/throw as CustomRequirer#require, except:
-    # Cannot return false since #load doesn't care about a file already being executed.
+    # Same yield/return behavior as CustomRequirer#require, except that it
+    # cannot return false #load doesn't care about a file already being executed.
     def load(path) # &fallback_block
+      path = path.to_s
+
       found_path = resolve_path(path, nil)
 
       if found_path.nil?
-        # #load has a final fallback of always trying relative to current work directory of process
+        # #load has a final fallback of always trying relative to current work directory
         possible_path = File.absolute_path(path)
         found_path = possible_path if File.exist?(possible_path)
       end
 
       return yield(:not_found) unless found_path
+      return yield(:not_in_covered_paths) unless DeepCover.within_lookup_paths?(found_path)
 
       cover_and_execute(found_path) { |reason| return yield(reason) }
 

data/lib/deep_cover/parser_ext/range.rb

@@ -5,16 +5,16 @@ class Parser::Source::Range
     adjust(begin_pos: +1, end_pos: +1)
   end
 
-  def wrap_rwhitespace
-    whitespace = @source_buffer.slice(end_pos..-1)[/\A\s+/] || ''
+  def wrap_rwhitespace(whitespaces: /\A\s+/)
+    whitespace = @source_buffer.slice(end_pos..-1)[whitespaces] || ''
     adjust(end_pos: whitespace.size)
   end
 
-  def wrap_rwhitespace_and_comments
-    current = wrap_rwhitespace
+  def wrap_rwhitespace_and_comments(whitespaces: /\A\s+/)
+    current = wrap_rwhitespace(whitespaces: whitespaces)
     while @source_buffer.slice(current.end_pos) == '#'
       comment = @source_buffer.slice(current.end_pos..-1)[/\A[^\n]+/] || ''
-      current = current.adjust(end_pos: comment.size).wrap_rwhitespace
+      current = current.adjust(end_pos: comment.size).wrap_rwhitespace(whitespaces: whitespaces)
     end
     current
   end

data/lib/deep_cover/tools/builtin_coverage.rb

@@ -6,10 +6,14 @@ module DeepCover
       require 'coverage'
       filename = File.absolute_path(File.expand_path(filename))
       ::Coverage.start
-      Tools.silence_warnings do
-        execute_sample -> { run_with_line_coverage(source, filename, lineno) }
+      begin
+        Tools.silence_warnings do
+          execute_sample -> { run_with_line_coverage(source, filename, lineno) }
+        end
+      ensure
+        result = ::Coverage.result
       end
-      unshift_coverage(::Coverage.result.fetch(filename), lineno)
+      unshift_coverage(result.fetch(filename), lineno)
     end
 
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'

data/lib/deep_cover/tools/scan_match_datas.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Tools::RequireRelativeDir
+    # Like String#scan, but return the MatchData object instead
+    def scan_match_datas(source, matcher)
+      source.to_enum(:scan, matcher).map { Regexp.last_match }
+    end
+  end
+end

data/lib/deep_cover/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepCover
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deep-cover
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Marc-André Lafortune
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-02 00:00:00.000000000 Z
+date: 2018-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -383,6 +383,7 @@ files:
 - lib/deep_cover/tools/profiling.rb
 - lib/deep_cover/tools/render_template.rb
 - lib/deep_cover/tools/require_relative_dir.rb
+- lib/deep_cover/tools/scan_match_datas.rb
 - lib/deep_cover/tools/silence_warnings.rb
 - lib/deep_cover/tools/slice.rb
 - lib/deep_cover/tools/strip_heredoc.rb