simplecov 0.15.1 → 0.18.0.beta1

data/lib/simplecov/simulate_coverage.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Responsible for producing file coverage metrics.
+  #
+  module SimulateCoverage
+  module_function
+
+    #
+    # Simulate normal file coverage report on
+    # ruby 2.5 and return similar hash with lines and branches keys
+    #
+    # Happens when a file wasn't required but still tracked.
+    #
+    # @return [Hash]
+    #
+    def call(absolute_path)
+      lines = File.foreach(absolute_path)
+
+      {
+        :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 => {}
+      }
+    end
+  end
+end

data/lib/simplecov/source_file.rb

@@ -1,88 +1,24 @@
+# frozen_string_literal: true
+
 module SimpleCov
   #
   # Representation of a source file including it's coverage data, source code,
   # source lines and featuring helpers to interpret that data.
   #
   class SourceFile
-    # Representation of a single line in a source file including
-    # this specific line's source code, line_number and code coverage,
-    # with the coverage being either nil (coverage not applicable, e.g. comment
-    # line), 0 (line not covered) or >1 (the amount of times the line was
-    # executed)
-    class Line
-      # The source code for this line. Aliased as :source
-      attr_reader :src
-      # The line number in the source file. Aliased as :line, :number
-      attr_reader :line_number
-      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
-      attr_reader :coverage
-      # Whether this line was skipped
-      attr_reader :skipped
-
-      # Lets grab some fancy aliases, shall we?
-      alias source src
-      alias line line_number
-      alias number line_number
-
-      def initialize(src, line_number, coverage)
-        raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
-        raise ArgumentError, "Only Integer accepted for line_number" unless line_number.is_a?(Integer)
-        raise ArgumentError, "Only Integer and nil accepted for coverage" unless coverage.is_a?(Integer) || coverage.nil?
-        @src         = src
-        @line_number = line_number
-        @coverage    = coverage
-        @skipped     = false
-      end
-
-      # Returns true if this is a line that should have been covered, but was not
-      def missed?
-        !never? && !skipped? && coverage.zero?
-      end
-
-      # Returns true if this is a line that has been covered
-      def covered?
-        !never? && !skipped? && coverage > 0
-      end
-
-      # Returns true if this line is not relevant for coverage
-      def never?
-        !skipped? && coverage.nil?
-      end
-
-      # Flags this line as skipped
-      def skipped!
-        @skipped = true
-      end
-
-      # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
-      # # :nocov: comment lines.
-      def skipped?
-        !!skipped
-      end
-
-      # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
-      # as a css class in report generation
-      def status
-        return "skipped" if skipped?
-        return "never" if never?
-        return "missed" if missed?
-        return "covered" if covered?
-      end
-    end
-
     # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
     attr_reader :filename
     # The array of coverage data received from the Coverage.result
     attr_reader :coverage
 
     def initialize(filename, coverage)
-      @filename = filename
+      @filename = filename.to_s
       @coverage = coverage
     end
 
     # The path to this source file relative to the projects directory
     def project_filename
-      @filename.sub(/^#{SimpleCov.root}/, "")
+      @filename.sub(Regexp.new("^#{Regexp.escape(SimpleCov.root)}"), "")
     end
 
     # The source code for this file. Aliased as :source
@@ -100,19 +36,68 @@ module SimpleCov
     end
     alias source_lines lines
 
-    def build_lines
-      coverage_exceeding_source_warn if coverage.size > src.size
+    # Returns all covered lines as SimpleCov::SourceFile::Line
+    def covered_lines
+      @covered_lines ||= lines.select(&:covered?)
+    end
 
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
+    def missed_lines
+      @missed_lines ||= lines.select(&:missed?)
+    end
+
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
+    def never_lines
+      @never_lines ||= lines.select(&:never?)
+    end
+
+    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+    def skipped_lines
+      @skipped_lines ||= lines.select(&:skipped?)
+    end
+
+    # Returns the number of relevant lines (covered + missed)
+    def lines_of_code
+      covered_lines.size + missed_lines.size
+    end
+
+    def build_lines
+      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[i - 1])
+        SimpleCov::SourceFile::Line.new(src, i, coverage[:lines][i - 1])
       end
-
       process_skipped_lines(lines)
     end
 
+    # no_cov_chunks is zero indexed to work directly with the array holding the lines
+    def no_cov_chunks
+      @no_cov_chunks ||= build_no_cov_chunks
+    end
+
+    def build_no_cov_chunks
+      no_cov_lines = src.map.with_index(1).select { |line, _index| LinesClassifier.no_cov_line?(line) }
+
+      warn "uneven number of nocov comments detected" if no_cov_lines.size.odd?
+
+      no_cov_lines.each_slice(2).map do |(_line_start, index_start), (_line_end, index_end)|
+        index_start..index_end
+      end
+    end
+
+    def process_skipped_lines(lines)
+      # the array the lines are kept in is 0-based whereas the line numbers in the nocov
+      # chunks are 1-based and are expected to be like this in other parts (and it's also
+      # arguably more understandable)
+      no_cov_chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
+
+      lines
+    end
+
     # Warning to identify condition from Issue #56
     def coverage_exceeding_source_warn
-      $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.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
@@ -120,7 +105,7 @@ module SimpleCov
       lines[number - 1]
     end
 
-    # The coverage for this file in percent. 0 if the file has no relevant lines
+    # The coverage for this file in percent. 0 if the file has no coverage lines
     def covered_percent
       return 100.0 if no_lines?
 
@@ -132,7 +117,7 @@ module SimpleCov
     def covered_strength
       return 0.0 if relevant_lines.zero?
 
-      round_float(lines_strength / relevant_lines.to_f, 1)
+      (lines_strength / relevant_lines.to_f).round(1)
     end
 
     def no_lines?
@@ -147,55 +132,182 @@ module SimpleCov
       lines.size - never_lines.size - skipped_lines.size
     end
 
-    # Returns all covered lines as SimpleCov::SourceFile::Line
-    def covered_lines
-      @covered_lines ||= lines.select(&:covered?)
+    #
+    # Return all the branches inside current source file
+    def branches
+      @branches ||= build_branches
     end
 
-    # Returns all lines that should have been, but were not covered
-    # as instances of SimpleCov::SourceFile::Line
-    def missed_lines
-      @missed_lines ||= lines.select(&:missed?)
+    def no_branches?
+      total_branches.empty?
     end
 
-    # Returns all lines that are not relevant for coverage as
-    # SimpleCov::SourceFile::Line instances
-    def never_lines
-      @never_lines ||= lines.select(&:never?)
+    def branches_coverage_percent
+      return 100.0 if no_branches?
+      return 0.0 if covered_branches.empty?
+
+      Float(covered_branches.size * 100.0 / total_branches.size.to_f)
     end
 
-    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
-    def skipped_lines
-      @skipped_lines ||= lines.select(&:skipped?)
+    #
+    # Return the relevant branches to source file
+    def total_branches
+      covered_branches + missed_branches
     end
 
-    # Returns the number of relevant lines (covered + missed)
-    def lines_of_code
-      covered_lines.size + missed_lines.size
+    #
+    # Return hash with key of line number and branch coverage count as value
+    def branches_report
+      @branches_report ||= build_branches_report
     end
 
-    # Will go through all source files and mark lines that are wrapped within # :nocov: comment blocks
-    # as skipped.
-    def process_skipped_lines(lines)
-      skipping = false
-
-      lines.each do |line|
-        if line.src =~ SimpleCov::LinesClassifier.no_cov_line
-          skipping = !skipping
-          line.skipped!
-        elsif skipping
-          line.skipped!
-        end
+    ## Related to source file branches statistics
+
+    #
+    # Call recursive method that transform our static hash to array of objects
+    # @return [Array]
+    #
+    def build_branches
+      coverage_branch_data = coverage.fetch(:branches, {})
+      branches = coverage_branch_data.flat_map do |condition, coverage_branches|
+        build_branches_from(condition, coverage_branches)
       end
+
+      process_skipped_branches(branches)
     end
 
-  private
+    def process_skipped_branches(branches)
+      return branches if no_cov_chunks.empty?
+
+      branches.each do |branch|
+        branch.skipped! if no_cov_chunks.any? { |no_cov_chunk| branch.overlaps_with?(no_cov_chunk) }
+      end
+
+      branches
+    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).
+    #
+    # 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.
+    #
+    # See #801
+    #
+    def restore_ruby_data_structure(structure)
+      # Tests use the real data structures (except for integration tests) so no need to
+      # 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
+      # rubocop:enable Security/Eval
+    end
 
-    # ruby 1.9 could use Float#round(places) instead
-    # @return [Float]
-    def round_float(float, places)
-      factor = Float(10 * places)
-      Float((float * factor).round / factor)
+    def build_branches_from(condition, branches)
+      # the format handed in from the coverage data is like this:
+      #
+      #     [: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)
+
+      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) }
+    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
+
+      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
+      )
+    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
+    # else that is not in declared inside the code but given by default by coverage report
+    #
+    # @return [Array]
+    #
+    def covered_branches
+      @covered_branches ||= branches.select(&:covered?)
+    end
+
+    #
+    # Select the missed branches with coverage equal to zero
+    #
+    # @return [Array]
+    #
+    def missed_branches
+      @missed_branches ||= branches.select(&:missed?)
+    end
+
+    def branches_for_line(line_number)
+      branches_report.fetch(line_number, [])
+    end
+
+    #
+    # Check if any branches missing on given line number
+    #
+    # @param [Integer] line_number
+    #
+    # @return [Boolean]
+    #
+    def line_with_missed_branch?(line_number)
+      branches_for_line(line_number).select { |count, _sign| count.zero? }.any?
+    end
+
+    #
+    # Build full branches report
+    # Root branches represent the wrapper of all condition state that
+    # have inside the branches
+    #
+    # @return [Hash]
+    #
+    def build_branches_report
+      branches.reject(&:skipped?).each_with_object({}) do |branch, coverage_statistics|
+        coverage_statistics[branch.report_line] ||= []
+        coverage_statistics[branch.report_line] << branch.report
+      end
     end
   end
 end

data/lib/simplecov/source_file/branch.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    #
+    # 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
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(start_line:, end_line:, coverage:, inline:, positive:)
+        @start_line = start_line
+        @end_line   = end_line
+        @coverage   = coverage
+        @inline     = inline
+        @positive   = positive
+        @skipped    = false
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def inline?
+        @inline
+      end
+
+      def positive?
+        @positive
+      end
+
+      #
+      # Branch is negative
+      #
+      # @return [Boolean]
+      #
+      def negative?
+        !positive?
+      end
+
+      #
+      # Return true if there is relevant count defined > 0
+      #
+      # @return [Boolean]
+      #
+      def covered?
+        !skipped? && coverage.positive?
+      end
+
+      #
+      # Check if branche missed or not
+      #
+      # @return [Boolean]
+      #
+      def missed?
+        !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
+      # at if/else) because that
+      # * highlights the condition
+      # * makes it distinguishable if the first line of the branch is an inline branch
+      #   (see the nested_branches fixture)
+      #
+      def report_line
+        if inline?
+          start_line
+        else
+          start_line - 1
+        end
+      end
+
+      # Flags the branch as skipped
+      def skipped!
+        @skipped = true
+      end
+
+      # Returns true if the branch was marked skipped by virtue of nocov comments.
+      def skipped?
+        @skipped
+      end
+
+      def overlaps_with?(line_range)
+        start_line <= line_range.end && end_line >= line_range.begin
+      end
+
+      #
+      # Return array with coverage count and badge
+      #
+      # @return [Array]
+      #
+      def report
+        [coverage, badge]
+      end
+    end
+  end
+end