simplecov 0.18.0.beta1 → 0.18.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd6ab6b1c33e8b2503dc00691a8ae500ae0caf885fc2dba52bbe102d696d926
-  data.tar.gz: 41c70724c0beb18bd66f665cb078a8b9cf95d1dbb770bf1eb0601156c12370e0
+  metadata.gz: eeee06c5cbeaf6c89000a43641f7a6163d9b267d145698e742089385eae6e2b8
+  data.tar.gz: 76e7182adc3c8156e021d780618733f6237a81723656f0123b51abf34a63e891
 SHA512:
-  metadata.gz: ba1dcb50ce7ef6765a9f519bda006388d587c67cd103bcf6d0f4bd4d4427ebef240de13772e8925f62d70dd232310bd705b66fbda1c39c25444dcd329b9dedc1
-  data.tar.gz: cc1160ba31aa5ecdcb46a255e3147e78f649789d542d1363343fec803ec9c5c96759272990ba67ceb75a0a07116325f962a69354d8a01477a905b491bba86275
+  metadata.gz: e5e785e01ff4bf53c9cbdbeaeb7cc5925265e2ec9cacecb9865261150eed13b8c59c43d840588eb6baa0565ce510c74891f535f02bb1db42d2eeea4e61b3cd54
+  data.tar.gz: d8f29ed7d8ecf8a01d9fcd843a0c2a9845f022a690c8c7096c23077f7e3c2488fce290e099e70083ee44e37d1bb05f1535c2ec1a70b6952929ab92857b38a339

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+0.18.0.beta2 (unreleased)
+===================
+
+## Enhancements
+* only turn on the requested coverage criteria (when activating branch coverage before SimpleCov would also instruct Ruby to take Method coverage)
+* Change how branch coverage is displayed, now it's `branch_type: hit_count` which should be more self explanatory. See [#830](https://github.com/colszowka/simplecov/pull/830) for an example and feel free to give feedback!
+* Allow early running exit tasks and avoid the `at_exit` hook through the `SimpleCov.run_exit_tasks!` method. (thanks [@macumber]: https://github.com/macumber))
+* Allow manual collation of result sets through the `SimpleCov.collate` entrypoint. See the README for more details (thanks [@ticky](https://github.com/ticky))
+* Within `case`, even if there is no `else` branch declared show missing coverage for it (aka no branch of it). See [#825](https://github.com/colszowka/simplecov/pull/825)
+* Stop symbolizing all keys when loading cache (should lead to be faster and consume less memory)
+* Cache whether we can use/are using branch coverage (should be slightly faster)
+
+## Bugfixes
+* Fix a crash that happened when an old version of our internal cache file `.resultset.json` was still present
+
 0.18.0.beta1 (2020-01-05)
 ===================
 
@@ -8,7 +23,7 @@ This release is still beta because we'd love for you to test out branch coverage
 On a personal note from [@PragTob](https://github.com/PragTob/) thanks to [ruby together](https://rubytogether.org/) for sponsoring this work on SimpleCov making it possible to deliver this and subsequent releases.
 
 ## Breaking
-* Dropped official support for all EOL'ed rubies meaning we only officially support 2.4+ - older rubies might still work but are not guaranteed to do so. Older release should still work. (thanks [@deivid-rodriguez](https://github.com/deivid-rodriguez))
+* Dropped support for all EOL'ed rubies meaning we only support 2.4+. Simplecov can no longer be installed on older rubies, but older simplecov releases should still work. (thanks [@deivid-rodriguez](https://github.com/deivid-rodriguez))
 * Dropped the `rake simplecov` task that "magically" integreated with rails. It was always undocumented, caused some issues and [had some issues](https://github.com/colszowka/simplecov/issues/689#issuecomment-561572327). Use the integration as described in the README please :)
 
 ## Enhancements

data/README.md

@@ -170,6 +170,17 @@ to use SimpleCov with them. Here's an overview of the known ones:
       <a href="https://github.com/colszowka/simplecov/pull/185">#185</a>
     </td>
   </tr>
+  <tr>
+    <th>
+      knapsack_pro
+    </th>
+    <td>
+      To make SimpleCov work with Knapsack Pro Queue Mode to split tests in parallel on CI jobs you need to provide CI node index number to the <code>SimpleCov.command_name</code> in <code>KnapsackPro::Hooks::Queue.before_queue</code> hook.
+    </td>
+    <td>
+      <a href="https://knapsackpro.com/faq/question/how-to-use-simplecov-in-queue-mode">Tip</a>
+    </td>
+  </tr>
   <tr>
     <th>
       RubyMine
@@ -308,12 +319,16 @@ return if number.odd?
 ```
 
 If all the code in that method was covered you'd never know if the guard clause was ever
-triggered with line coverage as just evaluating the condition marks it as covered.
+triggered! With line coverage as just evaluating the condition marks it as covered.
+
+In the HTML report the lines of code will be annotated like `branch_type: hit_count`:
 
-In the HTML report the lines of code will be annotated like `hit_count, positive_or_negative_branch`:
+* `then: 2` - the then branch (of an `if`) was executed twice
+* `else: 0` - the else branch (of an `if` or `case`) was never executed
 
-* `2, +` - the positive branch was executed twice
-* `0, -` - the negative branch was never executed
+Not that even if you don't declare an `else` branch it will still show up in the coverage
+reports meaning that the condition of the `if` was not hit or that no `when` of `case`
+was hit during the test runs.
 
 **Is branch coverage strictly better?** No. Branch coverage really only concerns itself with
 conditionals - meaning coverage of sequential code is of no interest to it. A file without
@@ -461,12 +476,11 @@ end
 
 You normally want to have your coverage analyzed across ALL of your test suites, right?
 
-Simplecov automatically caches coverage results in your (coverage_path)/.resultset.json. Those results will then
-be automatically merged when generating the result, so when coverage is set up properly for Cucumber and your
-unit / functional / integration tests, all of those test suites will be taken into account when building the
-coverage report.
-
-There are two things to note here though:
+Simplecov automatically caches coverage results in your
+(coverage_path)/.resultset.json, and will merge or override those with
+subsequent runs, depending on whether simplecov considers those subsequent runs
+as different test suites or as the same test suite as the cached results. To
+make this distinction, simplecov has the concept of "test suite names".
 
 ### Test suite names
 
@@ -520,14 +534,84 @@ SimpleCov.command_name "features" + (ENV['TEST_ENV_NUMBER'] || '')
 
 [simplecov-html] prints the used test suites in the footer of the generated coverage report.
 
-### Timeout for merge
 
-Of course, your cached coverage data is likely to become invalid at some point. Thus, result sets that are older than
-`SimpleCov.merge_timeout` will not be used any more. By default, the timeout is 600 seconds (10 minutes), and you can
-raise (or lower) it by specifying `SimpleCov.merge_timeout 3600` (1 hour), or, inside a configure/start block, with
-just `merge_timeout 3600`.
+### Merging test runs under the same execution environment
+
+Test results are automatically merged with previous runs in the same execution
+environment when generating the result, so when coverage is set up properly for
+Cucumber and your unit / functional / integration tests, all of those test
+suites will be taken into account when building the coverage report.
 
-You can deactivate merging altogether with `SimpleCov.use_merging false`.
+#### Timeout for merge
+
+Of course, your cached coverage data is likely to become invalid at some point. Thus, when automatically merging
+subsequent test runs, result sets that are older than `SimpleCov.merge_timeout` will not be used any more. By default,
+the timeout is 600 seconds (10 minutes), and you can raise (or lower) it by specifying `SimpleCov.merge_timeout 3600`
+(1 hour), or, inside a configure/start block, with just `merge_timeout 3600`.
+
+You can deactivate this automatic merging altogether with `SimpleCov.use_merging false`.
+
+### Merging test runs under different execution environments
+
+If your tests are done in parallel across multiple build machines, you can fetch them all and merge them into a single
+result set using the `SimpleCov.collate` method. This can be added to a Rakefile or script file, having downloaded a set of
+`.resultset.json` files from each parallel test run.
+
+```ruby
+# lib/tasks/coverage_report.rake
+namespace :coverage do
+  desc "Collates all result sets generated by the different test runners"
+  task :report do
+    require 'simplecov'
+
+    SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
+  end
+end
+```
+
+`SimpleCov.collate` also takes an optional simplecov profile and an optional
+block for configuration, just the same as `SimpleCov.start` or
+`SimpleCov.configure`.  This means you can configure a separate formatter for
+the collated output. For instance, you can make the formatter in
+`SimpleCov.start` the `SimpleCov::Formatter::SimpleFormatter`, and only use more
+complex formatters in the final `SimpleCov.collate` run.
+
+```ruby
+# spec/spec_helper.rb
+require 'simplecov'
+
+SimpleCov.start 'rails' do
+  # Disambiguates individual test runs
+  command_name "Job #{ENV["TEST_ENV_NUMBER"]}" if ENV["TEST_ENV_NUMBER"]
+
+  if ENV['CI']
+    formatter SimpleCov::Formatter::SimpleFormatter
+  else
+    formatter SimpleCov::Formatter::MultiFormatter.new([
+      SimpleCov::Formatter::SimpleFormatter,
+      SimpleCov::Formatter::HTMLFormatter
+    ])
+  end
+
+  track_files "**/*.rb"
+end
+```
+
+```ruby
+# lib/tasks/coverage_report.rake
+namespace :coverage do
+  task :report do
+    require 'simplecov'
+
+    SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
+      formatter SimpleCov::Formatter::MultiFormatter.new([
+        SimpleCov::Formatter::SimpleFormatter,
+        SimpleCov::Formatter::HTMLFormatter
+      ])
+    end
+  end
+end
+```
 
 ## Running coverage only on demand
 

data/lib/simplecov.rb

@@ -46,13 +46,48 @@ module SimpleCov
     #
     def start(profile = nil, &block)
       require "coverage"
-      load_profile(profile) if profile
-      configure(&block) if block_given?
+      initial_setup(profile, &block)
       @result = nil
-      self.running = true
       self.pid = Process.pid
 
-      start_coverage_measurment
+      start_coverage_measurement
+    end
+
+    #
+    # Collate a series of SimpleCov result files into a single SimpleCov output.
+    # You can optionally specify configuration with a block:
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do
+    #     add_filter 'test'
+    #   end
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
+    #     add_filter 'test'
+    #   end
+    #
+    # Please check out the RDoc for SimpleCov::Configuration to find about
+    # available config options, or checkout the README for more in-depth
+    # information about coverage collation
+    #
+    def collate(result_filenames, profile = nil, &block)
+      raise "There's no reports to be merged" if result_filenames.empty?
+
+      initial_setup(profile, &block)
+
+      results = result_filenames.flat_map do |filename|
+        # Re-create each included instance of SimpleCov::Result from the stored run data.
+        (JSON.parse(File.read(filename)) || {}).map do |command_name, coverage|
+          SimpleCov::Result.from_hash(command_name => coverage)
+        end
+      end
+
+      # Use the ResultMerger to produce a single, merged result, ready to use.
+      @result = SimpleCov::ResultMerger.merge_and_store(*results)
+
+      run_exit_tasks!
     end
 
     #
@@ -159,6 +194,8 @@ module SimpleCov
     # Called from at_exit block
     #
     def run_exit_tasks!
+      set_exit_exception
+
       exit_status = SimpleCov.exit_status_from_exception
 
       SimpleCov.at_exit.call
@@ -170,7 +207,7 @@ module SimpleCov
       # Force exit with stored status (see github issue #5)
       # unless it's nil or 0 (see github issue #281)
       if exit_status&.positive?
-        $stderr.printf("SimpleCov failed with exit %<exit_status>d\n", :exit_status => exit_status) if print_error_status
+        $stderr.printf("SimpleCov failed with exit %<exit_status>d\n", exit_status: exit_status) if print_error_status
         Kernel.exit exit_status
       end
     end
@@ -197,25 +234,25 @@ module SimpleCov
       if covered_percent < SimpleCov.minimum_coverage
         $stderr.printf(
           "Coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-          :covered => covered_percent,
-          :minimum_coverage => SimpleCov.minimum_coverage
+          covered: covered_percent,
+          minimum_coverage: SimpleCov.minimum_coverage
         )
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file }
         $stderr.printf(
           "File (%<file>s) is only (%<least_covered_percentage>.2f%%) covered. This is below the expected minimum coverage per file of (%<min_coverage>.2f%%).\n",
-          :file => result.least_covered_file,
-          :least_covered_percentage => covered_percentages.min,
-          :min_coverage => SimpleCov.minimum_coverage_by_file
+          file: result.least_covered_file,
+          least_covered_percentage: covered_percentages.min,
+          min_coverage: SimpleCov.minimum_coverage_by_file
         )
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       elsif (last_run = SimpleCov::LastRun.read)
-        coverage_diff = last_run["result"]["covered_percent"] - covered_percent
+        coverage_diff = last_run[:result][:covered_percent] - covered_percent
         if coverage_diff > SimpleCov.maximum_coverage_drop
           $stderr.printf(
             "Coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
-            :drop_percent => coverage_diff,
-            :max_drop => SimpleCov.maximum_coverage_drop
+            drop_percent: coverage_diff,
+            max_drop: SimpleCov.maximum_coverage_drop
           )
           SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
         else
@@ -248,18 +285,24 @@ module SimpleCov
     # @api private
     #
     def write_last_run(covered_percent)
-      SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
+      SimpleCov::LastRun.write(result: {covered_percent: covered_percent})
     end
 
   private
 
+    def initial_setup(profile, &block)
+      load_profile(profile) if profile
+      configure(&block) if block_given?
+      self.running = true
+    end
+
     #
     # Trigger Coverage.start depends on given config coverage_criterion
     #
     # With Positive branch it supports all coverage measurement types
     # With Negative branch it supports only line coverage measurement type
     #
-    def start_coverage_measurment
+    def start_coverage_measurement
       # This blog post gives a good run down of the coverage criterias introduced
       # in Ruby 2.5: https://blog.bigbinary.com/2018/04/11/ruby-2-5-supports-measuring-branch-and-method-coverages.html
       # There is also a nice writeup of the different coverage criteria made in this
@@ -287,13 +330,29 @@ module SimpleCov
       # :oneshot_lines - can not be combined with lines
       # :all - same as lines + branches + methods
       #
-      if branch_coverage?
-        Coverage.start(:all)
+      if coverage_start_arguments_supported?
+        start_coverage_with_criteria
       else
         Coverage.start
       end
     end
 
+    def start_coverage_with_criteria
+      start_arguments = coverage_criteria.map do |criterion|
+        [lookup_corresponding_ruby_coverage_name(criterion), true]
+      end.to_h
+
+      Coverage.start(start_arguments)
+    end
+
+    CRITERION_TO_RUBY_COVERAGE = {
+      branch: :branches,
+      line: :lines
+    }.freeze
+    def lookup_corresponding_ruby_coverage_name(criterion)
+      CRITERION_TO_RUBY_COVERAGE.fetch(criterion)
+    end
+
     #
     # Finds files that were to be tracked but were not loaded and initializes
     # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).

data/lib/simplecov/combine/files_combiner.rb

@@ -15,10 +15,9 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        {
-          :lines => Combine.combine(LinesCombiner, coverage_a[:lines], coverage_b[:lines]),
-          :branches => Combine.combine(BranchesCombiner, coverage_a[:branches], coverage_b[:branches])
-        }
+        combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
+        combination["branches"] = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"]) if SimpleCov.branch_coverage?
+        combination
       end
     end
   end

data/lib/simplecov/combine/results_combiner.rb

@@ -20,30 +20,70 @@ module SimpleCov
       # @return [Hash]
       #
       def combine(*results)
-        results.reduce({}) do |result, next_result|
-          combine_result_sets(result, next_result)
+        results.reduce({}) do |combined_results, next_result|
+          combine_result_sets(combined_results, next_result)
         end
       end
 
       #
       # Manage combining results on files level
       #
-      # @param [Hash] result_a
-      # @param [Hash] result_b
+      # @param [Hash] combined_results
+      # @param [Hash] result
       #
       # @return [Hash]
       #
-      def combine_result_sets(result_a, result_b)
-        results_files = result_a.keys | result_b.keys
+      def combine_result_sets(combined_results, result)
+        unless correct_format?(result)
+          warn_wrong_format
+          return combined_results
+        end
+
+        results_files = combined_results.keys | result.keys
 
-        results_files.each_with_object({}) do |file_name, combined_results|
-          combined_results[file_name] = combine_file_coverage(
-            result_a[file_name],
-            result_b[file_name]
+        results_files.each_with_object({}) do |file_name, file_combination|
+          file_combination[file_name] = combine_file_coverage(
+            combined_results[file_name],
+            result[file_name]
           )
         end
       end
 
+      # We might start a run of a new simplecov version with a new format stored while
+      # there is still a recent file like this lying around. If it's recent enough (
+      # see merge_timeout) it will end up here. In order not to crash against this
+      # we need to do some basic checking of the format of data we expect and
+      # otherwise ignore it. See #820
+      #
+      # Currently correct format is:
+      # { file_path_string => {coverage_criterion => coverage_date}}
+      #
+      # Internal use/reliance only.
+      def correct_format?(result)
+        result.empty? || matches_current_format?(result)
+      end
+
+      def matches_current_format?(result)
+        # I so wish I could already use pattern matching
+        key, data = result.first
+
+        key.is_a?(String) && second_level_choice_of_criterion?(data)
+      end
+
+      SECOND_LEVEL_KEYS = %w[lines branches].freeze
+      def second_level_choice_of_criterion?(data)
+        second_level_key, = data.first
+
+        SECOND_LEVEL_KEYS.member?(second_level_key)
+      end
+
+      def warn_wrong_format
+        warn "Merging results, encountered an incorrectly formatted value. "\
+          "This value was ignored.\nIf you just upgraded simplecov this is "\
+          "likely due to a changed file format. If this happens again please "\
+          "file a bug. https://github.com/colszowka/simplecov/issues"
+      end
+
       #
       # Combine two files coverage results
       #

data/lib/simplecov/configuration.rb

@@ -313,7 +313,7 @@ module SimpleCov
     # * :line - coverage based on lines aka has this line been executed?
     # * :branch - coverage based on branches aka has this branch (think conditions) been executed?
     #
-    # If not set the default is is `:line`
+    # If not set the default is `:line`
     #
     # @param [Symbol] criterion
     #
@@ -335,15 +335,31 @@ module SimpleCov
       @coverage_criteria ||= Set[DEFAULT_COVERAGE_CRITERION]
     end
 
+    def coverage_criterion_enabled?(criterion)
+      coverage_criteria.member?(criterion)
+    end
+
+    def clear_coverage_criteria
+      @coverage_criteria = nil
+    end
+
     def branch_coverage?
-      branch_coverage_supported? && coverage_criteria.member?(:branch)
+      branch_coverage_supported? && coverage_criterion_enabled?(:branch)
     end
 
-    def branch_coverage_supported?
-      require "coverage"
-      !Coverage.method(:start).arity.zero?
+    def coverage_start_arguments_supported?
+      # safe to cache as within one process this value should never
+      # change
+      return @coverage_start_arguments_supported if defined?(@coverage_start_arguments_supported)
+
+      @coverage_start_arguments_supported = begin
+        require "coverage"
+        !Coverage.method(:start).arity.zero?
+      end
     end
 
+    alias branch_coverage_supported? coverage_start_arguments_supported?
+
   private
 
     def raise_if_criterion_unsupported(criterion)

data/lib/simplecov/defaults.rb

@@ -25,7 +25,9 @@ at_exit do
   # If we are in a different process than called start, don't interfere.
   next if SimpleCov.pid != Process.pid
 
-  SimpleCov.set_exit_exception
+  # If SimpleCov is no longer running then don't run exit tasks
+  next unless SimpleCov.running
+
   SimpleCov.run_exit_tasks!
 end
 

data/lib/simplecov/last_run.rb

@@ -15,7 +15,7 @@ module SimpleCov
         json = File.read(last_run_path)
         return nil if json.strip.empty?
 
-        JSON.parse(json)
+        JSON.parse(json, symbolize_names: true)
       end
 
       def write(json)

data/lib/simplecov/result.rb

@@ -28,7 +28,7 @@ module SimpleCov
     def initialize(original_result)
       @original_result = original_result.freeze
       @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage), :symbolize_names => true)) if File.file?(filename.to_s)
+        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
       end.compact.sort_by(&:filename))
       filter!
     end
@@ -61,35 +61,25 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
+      {
+        command_name => {
+          "coverage" => coverage,
+          "timestamp" => created_at.to_i
+        }
+      }
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       command_name, data = hash.first
 
-      result = SimpleCov::Result.new(
-        symbolize_names_of_coverage_results(data["coverage"])
-      )
+      result = SimpleCov::Result.new(data["coverage"])
 
       result.command_name = command_name
       result.created_at = Time.at(data["timestamp"])
       result
     end
 
-    # Manage symbolize the keys of coverage hash.
-    # JSON.parse gives coverage hash with stringified keys what breaks some logics
-    # inside the process that expects them as symboles.
-    #
-    # @return [Hash]
-    def self.symbolize_names_of_coverage_results(coverage_data)
-      coverage_data.each_with_object({}) do |(file_name, file_coverage_result), coverage_results|
-        coverage_results[file_name] = file_coverage_result.each_with_object({}) do |(k, v), cov_elem|
-          cov_elem[k.to_sym] = v
-        end
-      end
-    end
-
   private
 
     def coverage

data/lib/simplecov/result_adapter.rb

@@ -20,7 +20,7 @@ module SimpleCov
 
       result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
         if cover_statistic.is_a?(Array)
-          adapted_result.merge!(file_name => {:lines => cover_statistic})
+          adapted_result.merge!(file_name => {"lines" => cover_statistic})
         else
           adapted_result.merge!(file_name => cover_statistic)
         end

data/lib/simplecov/result_merger.rb

@@ -62,11 +62,17 @@ module SimpleCov
         results
       end
 
+      def merge_and_store(*results)
+        result = merge_results(*results)
+        store_result(result) if result
+        result
+      end
+
       # Merge two or more SimpleCov::Results into a new one with merged
       # coverage data and the command_name for the result consisting of a join
       # on all source result's names
       def merge_results(*results)
-        parsed_results = JSON.parse(JSON.dump(results.map(&:original_result)), :symbolize_names => true)
+        parsed_results = JSON.parse(JSON.dump(results.map(&:original_result)))
         combined_result = SimpleCov::Combine::ResultsCombiner.combine(*parsed_results)
         result = SimpleCov::Result.new(combined_result)
         # Specify the command name

data/lib/simplecov/simulate_coverage.rb

@@ -19,10 +19,10 @@ module SimpleCov
       lines = File.foreach(absolute_path)
 
       {
-        :lines => LinesClassifier.new.classify(lines),
+        "lines" => LinesClassifier.new.classify(lines),
         # we don't want to parse branches ourselves...
         # requiring files can have side effects and we don't want to trigger that
-        :branches => {}
+        "branches" => {}
       }
     end
   end

data/lib/simplecov/source_file.rb

@@ -12,7 +12,7 @@ module SimpleCov
     attr_reader :coverage
 
     def initialize(filename, coverage)
-      @filename = filename.to_s
+      @filename = filename
       @coverage = coverage
     end
 
@@ -64,9 +64,9 @@ module SimpleCov
     end
 
     def build_lines
-      coverage_exceeding_source_warn if coverage[:lines].size > src.size
+      coverage_exceeding_source_warn if coverage["lines"].size > src.size
       lines = src.map.with_index(1) do |src, i|
-        SimpleCov::SourceFile::Line.new(src, i, coverage[:lines][i - 1])
+        SimpleCov::SourceFile::Line.new(src, i, coverage["lines"][i - 1])
       end
       process_skipped_lines(lines)
     end
@@ -97,7 +97,7 @@ module SimpleCov
 
     # Warning to identify condition from Issue #56
     def coverage_exceeding_source_warn
-      warn "Warning: coverage data provided by Coverage [#{coverage[:lines].size}] exceeds number of lines in #{filename} [#{src.size}]"
+      warn "Warning: coverage data provided by Coverage [#{coverage['lines'].size}] exceeds number of lines in #{filename} [#{src.size}]"
     end
 
     # Access SimpleCov::SourceFile::Line source lines by line number
@@ -168,7 +168,7 @@ module SimpleCov
     # @return [Array]
     #
     def build_branches
-      coverage_branch_data = coverage.fetch(:branches, {})
+      coverage_branch_data = coverage.fetch("branches", {})
       branches = coverage_branch_data.flat_map do |condition, coverage_branches|
         build_branches_from(condition, coverage_branches)
       end
@@ -187,7 +187,7 @@ module SimpleCov
     end
 
     # Since we are dumping to and loading from JSON, and we have arrays as keys those
-    # don't make their way back to us intact e.g. just as a string or a symbol (currently keys are symbolized).
+    # don't make their way back to us intact e.g. just as a string
     #
     # We should probably do something different here, but as it stands these are
     # our data structures that we write so eval isn't _too_ bad.
@@ -199,9 +199,8 @@ module SimpleCov
       # put them through here.
       return structure if structure.is_a?(Array)
 
-      # as of right now the keys are still symbolized
       # rubocop:disable Security/Eval
-      eval structure.to_s
+      eval structure
       # rubocop:enable Security/Eval
     end
 
@@ -211,56 +210,26 @@ module SimpleCov
       #     [:then, 4, 6, 6, 6, 10]
       #
       # which is [type, id, start_line, start_col, end_line, end_col]
-      condition_type, condition_id, condition_start_line, * = restore_ruby_data_structure(condition)
+      _condition_type, _condition_id, condition_start_line, * = restore_ruby_data_structure(condition)
 
-      branches
-        .map { |branch_data, hit_count| [restore_ruby_data_structure(branch_data), hit_count] }
-        .reject { |branch_data, _hit_count| ignore_branch?(branch_data, condition_type, condition_start_line) }
-        .map { |branch_data, hit_count| build_branch(branch_data, hit_count, condition_start_line, condition_id) }
+      branches.map do |branch_data, hit_count|
+        branch_data = restore_ruby_data_structure(branch_data)
+        build_branch(branch_data, hit_count, condition_start_line)
+      end
     end
 
-    def build_branch(branch_data, hit_count, condition_start_line, condition_id)
-      type, id, start_line, _start_col, end_line, _end_col = branch_data
+    def build_branch(branch_data, hit_count, condition_start_line)
+      type, _id, start_line, _start_col, end_line, _end_col = branch_data
 
       SourceFile::Branch.new(
-        # rubocop these are keyword args please let me keep them, thank you
-        # rubocop:disable Style/HashSyntax
         start_line: start_line,
         end_line:   end_line,
         coverage:   hit_count,
         inline:     start_line == condition_start_line,
-        positive:   positive_branch?(condition_id, id, type)
-        # rubocop:enable Style/HashSyntax
+        type:       type
       )
     end
 
-    def ignore_branch?(branch_data, condition_type, condition_start_line)
-      branch_type = branch_data[0]
-      branch_start_line = branch_data[2]
-
-      # branch coverage always reports case to be with an else branch even when
-      # there is no else branch to be covered, it's noticable by the reported start
-      # line being the same as that of the condition/case
-      condition_type == :case &&
-        branch_type == :else &&
-        condition_start_line == branch_start_line
-    end
-
-    #
-    # Branch is positive or negative.
-    # For `case` conditions, `when` always supposed as positive branch.
-    # For `if, else` conditions:
-    # coverage returns matrices ex: [:if, 0,..] => {[:then, 1,..], [:else, 2,..]},
-    # positive branch always has id equals to condition id incremented by 1.
-    #
-    # @return [Boolean]
-    #
-    def positive_branch?(condition_id, branch_id, branch_type)
-      return true if branch_type == :when
-
-      branch_id == (1 + condition_id)
-    end
-
     #
     # Select the covered branches
     # Here we user tree schema because some conditions like case may have additional
@@ -293,7 +262,7 @@ module SimpleCov
     # @return [Boolean]
     #
     def line_with_missed_branch?(line_number)
-      branches_for_line(line_number).select { |count, _sign| count.zero? }.any?
+      branches_for_line(line_number).select { |_type, count| count.zero? }.any?
     end
 
     #

data/lib/simplecov/source_file/branch.rb

@@ -6,15 +6,15 @@ module SimpleCov
     # Representing single branch that has been detected in coverage report.
     # Give us support methods that handle needed calculations.
     class Branch
-      attr_reader :start_line, :end_line, :coverage
+      attr_reader :start_line, :end_line, :coverage, :type
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(start_line:, end_line:, coverage:, inline:, positive:)
+      def initialize(start_line:, end_line:, coverage:, inline:, type:)
         @start_line = start_line
         @end_line   = end_line
         @coverage   = coverage
         @inline     = inline
-        @positive   = positive
+        @type       = type
         @skipped    = false
       end
       # rubocop:enable Metrics/ParameterLists
@@ -23,19 +23,6 @@ module SimpleCov
         @inline
       end
 
-      def positive?
-        @positive
-      end
-
-      #
-      # Branch is negative
-      #
-      # @return [Boolean]
-      #
-      def negative?
-        !positive?
-      end
-
       #
       # Return true if there is relevant count defined > 0
       #
@@ -54,15 +41,6 @@ module SimpleCov
         !skipped? && coverage.zero?
       end
 
-      #
-      # Return the sign depends on branch is positive or negative
-      #
-      # @return [String]
-      #
-      def badge
-        positive? ? "+" : "-"
-      end
-
       # The line on which we want to report the coverage
       #
       # Usually we choose the line above the start of the branch (so that it shows up
@@ -99,7 +77,7 @@ module SimpleCov
       # @return [Array]
       #
       def report
-        [coverage, badge]
+        [type, coverage]
       end
     end
   end

data/lib/simplecov/useless_results_remover.rb

@@ -2,7 +2,7 @@
 
 module SimpleCov
   #
-  # Selection the files that related to working scope directory of SimpleCov
+  # Select the files that related to working scope directory of SimpleCov
   #
   module UselessResultsRemover
     ROOT_REGX = /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io.freeze

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "0.18.0.beta1"
+  VERSION = "0.18.0.beta2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.18.0.beta1
+  version: 0.18.0.beta2
 platform: ruby
 authors:
 - Christoph Olszowka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-05 00:00:00.000000000 Z
+date: 2020-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0.beta1
+        version: 0.11.0.beta2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0.beta1
+        version: 0.11.0.beta2
 description: Code coverage for Ruby with a powerful configuration library and automatic
   merging of coverage across test suites
 email:
@@ -95,9 +95,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/colszowka/simplecov/issues
   changelog_uri: https://github.com/colszowka/simplecov/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.18.0.beta1
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.18.0.beta2
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/colszowka/simplecov/tree/v0.18.0.beta1
+  source_code_uri: https://github.com/colszowka/simplecov/tree/v0.18.0.beta2
 post_install_message: 
 rdoc_options: []
 require_paths: