simplecov 0.22.0 → 1.1.1

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -2,25 +2,12 @@
 
 module SimpleCov
   module ExitCodes
-    class MinimumCoverageByFileCheck
-      def initialize(result, minimum_coverage_by_file)
-        @result = result
-        @minimum_coverage_by_file = minimum_coverage_by_file
-      end
-
-      def failing?
-        minimum_violations.any?
-      end
-
-      def report
-        minimum_violations.each do |violation|
-          $stderr.printf(
-            "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
-            criterion: violation.fetch(:criterion).capitalize
-          )
-        end
+    # Fails when any individual file falls below the configured minimum
+    # coverage for any criterion.
+    class MinimumCoverageByFileCheck < Check
+      def initialize(result, minimum_coverage_by_file, overrides = {})
+        super(result, minimum_coverage_by_file)
+        @overrides = overrides
       end
 
       def exit_code
@@ -29,25 +16,19 @@ module SimpleCov
 
     private
 
-      attr_reader :result, :minimum_coverage_by_file
-
-      def minimum_violations
-        @minimum_violations ||=
-          compute_minimum_coverage_data.select do |achieved|
-            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
-          end
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_by_file(result, thresholds, @overrides)
       end
 
-      def compute_minimum_coverage_data
-        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
-          result.coverage_statistics_by_file.fetch(criterion).map do |actual_coverage|
-            {
-              criterion: criterion,
-              minimum_expected: expected_percent,
-              actual: SimpleCov.round_coverage(actual_coverage.percent)
-            }
-          end
-        end
+      def report_violation(violation)
+        ExitCodes.print_error format(
+          "%<criterion>s coverage by file (%<actual>s) is below the expected minimum coverage " \
+          "(%<expected>.2f%%) in %<filename>s.",
+          criterion: violation.fetch(:criterion).capitalize,
+          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected),
+          filename: violation.fetch(:project_filename)
+        )
       end
     end
   end

data/lib/simplecov/exit_codes/minimum_coverage_by_group_check.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    # Fails when any configured group falls below its minimum coverage
+    # threshold for any criterion.
+    class MinimumCoverageByGroupCheck < Check
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_by_group(result, thresholds)
+      end
+
+      def report_violation(violation)
+        ExitCodes.print_error format(
+          "%<criterion>s coverage by group (%<actual>s) is below the expected minimum coverage " \
+          "(%<expected>.2f%%) in %<group_name>s.",
+          criterion: violation.fetch(:criterion).capitalize,
+          actual: SimpleCov::Color.colorize_percent(violation.fetch(:actual)),
+          expected: violation.fetch(:expected),
+          group_name: violation.fetch(:group_name)
+        )
+      end
+    end
+  end
+end

data/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -2,51 +2,55 @@
 
 module SimpleCov
   module ExitCodes
-    class MinimumOverallCoverageCheck
-      def initialize(result, minimum_coverage)
-        @result = result
-        @minimum_coverage = minimum_coverage
-      end
-
-      def failing?
-        minimum_violations.any?
-      end
-
-      def report
-        minimum_violations.each do |violation|
-          $stderr.printf(
-            "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
-            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
-            minimum_coverage: violation.fetch(:minimum_expected),
-            criterion: violation.fetch(:criterion).capitalize
-          )
-        end
-      end
-
+    # Fails when the overall (project-wide) coverage for any criterion is
+    # below the configured minimum.
+    class MinimumOverallCoverageCheck < Check
       def exit_code
         SimpleCov::ExitCodes::MINIMUM_COVERAGE
       end
 
     private
 
-      attr_reader :result, :minimum_coverage
+      WORST_FILES_LIMIT = 5
+      private_constant :WORST_FILES_LIMIT
+
+      def compute_violations
+        SimpleCov::CoverageViolations.minimum_overall(result, thresholds)
+      end
 
-      def minimum_violations
-        @minimum_violations ||= calculate_minimum_violations
+      def report_violation(violation)
+        criterion = violation.fetch(:criterion)
+        actual = violation.fetch(:actual)
+        ExitCodes.print_error format(
+          "%<criterion>s coverage (%<actual>s) is below the expected minimum coverage (%<expected>.2f%%).",
+          criterion: criterion.capitalize,
+          actual: SimpleCov::Color.colorize_percent(actual),
+          expected: violation.fetch(:expected)
+        )
+        report_worst_files(criterion)
       end
 
-      def calculate_minimum_violations
-        coverage_achieved = minimum_coverage.map do |criterion, percent|
-          {
-            criterion: criterion,
-            minimum_expected: percent,
-            actual: result.coverage_statistics.fetch(criterion).percent
-          }
+      def report_worst_files(criterion)
+        worst = worst_files_for(criterion)
+        return if worst.empty?
+
+        ExitCodes.print_error "  Lowest-coverage files (#{criterion}):"
+        worst.each do |path, percent|
+          ExitCodes.print_error format(
+            "    %<percent>s  %<path>s",
+            percent: SimpleCov::Color.colorize_percent(percent, format("%6.2f%%", percent)),
+            path: path
+          )
         end
+      end
 
-        coverage_achieved.select do |achieved|
-          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+      def worst_files_for(criterion)
+        stats_key = SimpleCov.coverage_statistics_key(criterion)
+        with_stats = result.files.filter_map do |source_file|
+          stats = source_file.coverage_statistics[stats_key]
+          [source_file.project_filename, stats.percent] if stats
         end
+        with_stats.sort_by { |_path, percent| percent }.first(WORST_FILES_LIMIT)
       end
     end
   end

data/lib/simplecov/exit_codes.rb

@@ -1,15 +1,35 @@
 # frozen_string_literal: true
 
 module SimpleCov
+  # Exit statuses SimpleCov sets when coverage checks fail, and the output
+  # helper the enforcement machinery reports through.
   module ExitCodes
     SUCCESS = 0
     EXCEPTION = 1
     MINIMUM_COVERAGE = 2
     MAXIMUM_COVERAGE_DROP = 3
+    MAXIMUM_COVERAGE = 4
+
+    # Threshold-violation reports and exit-status notices are the output of
+    # the enforcement feature, not Ruby warnings: routing them through
+    # `Kernel#warn` made `-W0` swallow the explanation for a failing exit
+    # code, let `Warning.warn` hooks (warning trackers, raise-on-warning
+    # test setups) intercept them mid-`at_exit`, and fed colorized text to
+    # warning logs. `print_errors false` remains the intended opt-out.
+    def self.print_error(message)
+      $stderr.puts message # rubocop:disable Style/StderrPuts
+    rescue IOError
+      # A parallel runner can close a worker's stderr before its at_exit
+      # hooks run (rspec-conductor does). The violation still has to set
+      # the exit status even when its explanation cannot be printed.
+    end
   end
 end
 
+require_relative "exit_codes/check"
 require_relative "exit_codes/exit_code_handling"
 require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/maximum_overall_coverage_check"
 require_relative "exit_codes/minimum_coverage_by_file_check"
+require_relative "exit_codes/minimum_coverage_by_group_check"
 require_relative "exit_codes/minimum_overall_coverage_check"

data/lib/simplecov/exit_handling.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "English"
+
+# `at_exit` orchestration: post-suite report generation, threshold
+# checks, deferral when a sibling subprocess already wrote a fresher
+# report, and exit-status propagation.
+module SimpleCov
+  class << self
+    # @api private
+    CoverageLimits = Data.define(
+      :minimum_coverage,
+      :minimum_coverage_by_file,
+      :minimum_coverage_by_file_overrides,
+      :minimum_coverage_by_group,
+      :maximum_coverage,
+      :maximum_coverage_drop
+    )
+
+    def at_exit_behavior
+      # If we are in a different process than called start, don't interfere.
+      return if SimpleCov.pid != Process.pid
+
+      # If Coverage is no longer running (e.g. someone manually stopped it
+      # or a test consumed the result) then don't run exit tasks.
+      return unless Coverage.running?
+
+      # Capture the suite's exit status BEFORE the deferral probe: its
+      # freshness check rescues filesystem errors, and completing any
+      # rescue inside an at_exit handler resets $ERROR_INFO to nil.
+      error_exit_status = exit_status_from_exception
+
+      # Stand down when we'd only clobber a fresher report (#581).
+      return if defer_to_existing_report?
+
+      SimpleCov.run_exit_tasks!(error_exit_status)
+    end
+
+    # @api private — called from the at_exit block (which pre-captures
+    # the status, see there) and by `collate` (the default argument).
+    def run_exit_tasks!(error_exit_status = exit_status_from_exception)
+      at_exit.call
+
+      exit_and_report_previous_error(error_exit_status) if previous_error?(error_exit_status)
+      process_results_and_report_error if ready_to_process_results?
+    end
+
+    # @api private — returns the exit status from the exit exception.
+    def exit_status_from_exception
+      @exit_exception = $ERROR_INFO
+      return nil unless @exit_exception
+
+      if @exit_exception.is_a?(SystemExit)
+        @exit_exception.status
+      else
+        SimpleCov::ExitCodes::EXCEPTION
+      end
+    end
+
+    # @api private — strict boolean so rspec-mocks 4's predicate matcher
+    # accepts it. test_unit sets status 0 on success, so SUCCESS must
+    # also be treated as "not a previous error".
+    def previous_error?(error_exit_status)
+      !!(error_exit_status && error_exit_status != SimpleCov::ExitCodes::SUCCESS)
+    end
+
+    # @api private
+    def exit_and_report_previous_error(exit_status)
+      if print_errors
+        ExitCodes.print_error SimpleCov::Color.colorize(
+          "Stopped processing SimpleCov as a previous error not related to SimpleCov has been detected",
+          :yellow
+        )
+      end
+      Kernel.exit(exit_status)
+    end
+
+    # @api private — the process that owns final merge processing is the
+    # only one that reports against thresholds, and only when its
+    # `wait_for_other_processes` confirmed every sibling reported.
+    # When the wait times out, the merged total is partial and
+    # comparing it against `minimum_coverage` / `maximum_coverage`
+    # would surface a spurious "below minimum" violation about the
+    # missing slice rather than a real shortfall.
+    def ready_to_process_results?
+      merge_finalization_owner? && result? &&
+        (collating_result? || parallel_results_complete?)
+    end
+
+    def process_results_and_report_error
+      exit_status = process_result(result)
+
+      # Force exit with stored status (see github issue #5)
+      return unless exit_status.positive?
+
+      if print_errors
+        ExitCodes.print_error SimpleCov::Color.colorize(
+          "SimpleCov failed with exit #{exit_status} due to a coverage related error", :red
+        )
+      end
+      Kernel.exit exit_status
+    end
+
+    # @api private — `exit_status = SimpleCov.process_result(SimpleCov.result)`.
+    def process_result(result)
+      result_exit_status = result_exit_status(result)
+      write_last_run(result) if result_exit_status == SimpleCov::ExitCodes::SUCCESS
+      result_exit_status
+    end
+
+    def result_exit_status(result)
+      ExitCodes::ExitCodeHandling.call(result, coverage_limits: build_coverage_limits)
+    end
+
+  private
+
+    def build_coverage_limits
+      CoverageLimits.new(
+        minimum_coverage: minimum_coverage,
+        minimum_coverage_by_file: minimum_coverage_by_file,
+        minimum_coverage_by_file_overrides: minimum_coverage_by_file_overrides,
+        minimum_coverage_by_group: minimum_coverage_by_group,
+        maximum_coverage: maximum_coverage,
+        maximum_coverage_drop: maximum_coverage_drop
+      )
+    end
+  end
+end

data/lib/simplecov/file_list.rb

@@ -23,8 +23,12 @@ module SimpleCov
       @files = files
     end
 
-    def coverage_statistics
-      @coverage_statistics ||= compute_coverage_statistics
+    # The per-criterion coverage statistics across all files. With no argument
+    # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
+    # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
+    def coverage_statistics(criterion = nil)
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
@@ -43,16 +47,12 @@ module SimpleCov
 
     # Returns the count of lines that are not relevant for coverage
     def never_lines
-      return 0.0 if empty?
-
-      map { |f| f.never_lines.count }.inject(:+)
+      sum { |f| f.never_lines.size }
     end
 
     # Returns the count of skipped lines
     def skipped_lines
-      return 0.0 if empty?
-
-      map { |f| f.skipped_lines.count }.inject(:+)
+      sum { |f| f.skipped_lines.size }
     end
 
     # Computes the coverage based upon lines covered and lines missed for each file
@@ -61,9 +61,13 @@ module SimpleCov
       map(&:covered_percent)
     end
 
-    # Finds the least covered file and returns that file's name
+    # Finds the least covered file and returns that file's name, or nil
+    # for an empty list (e.g. a fully filtered result).
     def least_covered_file
-      min_by(&:covered_percent).filename
+      # `covered_percent` is nil only for an unmeasured criterion, and :line
+      # is always measured, so the `|| 0.0` arm never fires at runtime; it
+      # exists to satisfy min_by's Comparable requirement.
+      min_by { |file| file.covered_percent || 0.0 }&.filename
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
@@ -71,16 +75,18 @@ module SimpleCov
       coverage_statistics[:line]&.total
     end
 
-    # Computes the coverage based upon lines covered and lines missed
-    # @return [Float]
-    def covered_percent
-      coverage_statistics[:line]&.percent
+    # The coverage across all files in percent, for the given criterion (line
+    # by default). Returns nil if the criterion was not measured.
+    # @return [Float, nil]
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
     end
 
-    # Computes the strength (hits / line) based upon lines covered and lines missed
-    # @return [Float]
-    def covered_strength
-      coverage_statistics[:line]&.strength
+    # The strength (average hits per relevant unit) for the given criterion
+    # (line by default).
+    # @return [Float, nil]
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
     end
 
     # Return total count of branches in all files
@@ -102,19 +108,59 @@ module SimpleCov
       coverage_statistics[:branch]&.percent
     end
 
+    # Return total count of methods in all files
+    def total_methods
+      coverage_statistics[:method]&.total
+    end
+
+    # Return total count of covered methods
+    def covered_methods
+      coverage_statistics[:method]&.covered
+    end
+
+    # Return total count of missed methods
+    def missed_methods
+      coverage_statistics[:method]&.missed
+    end
+
+    def method_covered_percent
+      coverage_statistics[:method]&.percent
+    end
+
   private
 
+    # Seed the result hash with one entry per criterion the user
+    # enabled — so an empty FileList (e.g. a group with no files) still
+    # yields the right shape — then fold each file's stats into the
+    # matching bucket. `SourceFile#coverage_statistics` always reports
+    # all three criteria; FileList is the layer that filters to the
+    # enabled set so disabled criteria don't surface in totals, JSON,
+    # or the HTML report.
     def compute_coverage_statistics_by_file
-      @files.each_with_object(line: [], branch: []) do |file, together|
-        together[:line] << file.coverage_statistics.fetch(:line)
-        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
+      seed = enabled_criteria_for_reporting.to_h do |criterion|
+        bucket = [] #: Array[CoverageStatistics]
+        [criterion, bucket]
+      end
+      @files.each_with_object(seed) do |file, together|
+        file.coverage_statistics.each do |criterion, stats|
+          together[criterion] << stats if together.key?(criterion)
+        end
       end
     end
 
     def compute_coverage_statistics
-      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
-      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
-      coverage_statistics
+      coverage_statistics_by_file.transform_values { |stats| CoverageStatistics.from(stats) }
+    end
+
+    # `:line` (or its `:oneshot_line` synonym) is reported when either
+    # criterion is enabled; the JRuby-gated branch/method criteria are
+    # reported when they pass their own engine-support check.
+    def enabled_criteria_for_reporting
+      criteria = [] #: Array[SimpleCov::criterion]
+      criteria << :line   if SimpleCov.line_coverage?
+      criteria << :branch if SimpleCov.branch_coverage?
+      criteria << :method if SimpleCov.method_coverage?
+      criteria
     end
   end
 end

data/lib/simplecov/filter.rb

@@ -3,11 +3,11 @@
 module SimpleCov
   #
   # Base filter class. Inherit from this to create custom filters,
-  # and overwrite the passes?(source_file) instance method
+  # and overwrite the matches?(source_file) instance method
   #
   # # A sample class that rejects all source files.
   # class StupidFilter < SimpleCov::Filter
-  #   def passes?(source_file)
+  #   def matches?(source_file)
   #     false
   #   end
   # end
@@ -20,52 +20,110 @@ module SimpleCov
     end
 
     def matches?(_source_file)
-      raise "The base filter class is not intended for direct use"
+      raise NotImplementedError, "The base filter class is not intended for direct use"
     end
 
-    def passes?(source_file)
-      warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
-      matches?(source_file)
+    # Whether this filter's verdict depends only on the file's path, so it can
+    # be decided before that file has any coverage. Used when recording which
+    # tracked files a process did not load, where no coverage exists yet.
+    # Defaults to false so a custom filter is never guessed at. See #1250.
+    def path_only?
+      false
     end
 
-    def self.build_filter(filter_argument)
-      return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
-
-      class_for_argument(filter_argument).new(filter_argument)
-    end
-
-    def self.class_for_argument(filter_argument)
+    # `string_filter` selects the semantics of bare String arguments —
+    # StringFilter's segment-substring match for `add_filter`/`skip`,
+    # GlobFilter for `cover` — and threads through Array elements so a
+    # list gets the same treatment as its members.
+    def self.build_filter(filter_argument, string_filter: SimpleCov::StringFilter)
       case filter_argument
-      when String
-        SimpleCov::StringFilter
-      when Regexp
-        SimpleCov::RegexFilter
+      when SimpleCov::Filter then filter_argument
+      when String            then string_filter.new(filter_argument)
       when Array
-        SimpleCov::ArrayFilter
-      when Proc
-        SimpleCov::BlockFilter
-      else
-        raise ArgumentError, "You have provided an unrecognized filter type"
+        SimpleCov::ArrayFilter.new(filter_argument.map { |arg| build_filter(arg, string_filter: string_filter) })
+      else class_for_argument(filter_argument).new(filter_argument)
       end
     end
+
+    def self.class_for_argument(filter_argument)
+      filter_classes_by_argument_type.find { |type, _| filter_argument.is_a?(type) }&.last ||
+        raise(SimpleCov::ConfigurationError, "You have provided an unrecognized filter type")
+    end
+
+    def self.filter_classes_by_argument_type
+      @filter_classes_by_argument_type ||= {
+        String => SimpleCov::StringFilter,
+        Regexp => SimpleCov::RegexFilter,
+        Array => SimpleCov::ArrayFilter,
+        Proc => SimpleCov::BlockFilter
+      }.freeze
+    end
+    private_class_method :filter_classes_by_argument_type
   end
 
+  # Filter that matches when the source file's project path contains the
+  # configured string at a path-segment boundary.
   class StringFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # string configured when initializing this Filter with StringFilter.new('somestring')
+    # string configured when initializing this Filter with StringFilter.new('somestring').
+    # Matching is path-segment-aware: the argument must appear immediately after a "/"
+    # and be followed by "/" or end-of-string, so "lib" matches "/lib/foo.rb" but not
+    # "/app/models/library.rb".
     def matches?(source_file)
-      source_file.project_filename.include?(filter_argument)
+      source_file.project_filename.match?(segment_pattern)
+    end
+
+    def path_only?
+      true
+    end
+
+  private
+
+    def segment_pattern
+      @segment_pattern ||= compute_segment_pattern
+    end
+
+    def compute_segment_pattern
+      normalized = filter_argument.delete_prefix("/")
+      escaped    = Regexp.escape(normalized)
+      boundary   = '(?:\A|/)'
+
+      if normalized.end_with?("/")
+        # Trailing slash signals directory-only matching.
+        /#{boundary}#{escaped}/
+      elsif normalized.include?(".") && !normalized.include?("/")
+        # Bare filename pattern (e.g. "test.rb" matches "faked_test.rb"):
+        # allow a substring match within a single path segment. Multi-segment
+        # arguments must not get this relaxation, or "app/models/user.rb"
+        # would also match "webapp/models/user.rb".
+        %r{#{boundary}[^/]*#{escaped}(?=[/.]|\z)}
+      else
+        # Directory or path: require a segment-boundary match so "lib"
+        # matches "lib/" but not "library/".
+        %r{#{boundary}#{escaped}(?=[/.]|\z)}
+      end
     end
   end
 
+  # Filter that matches when the source file's project path matches the
+  # configured Regexp.
   class RegexFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/).
+    # Uses `Regexp#match?` so the predicate returns a real boolean — `=~`
+    # would return the match position (an Integer or nil), which trips
+    # rspec-mocks 4's stricter predicate-matcher type check.
     def matches?(source_file)
-      (source_file.project_filename =~ filter_argument)
+      filter_argument.match?(source_file.project_filename)
+    end
+
+    def path_only?
+      true
     end
   end
 
+  # Filter that matches when the configured block returns truthy for the
+  # source file.
   class BlockFilter < SimpleCov::Filter
     # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
     # returns true for the given source file.
@@ -74,6 +132,22 @@ module SimpleCov
     end
   end
 
+  # Filter that matches when the source file's project path matches the
+  # configured shell glob (e.g. "lib/**/*.rb"). Used by `cover` and
+  # `skip` when callers want glob semantics instead of the substring
+  # match of `StringFilter`.
+  class GlobFilter < SimpleCov::Filter
+    def matches?(source_file)
+      File.fnmatch?(filter_argument, source_file.project_filename, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+    end
+
+    def path_only?
+      true
+    end
+  end
+
+  # Filter that matches when any of its component filters (built from the
+  # array's elements) match the source file.
   class ArrayFilter < SimpleCov::Filter
     def initialize(filter_argument)
       filter_objects = filter_argument.map do |arg|
@@ -83,6 +157,11 @@ module SimpleCov
       super(filter_objects)
     end
 
+    # Path-decidable only when every component filter is.
+    def path_only?
+      filter_argument.all?(&:path_only?)
+    end
+
     # Returns true if any of the filters in the array match the given source file.
     # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
     def matches?(source_files_list)