rspec-core 2.99.0 → 3.0.0

data/lib/rspec/core/filter_manager.rb

@@ -1,5 +1,6 @@
 module RSpec
   module Core
+    # @private
     # Manages the filtering of examples and groups by matching tags declared on
     # the command line or options files, or filters declared via
     # `RSpec.configure`, with hash key/values submitted within example group
@@ -66,175 +67,193 @@ module RSpec
     # @see Configuration#filter_run_including
     # @see Configuration#filter_run_excluding
     class FilterManager
-      class << self
-        def const_missing(name)
-          case name
-          when :DEFAULT_EXCLUSIONS
-            RSpec.deprecate("RSpec::Core::FilterManager::DEFAULT_EXCLUSIONS is deprecated")
-            default_exclusions
-          when :STANDALONE_FILTERS
-            RSpec.deprecate("RSpec::Core::FilterManager::STANDALONE_FILTERS is deprecated")
-            standalone_filters
-          else
-            super
-          end
-        end
+      attr_reader :exclusions, :inclusions
 
-        # @private
-        def default_exclusions
-          @default_exclusions ||= {
-            :if     => lambda { |value| !value },
-            :unless => lambda { |value| value }
-          }
-        end
+      def initialize
+        @exclusions, @inclusions = FilterRules.build
+      end
 
-        # @private
-        def standalone_filters
-          @standalone_filters ||= [:locations, :line_numbers, :full_description]
-        end
+      # @api private
+      #
+      # @param file_path [String]
+      # @param line_numbers [Array]
+      def add_location(file_path, line_numbers)
+        # locations is a hash of expanded paths to arrays of line
+        # numbers to match against. e.g.
+        #   { "path/to/file.rb" => [37, 42] }
+        locations = inclusions.delete(:locations) || Hash.new { |h,k| h[k] = [] }
+        locations[File.expand_path(file_path)].push(*line_numbers)
+        inclusions.add_location(locations)
       end
 
-      module Describable
-        PROC_HEX_NUMBER = /0x[0-9a-f]+\s?@/
-        PROJECT_DIR = File.expand_path('.')
+      def empty?
+        inclusions.empty? && exclusions.empty?
+      end
 
-        def description
-          reject { |k, v| RSpec::Core::FilterManager.default_exclusions[k] == v }.inspect.
-            gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','').gsub('__is_lambda__=true','')
+      def prune(examples)
+        if inclusions.standalone?
+          base_exclusions = ExclusionRules.new
+          examples.select {|e| !base_exclusions.include_example?(e) && include?(e) }
+        else
+          examples.select {|e| !exclude?(e) && include?(e)}
         end
+      end
 
-        def empty_without_conditional_filters?
-          RSpec.deprecate("(inclusion_filter | exclusion_filter)#empty_without_conditional_filters? is deprecated")
-          rules_empty?
-        end
+      def exclude(*args)
+        exclusions.add(args.last)
+      end
 
-        # @private
-        def rules_empty?
-          reject { |k, v| RSpec::Core::FilterManager.default_exclusions[k] == v }.empty?
-        end
+      def exclude_only(*args)
+        exclusions.use_only(args.last)
       end
 
-      module BackwardCompatibility
-        def merge(orig, opposite, *updates)
-          _warn_deprecated_keys(updates.last)
-          super
-        end
+      def exclude_with_low_priority(*args)
+        exclusions.add_with_low_priority(args.last)
+      end
 
-        def reverse_merge(orig, opposite, *updates)
-          _warn_deprecated_keys(updates.last)
-          super
-        end
+      def exclude?(example)
+        exclusions.include_example?(example)
+      end
 
-        # Supports a use case that probably doesn't exist: overriding the
-        # if/unless procs.
-        def _warn_deprecated_keys(updates)
-          _warn_deprecated_key(:unless, updates) if updates.has_key?(:unless)
-          _warn_deprecated_key(:if, updates)     if updates.has_key?(:if)
-        end
+      def include(*args)
+        inclusions.add(args.last)
+      end
 
-        # Emits a deprecation warning for keys that will not be supported in
-        # the future.
-        def _warn_deprecated_key(key, updates)
-          RSpec.deprecate("FilterManager#exclude(#{key.inspect} => #{updates[key].inspect})")
-          @exclusions[key] = updates.delete(key)
-        end
+      def include_only(*args)
+        inclusions.use_only(args.last)
       end
 
-      attr_reader :exclusions, :inclusions
+      def include_with_low_priority(*args)
+        inclusions.add_with_low_priority(args.last)
+      end
 
-      def initialize
-        @exclusions = self.class.default_exclusions.dup.extend(Describable)
-        @inclusions = {}.extend(Describable)
-        extend(BackwardCompatibility)
+      def include?(example)
+        inclusions.include_example?(example)
       end
+    end
 
-      def add_location(file_path, line_numbers)
-        # locations is a hash of expanded paths to arrays of line
-        # numbers to match against. e.g.
-        #   { "path/to/file.rb" => [37, 42] }
-        locations = @inclusions.delete(:locations) || Hash.new {|h,k| h[k] = []}
-        locations[File.expand_path(file_path)].push(*line_numbers)
-        @inclusions.replace(:locations => locations)
-        @exclusions.clear
+    # @private
+    class FilterRules
+      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+      PROJECT_DIR = File.expand_path('.')
+
+      attr_accessor :opposite
+      attr_reader :rules
+
+      def self.build
+        exclusions = ExclusionRules.new
+        inclusions = InclusionRules.new
+        exclusions.opposite = inclusions
+        inclusions.opposite = exclusions
+        [exclusions, inclusions]
       end
 
-      def empty?
-        inclusions.empty? && exclusions.rules_empty?
+      def initialize(*args, &block)
+        @rules = Hash.new(*args, &block)
       end
 
-      def prune(examples)
-        examples.select {|e| !exclude?(e) && include?(e)}
+      def add(updated)
+        @rules.merge!(updated).each_key { |k| opposite.delete(k) }
       end
 
-      def exclude(*args)
-        merge(@exclusions, @inclusions, *args)
+      def add_with_low_priority(_updated)
+        updated = _updated.merge(@rules)
+        opposite.each_pair { |k,v| updated.delete(k) if updated[k] == v }
+        @rules.replace(updated)
       end
 
-      def exclude!(*args)
-        RSpec.deprecate("FilterManager#exclude! is deprecated. Use FilterManager#exclude_only")
-        exclude_only(*args)
+      def use_only(updated)
+        updated.each_key { |k| opposite.delete(k) }
+        @rules.replace(updated)
       end
 
-      def exclude_only(*args)
-        replace(@exclusions, @inclusions, *args)
+      def clear
+        @rules.clear
       end
 
-      def exclude_with_low_priority(*args)
-        reverse_merge(@exclusions, @inclusions, *args)
+      def delete(key)
+        @rules.delete(key)
       end
 
-      def exclude?(example)
-        @exclusions.empty? ? false : example.any_apply?(@exclusions)
+      def fetch(*args, &block)
+        @rules.fetch(*args, &block)
       end
 
-      def include(*args)
-        unless_standalone(*args) { merge(@inclusions, @exclusions, *args) }
+      def [](key)
+        @rules[key]
       end
 
-      def include!(*args)
-        RSpec.deprecate("FilterManager#include! is deprecated. Use FilterManager#include_only")
-        include_only(*args)
+      def empty?
+        rules.empty?
       end
 
-      def include_only(*args)
-        unless_standalone(*args) { replace(@inclusions, @exclusions, *args) }
+      def each_pair(&block)
+        @rules.each_pair(&block)
       end
 
-      def include_with_low_priority(*args)
-        unless_standalone(*args) { reverse_merge(@inclusions, @exclusions, *args) }
+      def description
+        rules.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+      end
+    end
+
+    # @private
+    class InclusionRules < FilterRules
+      STANDALONE_FILTERS = [:locations, :full_description]
+
+      def add_location(locations)
+        replace_filters({ :locations => locations })
       end
 
-      def include?(example)
-        @inclusions.empty? ? true : example.any_apply?(@inclusions)
+      def add(*args)
+        set_standalone_filter(*args) || super
       end
 
-      private
+      def add_with_low_priority(*args)
+        set_standalone_filter(*args) || super
+      end
+
+      def use(*args)
+        set_standalone_filter(*args) || super
+      end
 
-      def unless_standalone(*args)
-        is_standalone_filter?(args.last) ? @inclusions.replace(args.last) : yield unless already_set_standalone_filter?
+      def include_example?(example)
+        @rules.empty? ? true : example.any_apply?(@rules)
       end
 
-      def merge(orig, opposite, *updates)
-        orig.merge!(updates.last).each_key {|k| opposite.delete(k)}
+      def standalone?
+        is_standalone_filter?(@rules)
       end
 
-      def replace(orig, opposite, *updates)
-        updates.last.each_key {|k| opposite.delete(k)}
-        orig.replace(updates.last)
+    private
+
+      def set_standalone_filter(updated)
+        return true if standalone?
+
+        if is_standalone_filter?(updated)
+          replace_filters(updated)
+          true
+        end
       end
 
-      def reverse_merge(orig, opposite, *updates)
-        updated = updates.last.merge(orig)
-        opposite.each_pair {|k,v| updated.delete(k) if updated[k] == v}
-        orig.replace(updated)
+      def replace_filters(new_rules)
+        @rules.replace(new_rules)
+        opposite.clear
       end
 
-      def already_set_standalone_filter?
-        is_standalone_filter?(inclusions)
+      def is_standalone_filter?(rules)
+        STANDALONE_FILTERS.any? { |key| rules.has_key?(key) }
       end
+    end
+
+    # @private
+    class ExclusionRules < FilterRules
+      CONDITIONAL_FILTERS = {
+        :if     => lambda { |value| !value },
+        :unless => lambda { |value| value }
+      }.freeze
 
-      def is_standalone_filter?(filter)
-        self.class.standalone_filters.any? {|key| filter.has_key?(key)}
+      def include_example?(example)
+        example.any_apply?(@rules) || example.any_apply?(CONDITIONAL_FILTERS)
       end
     end
   end

data/lib/rspec/core/flat_map.rb

@@ -0,0 +1,18 @@
+module RSpec
+  module Core
+    # @private
+    module FlatMap
+      if [].respond_to?(:flat_map)
+        def flat_map(array)
+          array.flat_map { |item| yield item }
+        end
+      else # for 1.8.7
+        def flat_map(array)
+          array.map { |item| yield item }.flatten
+        end
+      end
+
+      module_function :flat_map
+    end
+  end
+end

data/lib/rspec/core/formatters/base_formatter.rb

@@ -1,31 +1,28 @@
-require 'rspec/core/formatters/helpers'
+RSpec::Support.require_rspec_core "formatters/helpers"
 require 'stringio'
 
 module RSpec
   module Core
     module Formatters
       # RSpec's built-in formatters are all subclasses of RSpec::Core::Formatters::BaseTextFormatter,
-      # but the BaseTextFormatter documents all of the methods needed to be implemented by a formatter,
-      # as they are called from the reporter.
+      # but the BaseTextFormatter documents all of the notifications implemented as part of the standard
+      # interface. The reporter will issue these during a normal test suite run, but a formatter will
+      # only receive those notifications it has registered itself to receive.
       #
       # @see RSpec::Core::Formatters::BaseTextFormatter
       # @see RSpec::Core::Reporter
       class BaseFormatter
-        include Helpers
+
+        # all formatters inheriting from this formatter will receive these notifications
+        Formatters.register self, :start, :example_group_started, :close
         attr_accessor :example_group
-        attr_reader :duration, :examples, :output
-        attr_reader :example_count, :pending_count, :failure_count
-        attr_reader :failed_examples, :pending_examples
+        attr_reader :output
 
         # @api public
         #
-        # @param output
+        # @param output [IO] the formatter output
         def initialize(output)
           @output = output || StringIO.new
-          @example_count = @pending_count = @failure_count = 0
-          @examples = []
-          @failed_examples = []
-          @pending_examples = []
           @example_group = nil
         end
 
@@ -38,179 +35,124 @@ module RSpec
         # This will only be invoked once, and the next one to be invoked
         # is {#example_group_started}.
         #
-        # @param example_count
-        def start(example_count)
+        # @param notification [StartNotification]
+        def start(notification)
           start_sync_output
-          @example_count = example_count
+          @example_count = notification.count
         end
 
         # @api public
         #
         # This method is invoked at the beginning of the execution of each example group.
         #
-        # @param example_group subclass of `RSpec::Core::ExampleGroup`
-        #
         # The next method to be invoked after this is {#example_passed},
         # {#example_pending}, or {#example_group_finished}.
         #
-        # @param example_group
-        def example_group_started(example_group)
-          @example_group = example_group
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+        def example_group_started(notification)
+          @example_group = notification.group
         end
 
+        # @method example_group_finished
         # @api public
         #
         # Invoked at the end of the execution of each example group.
         #
-        # @param example_group subclass of `RSpec::Core::ExampleGroup`
-        def example_group_finished(example_group)
-        end
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
 
+        # @method example_started
         # @api public
         #
         # Invoked at the beginning of the execution of each example.
         #
-        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
-        # @return [Array]
-        def example_started(example)
-          examples << example
-        end
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
 
+        # @method example_passed
         # @api public
         #
         # Invoked when an example passes.
         #
-        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
-        def example_passed(example)
-        end
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
 
+        # @method example_pending
         # Invoked when an example is pending.
         #
-        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
-        # @return [Array]
-        def example_pending(example)
-          @pending_examples << example
-        end
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
 
+        # @method example_failed
         # @api public
         #
         # Invoked when an example fails.
         #
-        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
-        # @return [Array]
-        def example_failed(example)
-          @failed_examples << example
-        end
+        # @param notification [ExampleNotification] containing example subclass of `RSpec::Core::Example`
 
+        # @method message
         # @api public
         #
         # Used by the reporter to send messages to the output stream.
         #
-        # @param [String] message
-        def message(message)
-        end
+        # @param notification [MessageNotification] containing message
 
+        # @method stop
         # @api public
         #
         # Invoked after all examples have executed, before dumping post-run reports.
         #
-        # @return [nil]
-        def stop
-        end
+        # @param notification [NullNotification]
 
+        # @method start_dump
         # @api public
         #
         # This method is invoked after all of the examples have executed. The next method
         # to be invoked after this one is {#dump_failures}
         # (BaseTextFormatter then calls {#dump_failure} once for each failed example.)
         #
-        # @return [nil]
-        def start_dump
-        end
+        # @param notification [NullNotification]
 
+        # @method dump_failures
         # @api public
         #
         # Dumps detailed information about each example failure.
         #
-        # @return [nil]
-        def dump_failures
-        end
+        # @param notification [NullNotification]
 
+        # @method dump_summary
         # @api public
         #
         # This method is invoked after the dumping of examples and failures. Each parameter
         # is assigned to a corresponding attribute.
         #
-        # @param duration
-        # @param example_count
-        # @param failure_count
-        # @param pending_count
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          @duration = duration
-          @example_count = example_count
-          @failure_count = failure_count
-          @pending_count = pending_count
-        end
+        # @param summary [SummaryNotification] containing duration, example_count,
+        #                                      failure_count and pending_count
 
+        # @method dump_profile
+        # @api public
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [ProfileNotification] containing duration, slowest_examples
+        #                                      and slowest_example_groups
+
+        # @method dump_pending
         # @api public
         #
         # Outputs a report of pending examples.  This gets invoked
         # after the summary if option is set to do so.
         #
-        # @return [nil]
-        def dump_pending
-        end
-
-        # @private not intended for use outside RSpec.
-        def seed(number)
-        end
+        # @param notification [NullNotification]
 
         # @api public
         #
         # Invoked at the very end, `close` allows the formatter to clean
         # up resources, e.g. open streams, etc.
-        def close
-          restore_sync_output
-        end
-
-        # @api public
         #
-        # Formats the given backtrace based on configuration and
-        # the metadata of the given example.
-        def format_backtrace(backtrace, example)
-          super(backtrace, example.metadata)
-        end
-
-      protected
-
-        def configuration
-          RSpec.configuration
-        end
-
-        def read_failed_line(exception, example)
-          unless matching_line = find_failed_line(exception.backtrace, example.file_path)
-            return "Unable to find matching line from backtrace"
-          end
-
-          file_path, line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)[1..2]
-
-          if File.exist?(file_path)
-            File.readlines(file_path)[line_number.to_i - 1] ||
-              "Unable to find matching line in #{file_path}"
-          else
-            "Unable to find #{file_path} to read failed line"
-          end
-        rescue SecurityError
-          "Unable to read failed line"
+        # @param notification [NullNotification]
+        def close(notification)
+          restore_sync_output
         end
 
-        def find_failed_line(backtrace, path)
-          path = File.expand_path(path)
-          backtrace.detect { |line|
-            match = line.match(/(.+?):(\d+)(|:\d+)/)
-            match && match[1].downcase == path.downcase
-          }
-        end
+      private
 
         def start_sync_output
           @old_sync, output.sync = output.sync, true if output_supports_sync
@@ -224,22 +166,6 @@ module RSpec
           output.respond_to?(:sync=)
         end
 
-        def profile_examples?
-          configuration.profile_examples
-        end
-
-        def fail_fast?
-          configuration.fail_fast
-        end
-
-        def color_enabled?
-          configuration.color_enabled?(output)
-        end
-
-        def mute_profile_output?(failure_count)
-          # Don't print out profiled info if there are failures and `--fail-fast` is used, it just clutters the output
-          !profile_examples? || (fail_fast? && failure_count != 0)
-        end
       end
     end
   end