rspec-core 3.0.0.beta2 → 3.0.0.rc1

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,149 +67,193 @@ module RSpec
     # @see Configuration#filter_run_including
     # @see Configuration#filter_run_excluding
     class FilterManager
-      STANDALONE_FILTERS = [:locations, :line_numbers, :full_description]
+      attr_reader :exclusions, :inclusions
 
-      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
-      PROJECT_DIR = File.expand_path('.')
+      def initialize
+        @exclusions, @inclusions = FilterRules.build
+      end
 
-      def self.inspect_filter_hash(hash)
-        hash.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+      # @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
+
+      def empty?
+        inclusions.empty? && exclusions.empty?
       end
 
-      class InclusionFilterHash < Hash
-        def description
-          FilterManager.inspect_filter_hash self
+      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
 
-      class ExclusionFilterHash < Hash
-        CONDITIONAL_FILTERS = {
-          :if     => lambda { |value| !value },
-          :unless => lambda { |value| value }
-        }
+      def exclude(*args)
+        exclusions.add(args.last)
+      end
 
-        def initialize(*)
-          super
-          CONDITIONAL_FILTERS.each {|k,v| store(k, v)}
-        end
+      def exclude_only(*args)
+        exclusions.use_only(args.last)
+      end
 
-        def description
-          FilterManager.inspect_filter_hash without_conditional_filters
-        end
+      def exclude_with_low_priority(*args)
+        exclusions.add_with_low_priority(args.last)
+      end
 
-        def empty_without_conditional_filters?
-          without_conditional_filters.empty?
-        end
+      def exclude?(example)
+        exclusions.include_example?(example)
+      end
 
-        private
+      def include(*args)
+        inclusions.add(args.last)
+      end
 
-        if RUBY_VERSION.to_f < 2.1
-          def without_conditional_filters
-            # On 1.8.7, Hash#reject returns a hash but Hash#select returns an array.
-            reject {|k,v| CONDITIONAL_FILTERS[k] == v}
-          end
-        else
-          def without_conditional_filters
-            # On ruby 2.1 #reject on a subclass of Hash emits warnings, but #select does not.
-            select {|k,v| CONDITIONAL_FILTERS[k] != v}
-          end
-        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 = ExclusionFilterHash.new
-        @inclusions = InclusionFilterHash.new
+      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)
+    # @private
+    class FilterRules
+      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+      PROJECT_DIR = File.expand_path('.')
+
+      attr_accessor :opposite
+      attr_reader :rules
 
-        replace_filters :locations => locations
+      def self.build
+        exclusions = ExclusionRules.new
+        inclusions = InclusionRules.new
+        exclusions.opposite = inclusions
+        inclusions.opposite = exclusions
+        [exclusions, inclusions]
       end
 
-      def empty?
-        inclusions.empty? && exclusions.empty_without_conditional_filters?
+      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)
-        replace(@exclusions, @inclusions, *args)
+      def use_only(updated)
+        updated.each_key { |k| opposite.delete(k) }
+        @rules.replace(updated)
       end
 
-      def exclude_with_low_priority(*args)
-        reverse_merge(@exclusions, @inclusions, *args)
+      def clear
+        @rules.clear
       end
 
-      def exclude?(example)
-        @exclusions.empty? ? false : example.any_apply?(@exclusions)
+      def delete(key)
+        @rules.delete(key)
       end
 
-      def include(*filters)
-        set_standalone_filter(*filters) || merge(@inclusions, @exclusions, *filters)
+      def fetch(*args, &block)
+        @rules.fetch(*args, &block)
       end
 
-      def include!(*filters)
-        set_standalone_filter(*filters) || replace(@inclusions, @exclusions, *filters)
+      def [](key)
+        @rules[key]
       end
 
-      def include_with_low_priority(*filters)
-        set_standalone_filter(*filters) || reverse_merge(@inclusions, @exclusions, *filters)
+      def empty?
+        rules.empty?
       end
 
-      def include?(example)
-        @inclusions.empty? ? true : example.any_apply?(@inclusions)
+      def each_pair(&block)
+        @rules.each_pair(&block)
       end
 
-    private
+      def description
+        rules.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+      end
+    end
 
-      def set_standalone_filter(*args)
-        if already_set_standalone_filter?
-          true
-        elsif is_standalone_filter?(args.last)
-          replace_filters(args.last)
-          true
-        end
+    # @private
+    class InclusionRules < FilterRules
+      STANDALONE_FILTERS = [:locations, :full_description]
+
+      def add_location(locations)
+        replace_filters({ :locations => locations })
       end
 
-      def replace_filters(rule)
-        @inclusions.replace(rule)
-        @exclusions.clear
+      def add(*args)
+        set_standalone_filter(*args) || super
       end
 
-      def merge(orig, opposite, *updates)
-        orig.merge!(updates.last).each_key {|k| opposite.delete(k)}
+      def add_with_low_priority(*args)
+        set_standalone_filter(*args) || super
       end
 
-      def replace(orig, opposite, *updates)
-        updates.last.each_key {|k| opposite.delete(k)}
-        orig.replace(updates.last)
+      def use(*args)
+        set_standalone_filter(*args) || super
       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 include_example?(example)
+        @rules.empty? ? true : example.any_apply?(@rules)
       end
 
-      def already_set_standalone_filter?
-        is_standalone_filter?(inclusions)
+      def standalone?
+        is_standalone_filter?(@rules)
       end
 
-      def is_standalone_filter?(filter)
-        STANDALONE_FILTERS.any? {|key| filter.has_key?(key)}
+    private
+
+      def set_standalone_filter(updated)
+        return true if standalone?
+
+        if is_standalone_filter?(updated)
+          replace_filters(updated)
+          true
+        end
+      end
+
+      def replace_filters(new_rules)
+        @rules.replace(new_rules)
+        opposite.clear
+      end
+
+      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 include_example?(example)
+        example.any_apply?(@rules) || example.any_apply?(CONDITIONAL_FILTERS)
       end
     end
   end

data/lib/rspec/core/flat_map.rb

@@ -1,5 +1,6 @@
 module RSpec
   module Core
+    # @private
     module FlatMap
       if [].respond_to?(:flat_map)
         def flat_map(array)

data/lib/rspec/core/formatters.rb

@@ -1,5 +1,3 @@
-require 'rspec/core/formatters/legacy_formatter'
-
 # ## Built-in Formatters
 #
 # * progress (default) - prints dots for passing examples, `F` for failures, `*` for pending
@@ -56,8 +54,14 @@ module RSpec::Core::Formatters
   autoload :DocumentationFormatter, 'rspec/core/formatters/documentation_formatter'
   autoload :HtmlFormatter,          'rspec/core/formatters/html_formatter'
   autoload :ProgressFormatter,      'rspec/core/formatters/progress_formatter'
+  autoload :ProfileFormatter,       'rspec/core/formatters/profile_formatter'
   autoload :JsonFormatter,          'rspec/core/formatters/json_formatter'
 
+  # Register the formatter class
+  # @param formatter_class [Class] formatter class to register
+  # @param notifications [Symbol, ...] one or more notifications to be registered to the specified formatter
+  #
+  # @see RSpec::Core::Formatters::BaseFormatter
   def self.register(formatter_class, *notifications)
     Loader.formatters[formatter_class] = notifications
   end
@@ -80,38 +84,66 @@ module RSpec::Core::Formatters
     def initialize(reporter)
       @formatters = []
       @reporter = reporter
+      self.default_formatter = 'progress'
     end
-    attr_reader :formatters, :reporter
 
-    # @api private
+    # @return [Array] the loaded formatters
+    attr_reader :formatters
+
+    # @return [Reporter] the reporter
+    attr_reader :reporter
+
+    # @return [String] the default formatter to setup, defaults to `progress`
+    attr_accessor :default_formatter
+
+    # @private
     def setup_default(output_stream, deprecation_stream)
       if @formatters.empty?
-        add 'progress', output_stream
+        add default_formatter, output_stream
       end
       unless @formatters.any? { |formatter| DeprecationFormatter === formatter }
         add DeprecationFormatter, deprecation_stream, output_stream
       end
+      if RSpec.configuration.profile_examples? && !existing_formatter_implements?(:dump_profile)
+        add RSpec::Core::Formatters::ProfileFormatter, output_stream
+      end
     end
 
-    # @api private
+    # @private
     def add(formatter_to_use, *paths)
       formatter_class = find_formatter(formatter_to_use)
 
-      args = paths.map { |p| String === p ? file_at(p) : p }
+      args = paths.map { |p| p.respond_to?(:puts) ? p : file_at(p) }
 
       if !Loader.formatters[formatter_class].nil?
         formatter = formatter_class.new(*args)
         @reporter.register_listener formatter, *notifications_for(formatter_class)
-      else
-        formatter = LegacyFormatter.new(formatter_class, *args)
+      elsif defined?(RSpec::LegacyFormatters)
+        formatter = RSpec::LegacyFormatters.load_formatter formatter_class, *args
         @reporter.register_listener formatter, *formatter.notifications
-      end
+      else
+        line = ::RSpec::CallerFilter.first_non_rspec_line
+        if line
+          call_site = "Formatter added at: #{line}"
+        else
+          call_site = "The formatter was added via command line flag or your "+
+                      "`.rspec` file."
+        end
 
-      @formatters << formatter unless duplicate_formatter_exists?(formatter)
-      if formatter.is_a?(LegacyFormatter)
-        RSpec.warn_deprecation "The #{formatter_class} formatter uses the deprecated formatter interface.\n Formatter added at: #{::RSpec::CallerFilter.first_non_rspec_line}"
+        RSpec.warn_deprecation <<-WARNING.gsub(/\s*\|/,' ')
+          |The #{formatter_class} formatter uses the deprecated formatter
+          |interface not supported directly by RSpec 3.
+          |
+          |To continue to use this formatter you must install the
+          |`rspec-legacy_formatters` gem, which provides support
+          |for legacy formatters or upgrade the formatter to a
+          |compatible version.
+          |
+          |#{call_site}
+        WARNING
+        return
       end
-
+      @formatters << formatter unless duplicate_formatter_exists?(formatter)
       formatter
     end
 
@@ -129,6 +161,10 @@ module RSpec::Core::Formatters
       end
     end
 
+    def existing_formatter_implements?(notification)
+      @reporter.registered_listeners(notification).any?
+    end
+
     def built_in_formatter(key)
       case key.to_s
       when 'd', 'doc', 'documentation'

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

@@ -1,4 +1,4 @@
-require 'rspec/core/formatters/helpers'
+RSpec::Support.require_rspec_core "formatters/helpers"
 require 'stringio'
 
 module RSpec
@@ -14,22 +14,15 @@ module RSpec
       class BaseFormatter
 
         # all formatters inheriting from this formatter will receive these notifications
-        Formatters.register self, :start, :example_group_started, :example_started,
-                                  :example_pending, :example_failed, :close
-        include Helpers
+        Formatters.register self, :start, :example_group_started, :close
         attr_accessor :example_group
-        attr_reader :examples, :output
-        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
 
@@ -42,7 +35,7 @@ module RSpec
         # This will only be invoked once, and the next one to be invoked
         # is {#example_group_started}.
         #
-        # @param example_count
+        # @param notification [StartNotification]
         def start(notification)
           start_sync_output
           @example_count = notification.count
@@ -52,12 +45,10 @@ module RSpec
         #
         # 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
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
         def example_group_started(notification)
           @example_group = notification.group
         end
@@ -67,56 +58,47 @@ module RSpec
         #
         # Invoked at the end of the execution of each example group.
         #
-        # @param example_group subclass of `RSpec::Core::ExampleGroup`
+        # @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(notification)
-          examples << notification.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`
+        # @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(notification)
-          @pending_examples << notification.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(notification)
-          @failed_examples << notification.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
+        # @param notification [MessageNotification] containing message
 
         # @method stop
         # @api public
         #
         # Invoked after all examples have executed, before dumping post-run reports.
         #
-        # @return [nil]
+        # @param notification [NullNotification]
 
         # @method start_dump
         # @api public
@@ -125,14 +107,14 @@ module RSpec
         # to be invoked after this one is {#dump_failures}
         # (BaseTextFormatter then calls {#dump_failure} once for each failed example.)
         #
-        # @return [nil]
+        # @param notification [NullNotification]
 
         # @method dump_failures
         # @api public
         #
         # Dumps detailed information about each example failure.
         #
-        # @return [nil]
+        # @param notification [NullNotification]
 
         # @method dump_summary
         # @api public
@@ -140,73 +122,37 @@ module RSpec
         # 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
+        # @param summary [SummaryNotification] containing duration, example_count,
+        #                                      failure_count and pending_count
 
-        # @method dump_pending
+        # @method dump_profile
         # @api public
         #
-        # Outputs a report of pending examples.  This gets invoked
-        # after the summary if option is set to do so.
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
         #
-        # @return [nil]
+        # @param profile [ProfileNotification] containing duration, slowest_examples
+        #                                      and slowest_example_groups
 
-        # @method dump_profile
+        # @method dump_pending
         # @api public
         #
-        # This methods is invoked form formatters to show slowest examples and example groups
-        # when using `--profile COUNT` (default 10).
+        # Outputs a report of pending examples.  This gets invoked
+        # after the summary if option is set to do so.
         #
-        # @return [nil]
+        # @param notification [NullNotification]
 
         # @api public
         #
         # Invoked at the very end, `close` allows the formatter to clean
         # up resources, e.g. open streams, etc.
+        #
+        # @param notification [NullNotification]
         def close(notification)
           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)
-          configuration.backtrace_formatter.format_backtrace(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"
-        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
@@ -220,58 +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
-
-        # @api private
-        def slowest_examples
-          number_of_examples = RSpec.configuration.profile_examples
-          sorted_examples = examples.sort_by {|example|
-            example.execution_result[:run_time] }.reverse.first(number_of_examples)
-
-          total, slows = [examples, sorted_examples].map do |exs|
-            exs.inject(0.0) {|i, e| i + e.execution_result[:run_time] }
-          end
-          {:examples => sorted_examples, :total => total, :slows => slows}
-        end
-
-        # @api private
-        def slowest_groups
-          number_of_examples = RSpec.configuration.profile_examples
-          example_groups = {}
-
-          examples.each do |example|
-            location = example.example_group.parent_groups.last.metadata[:example_group][:location]
-
-            example_groups[location] ||= Hash.new(0)
-            example_groups[location][:total_time]  += example.execution_result[:run_time]
-            example_groups[location][:count]       += 1
-            example_groups[location][:description] = example.example_group.top_level_description unless example_groups[location].has_key?(:description)
-          end
-
-          # stop if we've only one example group
-          return {} if example_groups.keys.length <= 1
-
-          example_groups.each_value do |hash|
-            hash[:average] = hash[:total_time].to_f / hash[:count]
-          end
-
-          example_groups.sort_by {|_, hash| -hash[:average]}.first(number_of_examples)
-        end
       end
     end
   end