deep-cover-core 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26469b9b1a015b36a11d432d22d871647ba060fc272c4edd274175d7163dcceb
-  data.tar.gz: 51917845e6fdcc9e073e776fc13cade71a82d7f0806a01d36e1b653c52ee8b5f
+  metadata.gz: 51497f0cad911b1a78dac991b6b89f800c5cc1b0c7b99e8502816d02842ca239
+  data.tar.gz: 932a187d2d0669c5e21a82f81b1f7337db27d077d4ab07a9b92596721731862e
 SHA512:
-  metadata.gz: fd179008eefe481fdcd29f5857228fda6cf1b364b027694309ca40e664a548be13ba404d168d3d1f34e7749b7d037f9d70a4cfaa11450615ccec4d7aa615a6c2
-  data.tar.gz: bc452e18b3ec005229d4c889c5396cffa2ddadb1daa9cd4132f9e66b126be6d2a305b76d54718e1fcea5c8f548ef4e6e518620a221c8712298bc318f4068b1ea
+  metadata.gz: dbdc66591ef576cd5f3ad7dc0898b1746d3b1f3a5670490ea67a49a7773d200ae717029aa40b5b41359b8c67dff889aa118e7a5ef9e02e224f3c2a31cabc8372
+  data.tar.gz: e52c1575a8b86dd3ea5c908407a8efcbfa1ab3a0618d0b621384d1cb004143dba4e54a0464ac98030a59a8ba62f27119cbae6ef65e8cd51c07546cbd39970ae7

data/deep_cover_core.gemspec

@@ -39,8 +39,10 @@ Gem::Specification.new do |spec|
 
   ### Dev dependencies
   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.53.0' # About every single release breaks something
+
+  # About every single release breaks something
+  # Ruby 2.1 is no longer supported
+  spec.add_development_dependency 'rubocop', '0.61.1' if RUBY_VERSION >= '2.2.0'
 end

data/lib/deep_cover/analyser/branch.rb

@@ -30,8 +30,7 @@ module DeepCover
 
     def worst_branch_runs(fork)
       fork.branches.map { |jump| branch_runs(jump) }
-          .sort_by { |runs| runs == 0 ? -2 : runs || -1 }
-          .first
+          .min_by { |runs| runs == 0 ? -2 : runs || -1 }
     end
 
     def branch_runs(branch)

data/lib/deep_cover/analyser/node.rb

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

data/lib/deep_cover/analyser/ruby25_like_branch.rb

@@ -55,11 +55,11 @@ module DeepCover
         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 = whens.map { |w| wrap_rwhitespace_and_comments_if_ruby25(w.loc_hash[:begin] || w.loc_hash[:expression]).end }
         empty_fallbacks.map!(&:begin)
 
         if loc_hash[:else]
-          empty_fallbacks << loc_hash[:end].begin
+          empty_fallbacks << wrap_rwhitespace_and_comments_if_ruby25(loc_hash[:else]).end
         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
@@ -86,7 +86,7 @@ module DeepCover
 
       def handle_csend
         # csend wraps the comment but not the newlines
-        node_range = node.expression.wrap_rwhitespace_and_comments(whitespaces: /\A[ \t\r\f]+/)
+        node_range = wrap_rwhitespace_and_comments_if_ruby25(node.expression, whitespaces: /\A[ \t\r\f]+/)
         cond_info = [:"&.", *node_loc_infos(node_range)]
         false_branch, true_branch = branches
         [cond_info, {[:then, *node_loc_infos(node_range)] => true_branch.execution_count,
@@ -105,22 +105,19 @@ module DeepCover
         if style == :ternary
           empty_fallback_locs = [nil, nil]
         else
+          first_clause_fallback = wrap_rwhitespace_and_comments_if_ruby25(loc_hash[:begin]) if loc_hash[:begin]
+          first_clause_fallback ||= wrap_rwhitespace_and_comments_if_ruby25(condition.expression)
+          # Ruby26 wraps the comments but only on the same line
+          # No need for condition since Ruby25 wraps all of them
+          first_clause_fallback = first_clause_fallback.wrap_final_comment.end
           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
+            second_clause_fallback = wrap_rwhitespace_and_comments_if_ruby25(else_loc).end
+          elsif !modifier?
+            second_clause_fallback = root_if_node.loc_hash[:end].begin
           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]
+          empty_fallback_locs = [first_clause_fallback, second_clause_fallback]
         end
         # loc can be nil if the clause can't be empty, such as ternary and modifer if/unless
 
@@ -131,6 +128,25 @@ module DeepCover
 
         branches_locs = branches
         execution_counts = branches_locs.map(&:execution_count)
+        if modifier?
+          branches_locs = branches_locs.map do |branch|
+            if branch.is_a?(Node::Kwbegin)
+              if branch.instructions.empty?
+                wrap_rwhitespace_and_comments_if_ruby25(branch.loc_hash[:begin]).end
+              elsif branch.instructions.first.is_a?(Node::Ensure)
+                # Kernel.binding.pry
+                end_pos = wrap_rwhitespace_and_comments_if_ruby25(branch.instructions.last.expression).end_pos
+                wrap_rwhitespace_and_comments_if_ruby25(branch.loc_hash[:begin]).end.with(end_pos: end_pos)
+              else
+                end_pos = branch.instructions.last.expression.end_pos
+                branch.loc_hash[:begin].wrap_rwhitespace_and_comments.end.with(end_pos: end_pos)
+              end
+            else
+              branch
+            end
+          end
+        end
+
         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)
@@ -153,11 +169,13 @@ module DeepCover
                         end_pos = body.instructions.last.expression.end_pos
                         body.instructions.first.expression.with(end_pos: end_pos)
                       else
-                        body.loc_hash[:end].begin
+                        wrap_rwhitespace_and_comments_if_ruby25(body.loc_hash[:begin]).end
                       end
-                    elsif body.is_a?(Node::Begin) && !node.body.expressions.empty?
+                    elsif body.is_a?(Node::Begin) && !body.expressions.empty?
                       end_pos = body.expressions.last.expression.end_pos
                       body.expressions.first.expression.with(end_pos: end_pos)
+                    elsif body.is_a?(Node::EmptyBody)
+                      wrap_rwhitespace_and_comments_if_ruby25(condition.loc_hash[:expression]).end
                     else
                       body
                     end
@@ -167,13 +185,12 @@ module DeepCover
 
       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
+      # If the actual else clause (final one) of an if...elsif...end is empty, then Ruby25 wraps the final whitespace
       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)
+          return wrap_rwhitespace_and_comments_if_ruby25(possible_elsif.expression)
         end
         possible_elsif
       end
@@ -206,6 +223,14 @@ module DeepCover
         @loc_index += 1
         [@loc_index, source_range.line, source_range.column, source_range.last_line, source_range.last_column]
       end
+
+      def wrap_rwhitespace_and_comments_if_ruby25(expression, whitespaces: /\A\s+/)
+        if RUBY_VERSION.start_with?('2.5')
+          expression.wrap_rwhitespace_and_comments(whitespaces: whitespaces)
+        else
+          expression
+        end
+      end
     end
   end
 end

data/lib/deep_cover/autoload_tracker.rb

@@ -45,34 +45,44 @@ module DeepCover
       autoloads && !autoloads.empty?
     end
 
-    def wrap_require(requested_path, absolute_path_found) # &block
-      entries = entries_for_target(requested_path, absolute_path_found)
-
-      begin
-        entries.each do |entry|
-          mod = entry.mod_if_available
-          next unless mod
-          mod.autoload_without_deep_cover(entry.name, already_loaded_feature)
-        end
-
+    if RUBY_PLATFORM == 'java'
+      # JRuby dislikes that we change the autoload as it is executing an autoload
+      # Things seems to work when we do nothing special
+      def wrap_require(requested_path, absolute_path_found) # &block
         yield
-      ensure
+      end
+    else
+      def wrap_require(requested_path, absolute_path_found) # &block
         entries = entries_for_target(requested_path, absolute_path_found)
-        entries.each do |entry|
-          mod = entry.mod_if_available
-          next unless mod
-          # Putting the autoloads back back since we couldn't complete the require
-          mod.autoload_without_deep_cover(entry.name, entry.interceptor_path)
+
+        begin
+          entries.each do |entry|
+            mod = entry.mod_if_available
+            next unless mod
+            mod.autoload_without_deep_cover(entry.name, already_loaded_feature)
+          end
+
+          yield
+        ensure
+          entries = entries_for_target(requested_path, absolute_path_found)
+          entries.each do |entry|
+            mod = entry.mod_if_available
+            next unless mod
+            # Putting the autoloads back back since we couldn't complete the require
+            mod.autoload_without_deep_cover(entry.name, entry.interceptor_path)
+          end
         end
       end
     end
 
-    # This is only used on MRI, so ObjectSpace is alright.
+    # In JRuby, ObjectSpace.each_object is allowed for Module and Class, so we are good.
     def initialize_autoloaded_paths(mods = ObjectSpace.each_object(Module)) # &do_autoload_block
       mods.each do |mod|
         # Module's constants are shared with Object. But if you set autoloads directly on Module, they
         # appear on multiple classes. So just skip, Object will take care of those.
         next if mod == Module
+        # This happens with JRuby
+        next unless mod.respond_to?(:constants)
 
         if mod.frozen?
           if mod.constants.any? { |name| mod.autoload?(name) }
@@ -82,7 +92,10 @@ module DeepCover
         end
 
         mod.constants.each do |name|
-          path = mod.autoload?(name)
+          # JRuby can talk about deprecated constants here
+          path = Tools.silence_warnings do
+            mod.autoload?(name)
+          end
           next unless path
           interceptor_path = setup_interceptor_for(mod, name, path)
           yield mod, name, interceptor_path

data/lib/deep_cover/base.rb

@@ -8,15 +8,7 @@ module DeepCover
 
     def start
       return if running?
-      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-        # Autoload is not supported in JRuby. We currently need to use binding_of_caller
-        # 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'
-        LoadOverride.active = RequireOverride.active = true
-      elsif RUBY_VERSION >= '2.3.0'
+      if RUBY_VERSION >= '2.3.0' && RUBY_PLATFORM != 'java'
         require_relative 'core_ext/instruction_sequence_load_iseq'
       else
         require_relative 'core_ext/autoload_overrides'

data/lib/deep_cover/core_ext/autoload_overrides.rb

@@ -84,10 +84,27 @@ module DeepCover
   load_all
 
   module KernelAutoloadOverride
-    def autoload(name, path)
-      mod = binding.of_caller(1).eval('Module.nesting').first || Object
-      autoload_path = DeepCover.autoload_tracker.autoload_path_for(mod, name, path)
-      mod.autoload_without_deep_cover(name, autoload_path)
+    if RUBY_PLATFORM == 'java'
+      # JRuby has different semantics for Kernel.autoload and Kernel#autoload
+      def autoload(name, path)
+        if Kernel.equal?(self)
+          # Yeah, this is weird
+          # https://github.com/jruby/jruby/issues/5466
+          mod = Object.singleton_class
+        elsif self.is_a?(Module)
+          mod = self
+        else
+          mod = self.class
+        end
+        autoload_path = DeepCover.autoload_tracker.autoload_path_for(mod, name, path)
+        mod.autoload_without_deep_cover(name, autoload_path)
+      end
+    else
+      def autoload(name, path)
+        mod = binding.of_caller(1).eval('Module.nesting').first || Object
+        autoload_path = DeepCover.autoload_tracker.autoload_path_for(mod, name, path)
+        mod.autoload_without_deep_cover(name, autoload_path)
+      end
     end
 
     extend ModuleOverride

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -20,7 +20,10 @@ module DeepCover
         else
           targets = targets.to_hash.slice(*ALL_COVERAGES.keys).select { |_, v| v }
           targets = targets.map { |k, v| [k, !!v] }.to_h
-          raise 'no measuring target is specified' if targets.empty?
+          if targets.empty?
+            raise 'no measuring target is specified' if RUBY_VERSION.start_with?('2.5')
+            targets = OLD_COVERAGE_SENTINEL
+          end
         end
 
         if DeepCover.running?

data/lib/deep_cover/core_ext/exec_callbacks.rb

@@ -5,7 +5,7 @@
 # THERE MUST NOT BE ANY USE/REQUIRE OF DEPENDENCIES OF DeepCover HERE
 # See deep-cover/core_gem/lib/deep_cover/setup/clone_mode_entry_template.rb for explanation of
 # clone mode and of this top_level_module stuff.
-top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object
 
 # Adds a functionality to add callbacks before an `exec`
 

data/lib/deep_cover/custom_requirer.rb

@@ -43,7 +43,11 @@ module DeepCover
 
       if path == abs_path
         paths_with_ext.each do |path_with_ext|
-          return path_with_ext if File.exist?(path_with_ext)
+          next unless File.exist?(path_with_ext)
+
+          # https://github.com/jruby/jruby/issues/5465
+          path_with_ext = File.realpath(path_with_ext) if RUBY_PLATFORM == 'java' && JRUBY_VERSION >= '9.2.5'
+          return path_with_ext
         end
       else
         possible_paths = paths_with_load_paths(paths_with_ext)
@@ -74,6 +78,7 @@ module DeepCover
     # Exceptions raised by the required code bubble up as normal, except for
     # SyntaxError, which is turned into a :cover_failed which calls the fallback_block.
     def require(path) # &fallback_block
+      raise 'Should receive the fallback_block' unless block_given?
       path = path.to_s
 
       found_path = resolve_path(path)
@@ -109,6 +114,7 @@ module DeepCover
     # 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
+      raise 'Should receive the fallback_block' unless block_given?
       path = path.to_s
 
       found_path = resolve_path(path, try_extensions: false)

data/lib/deep_cover/global_variables.rb

@@ -5,7 +5,7 @@
 # THERE MUST NOT BE ANY USE/REQUIRE OF DEPENDENCIES OF DeepCover HERE
 # See deep-cover/core_gem/lib/deep_cover/setup/clone_mode_entry_template.rb for explanation of
 # clone mode and of this top_level_module stuff.
-top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object
 
 module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
   module GlobalVariables

data/lib/deep_cover/load.rb

@@ -21,8 +21,9 @@ module DeepCover
       Object.autoload :Forwardable, 'forwardable'
       Object.autoload :YAML, 'yaml'
 
-      # In ruby 2.2 and less, autoload doesn't work for gems which are not already on the `$LOAD_PATH`.
+      # In ruby 2.2 and in JRuby, autoload doesn't work for gems which are not already on the `$LOAD_PATH`.
       # The fix is to just require right away for those rubies
+      # JRuby issue asking for this to be changed: https://github.com/jruby/jruby/issues/5403
       #
       # Low-level: autoload not working for gems not on the `$LOAD_PATH` is because those rubies don't
       # call the regular `#require` when triggering an autoload, and the gem system monkey-patches `#require`
@@ -32,7 +33,7 @@ module DeepCover
        Term: 'term/ansicolor',
        Terminal: 'terminal-table',
       }.each do |const, require_path|
-        if RUBY_VERSION < '2.3'
+        if RUBY_VERSION < '2.3' || RUBY_PLATFORM == 'java'
           require require_path
         else
           Object.autoload const, require_path

data/lib/deep_cover/node/block.rb

@@ -49,7 +49,7 @@ module DeepCover
       alias_method :rewrite_for_completion, :rewrite
       def rewrite
         if call.is_a?(Csend)
-          rewrite_for_completion.gsub('%{node}', Csend::REWRITE_SUFFIX)
+          rewrite_for_completion.gsub('%{node}', Csend::REWRITE_SUFFIX_IN_BLOCK)
         else
           rewrite_for_completion
         end

data/lib/deep_cover/node/if.rb

@@ -67,6 +67,10 @@ module DeepCover
       def has_else?
         !!base_node.loc.to_hash[:else]
       end
+
+      def modifier?
+        loc_hash[:keyword] && root_if_node.loc_hash[:end].nil?
+      end
     end
   end
 end

data/lib/deep_cover/node/send.rb

@@ -77,7 +77,7 @@ module DeepCover
 
       def rewrite
         # All the rest of the rewriting logic is in Csend
-        '%{node};%{completion_tracker};' unless has_block?
+        '%{node});%{completion_tracker};' unless has_block?
       end
 
       def flow_completion_count
@@ -98,23 +98,21 @@ module DeepCover
       #    temp = *receiver*;
       #    if nil != temp
       #      TRACK_my_NOT_NIL
-      #      temp = temp&.*actual_send*{block}
+      #      temp = (temp&.*actual_send*{block})
       #      TRACK_actual_send_COMPLETION
-      #      t
-      #    else
-      #      nil
+      #      temp
       #    end
       # This is split across the children and the CsendInnerSend
       include Branch
       has_tracker :not_nil
       has_child receiver: Node,
-                rewrite: '(%{local}=%{node};if nil != %{local};%{not_nil_tracker};%{local}=%{local}'
-      REWRITE_SUFFIX = '%{node};%{local};else;nil;end)'
+                rewrite: '(%{local}=%{node};if nil != %{local};%{not_nil_tracker};%{local}=(%{local}'
+      REWRITE_SUFFIX_IN_BLOCK = '%{node});%{local};end)'
 
       has_child actual_send: {safe_send: CsendInnerSend},
                 flow_entry_count: :not_nil_tracker_hits
 
-      def initialize(base_node, base_children: base_node.children, **) # rubocop:disable Naming/UncommunicativeMethodParamName [#5436]
+      def initialize(base_node, base_children: base_node.children, **)
         send_without_receiver = base_node.updated(:safe_send, [nil, *base_node.children.drop(1)])
         base_children = [base_children.first, send_without_receiver]
         super
@@ -130,7 +128,7 @@ module DeepCover
       end
 
       def rewrite
-        REWRITE_SUFFIX unless has_block?
+        '%{node};%{local};end)' unless has_block?
       end
 
       def execution_count

data/lib/deep_cover/parser_ext/range.rb

@@ -18,4 +18,16 @@ class Parser::Source::Range
     end
     current
   end
+
+  # Only wraps anything if there is a comment to wrap on the last line
+  # Will wrap the whitespace before the comment
+  def wrap_final_comment
+    current = wrap_rwhitespace(whitespaces: /\A[ \t\r\f]+/)
+    if @source_buffer.slice(current.end_pos) != '#'
+      # No comment, do nothing
+      return self
+    end
+    comment = @source_buffer.slice(current.end_pos..-1)[/\A[^\n]+/] || ''
+    current.adjust(end_pos: comment.size)
+  end
 end

data/lib/deep_cover/persistence.rb

@@ -5,7 +5,7 @@
 # THERE MUST NOT BE ANY USE/REQUIRE OF DEPENDENCIES OF DeepCover HERE
 # See deep-cover/core_gem/lib/deep_cover/setup/clone_mode_entry_template.rb for explanation of
 # clone mode and of this top_level_module stuff.
-top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object
 
 module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
   require 'securerandom'

data/lib/deep_cover/reporter/istanbul.rb

@@ -98,12 +98,12 @@ module DeepCover
         end
 
         # Istanbul doesn't understand how to ignore a branch...
-        def zero_to_something(values)
+        def nil_to_something(values)
           values.map { |v| v || 1 }
         end
 
         def branch_runs
-          branches.values.map { |r| zero_to_something(r.values) }
+          branches.values.map { |r| nil_to_something(r.values) }
         end
 
         def statement_map

data/lib/deep_cover/tools/after_tests.rb

@@ -5,7 +5,7 @@
 # THERE MUST NOT BE ANY USE/REQUIRE OF DEPENDENCIES OF DeepCover HERE
 # See deep-cover/core_gem/lib/deep_cover/setup/clone_mode_entry_template.rb for explanation of
 # clone mode and of this top_level_module stuff.
-top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object
 
 module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
   module Tools

data/lib/deep_cover/tools/builtin_coverage.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'tempfile'
+
 module DeepCover
   module Tools::BuiltinCoverage
     def builtin_coverage(source, filename, lineno)
@@ -8,7 +10,7 @@ module DeepCover
       ::Coverage.start
       begin
         Tools.silence_warnings do
-          execute_sample -> { run_with_line_coverage(source, filename, lineno) }
+          execute_sample -> { filename = run_with_line_coverage(source, filename, lineno) }
         end
       ensure
         result = ::Coverage.result
@@ -16,30 +18,21 @@ module DeepCover
       unshift_coverage(result.fetch(filename), lineno)
     end
 
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      # Executes the source as if it was in the specified file while
-      # builtin coverage information is still captured
-      def run_with_line_coverage(source, filename = nil, lineno = 1)
-        source = shift_source(source, lineno)
-        Object.to_java.getRuntime.executeScript(source, filename)
-      end
-    else
-      # In ruby 2.0 and 2.1, using 2, 3 or 4 as lineno with RubyVM::InstructionSequence.compile
-      # will cause the coverage result to be truncated.
-      # 1: [1,2,nil,1]
-      # 2: [nil,1,2,nil]
-      # 3: [nil,nil,1,2]
-      # 4: [nil,nil,nil,1]
-      # 5: [nil,nil,nil,nil,1,2,nil,1]
-      # Using 1 and 5 or more do not seem to show this issue.
-      # The workaround is to create the fake lines manually and always use the default lineno
+    def run_with_line_coverage(source, filename = '<code>', lineno = 1)
+      source = shift_source(source, lineno)
+      f = Tempfile.new(['ruby', '.rb'])
+      f.write(source)
+      f.close
 
-      # Executes the source as if it was in the specified file while
-      # builtin coverage information is still captured
-      def run_with_line_coverage(source, filename = nil, lineno = 1)
-        source = shift_source(source, lineno)
-        RubyVM::InstructionSequence.compile(source, filename).eval
+      begin
+        require f.path
+      rescue StandardError => e
+        tempfile_matcher = Regexp.new("\\A#{Regexp.escape(f.path)}(?=:\\d)")
+        e.backtrace.each { |l| l.sub!(tempfile_matcher, filename) }
+        raise
       end
+      $LOADED_FEATURES.delete(f.path)
+      f.path
     end
 
     private

data/lib/deep_cover/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-top_level_module = Thread.current['_deep_cover_top_level_module'] || Object # rubocop:disable Lint/UselessAssignment
+top_level_module = Thread.current['_deep_cover_top_level_module'] || Object
 
 module top_level_module::DeepCover # rubocop:disable Naming/ClassAndModuleCamelCase
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deep-cover-core
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Marc-André Lafortune
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-20 00:00:00.000000000 Z
+date: 2018-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -109,20 +109,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.15'
-- !ruby/object:Gem::Dependency
-  name: psych
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -157,14 +143,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.53.0
+        version: 0.61.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.53.0
+        version: 0.61.1
 description: Core functionality for the DeepCover gem.
 email:
 - github@marc-andre.ca
@@ -325,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: In depth coverage of your Ruby code.