rspec-core 2.99.2 → 3.0.0.beta1

data/lib/rspec/core/filter_manager.rb

@@ -66,51 +66,44 @@ 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
+      STANDALONE_FILTERS = [:locations, :line_numbers, :full_description]
 
-        # @private
-        def default_exclusions
-          @default_exclusions ||= {
-            :if     => lambda { |value| !value },
-            :unless => lambda { |value| value }
-          }
-        end
+      PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+      PROJECT_DIR = File.expand_path('.')
+
+      def self.inspect_filter_hash(hash)
+        hash.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+      end
 
-        # @private
-        def standalone_filters
-          @standalone_filters ||= [:locations, :line_numbers, :full_description]
+      class InclusionFilterHash < Hash
+        def description
+          FilterManager.inspect_filter_hash self
         end
       end
 
-      module Describable
-        PROC_HEX_NUMBER = /0x[0-9a-f]+\s?@/
-        PROJECT_DIR = File.expand_path('.')
+      class ExclusionFilterHash < Hash
+        CONDITIONAL_FILTERS = {
+          :if     => lambda { |value| !value },
+          :unless => lambda { |value| value }
+        }
+
+        def initialize(*)
+          super
+          CONDITIONAL_FILTERS.each {|k,v| store(k, v)}
+        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','')
+          FilterManager.inspect_filter_hash without_conditional_filters
         end
 
         def empty_without_conditional_filters?
-          RSpec.deprecate("(inclusion_filter | exclusion_filter)#empty_without_conditional_filters? is deprecated")
-          rules_empty?
+          without_conditional_filters.empty?
         end
 
-        # @private
-        def rules_empty?
-          reject { |k, v| RSpec::Core::FilterManager.default_exclusions[k] == v }.empty?
+        private
+
+        def without_conditional_filters
+          reject {|k,v| CONDITIONAL_FILTERS[k] == v}
         end
       end
 
@@ -143,8 +136,8 @@ module RSpec
       attr_reader :exclusions, :inclusions
 
       def initialize
-        @exclusions = self.class.default_exclusions.dup.extend(Describable)
-        @inclusions = {}.extend(Describable)
+        @exclusions = ExclusionFilterHash.new
+        @inclusions = InclusionFilterHash.new
         extend(BackwardCompatibility)
       end
 
@@ -159,7 +152,7 @@ module RSpec
       end
 
       def empty?
-        inclusions.empty? && exclusions.rules_empty?
+        inclusions.empty? && exclusions.empty_without_conditional_filters?
       end
 
       def prune(examples)
@@ -171,11 +164,6 @@ module RSpec
       end
 
       def exclude!(*args)
-        RSpec.deprecate("FilterManager#exclude! is deprecated. Use FilterManager#exclude_only")
-        exclude_only(*args)
-      end
-
-      def exclude_only(*args)
         replace(@exclusions, @inclusions, *args)
       end
 
@@ -192,11 +180,6 @@ module RSpec
       end
 
       def include!(*args)
-        RSpec.deprecate("FilterManager#include! is deprecated. Use FilterManager#include_only")
-        include_only(*args)
-      end
-
-      def include_only(*args)
         unless_standalone(*args) { replace(@inclusions, @exclusions, *args) }
       end
 
@@ -234,7 +217,7 @@ module RSpec
       end
 
       def is_standalone_filter?(filter)
-        self.class.standalone_filters.any? {|key| filter.has_key?(key)}
+        STANDALONE_FILTERS.any? {|key| filter.has_key?(key)}
       end
     end
   end

data/lib/rspec/core/flat_map.rb

@@ -0,0 +1,17 @@
+module RSpec
+  module Core
+    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.rb

@@ -3,7 +3,6 @@
 # * progress (default) - prints dots for passing examples, `F` for failures, `*` for pending
 # * documentation - prints the docstrings passed to `describe` and `it` methods (and their aliases)
 # * html
-# * textmate - html plus links to editor
 # * json - useful for archiving data for subsequent analysis
 #
 # The progress formatter is the default, but you can choose any one or more of
@@ -52,141 +51,4 @@
 # @see RSpec::Core::Formatters::BaseTextFormatter
 # @see RSpec::Core::Reporter
 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 :JsonFormatter,          'rspec/core/formatters/json_formatter'
-  autoload :TextMateFormatter,      'rspec/core/formatters/text_mate_formatter'
-
-  # @api private
-  #
-  # `RSpec::Core::Formatters::Loader` is an internal class for
-  # managing formatters used by a particular configuration. It is
-  # not expected to be used directly, but only through the configuration
-  # interface.
-  class Loader
-
-    # @api private
-    def initialize(reporter)
-      @formatters = []
-      @reporter = reporter
-      @setup = false
-      @default_formatter = 'progress'
-    end
-
-    # @return [Array] the loaded formatters
-    attr_reader :formatters
-
-    # @return [Reporter] the reporter
-    attr_reader :reporter
-
-    # @private
-    def setup_default(output_stream, deprecation_stream)
-      if @formatters.empty?
-        add @default_formatter, output_stream
-      end
-      unless @formatters.any? { |formatter| DeprecationFormatter === formatter }
-        add DeprecationFormatter, deprecation_stream, output_stream
-      end
-      @formatters.each do |formatter|
-        @reporter.register_listener formatter, *RSpec::Core::Reporter::NOTIFICATIONS
-      end
-      @setup = true
-    end
-
-    # @private
-    def add(formatter_to_use, *paths)
-      formatter_class = find_formatter(formatter_to_use)
-
-      args = paths.map { |p| p.respond_to?(:puts) ? p : file_at(p) }
-
-      formatter = formatter_class.new(*args)
-      if @setup
-        @reporter.register_listener formatter, *RSpec::Core::Reporter::NOTIFICATIONS
-      end
-      @formatters << formatter unless duplicate_formatter_exists?(formatter)
-
-      formatter
-    end
-
-  private
-
-    def find_formatter(formatter_to_use)
-      built_in_formatter(formatter_to_use) ||
-      custom_formatter(formatter_to_use)   ||
-      (raise ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?.")
-    end
-
-    def duplicate_formatter_exists?(new_formatter)
-      @formatters.any? do |formatter|
-        formatter.class === new_formatter && formatter.output == new_formatter.output
-      end
-    end
-
-    def built_in_formatter(key)
-      case key.to_s
-      when 'd', 'doc', 'documentation'
-        DocumentationFormatter
-      when 's', 'n', 'spec', 'nested'
-        RSpec.deprecate "Using `#{key.to_s}` as a shortcut for the DocumentationFormatter",
-          :replacement => "`d`, `doc`, or `documentation`"
-        DocumentationFormatter
-      when 'h', 'html'
-        HtmlFormatter
-      when 'p', 'progress'
-        ProgressFormatter
-      when 'j', 'json'
-        JsonFormatter
-      when 't', 'textmate'
-        if defined?(::RSpec::Mate::Formatters::TextMateFormatter)
-          RSpec.deprecate "Using the text`#{key.to_s}` as a shortcut for the TextMateFormatter",
-          :replacement => "`::RSpec::Mate::Formatters::TextMateFormatter`"
-        else
-          RSpec.deprecate "Using rspec-core's `::RSpec::Core::TextMateFormatter`",
-          :replacement => "the `rspec-tmbundle` gem and it's `::RSpec::Mate::Formatters::TextMateFormatter`"
-        end
-        TextMateFormatter
-      end
-    end
-
-    def custom_formatter(formatter_ref)
-      if Class === formatter_ref
-        formatter_ref
-      elsif string_const?(formatter_ref)
-        begin
-          formatter_ref.gsub(/^::/,'').split('::').inject(Object) { |const,string| const.const_get string }
-        rescue NameError
-          require( path_for(formatter_ref) ) ? retry : raise
-        end
-      end
-    end
-
-    def string_const?(str)
-      str.is_a?(String) && /\A[A-Z][a-zA-Z0-9_:]*\z/ =~ str
-    end
-
-    def path_for(const_ref)
-      underscore_with_fix_for_non_standard_rspec_naming(const_ref)
-    end
-
-    def underscore_with_fix_for_non_standard_rspec_naming(string)
-      underscore(string).sub(%r{(^|/)r_spec($|/)}, '\\1rspec\\2')
-    end
-
-    # activesupport/lib/active_support/inflector/methods.rb, line 48
-    def underscore(camel_cased_word)
-      word = camel_cased_word.to_s.dup
-      word.gsub!(/::/, '/')
-      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
-
-    def file_at(path)
-      FileUtils.mkdir_p(File.dirname(path))
-      File.new(path, 'w')
-    end
-  end
 end

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

@@ -161,6 +161,15 @@ module RSpec
         def dump_pending
         end
 
+        # @api public
+        #
+        # This methods is invoked form formatters to show slowest examples and example groups
+        # when using `--profile COUNT` (default 10).
+        #
+        # @return [nil]
+        def dump_profile
+        end
+
         # @private not intended for use outside RSpec.
         def seed(number)
         end
@@ -178,7 +187,7 @@ module RSpec
         # Formats the given backtrace based on configuration and
         # the metadata of the given example.
         def format_backtrace(backtrace, example)
-          super(backtrace, example.metadata)
+          configuration.backtrace_formatter.format_backtrace(backtrace, example.metadata)
         end
 
       protected
@@ -240,6 +249,42 @@ module RSpec
           # 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

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

@@ -1,5 +1,5 @@
 require 'rspec/core/formatters/base_formatter'
-require 'rspec/core/formatters/console_codes'
+require 'set'
 
 module RSpec
   module Core
@@ -75,53 +75,31 @@ module RSpec
         end
 
         def dump_profile_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)
+          sorted_examples = slowest_examples
 
-          total, slows = [examples, sorted_examples].map {|exs|
-            exs.inject(0.0) {|i, e| i + e.execution_result[:run_time] }}
-
-          time_taken = slows / total
+          time_taken = sorted_examples[:slows] / sorted_examples[:total]
           percentage = '%.1f' % ((time_taken.nan? ? 0.0 : time_taken) * 100)
 
-          output.puts "\nTop #{sorted_examples.size} slowest examples (#{format_seconds(slows)} seconds, #{percentage}% of total time):\n"
+          output.puts "\nTop #{sorted_examples[:examples].size} slowest examples (#{format_seconds(sorted_examples[:slows])} seconds, #{percentage}% of total time):\n"
 
-          sorted_examples.each do |example|
+          sorted_examples[:examples].each do |example|
             output.puts "  #{example.full_description}"
-            output.puts detail_color("    #{failure_color(format_seconds(example.execution_result[:run_time]))} #{failure_color("seconds")} #{format_caller(example.location)}")
+            output.puts "    #{bold(format_seconds(example.execution_result[:run_time]))} #{bold("seconds")} #{format_caller(example.location)}"
           end
         end
 
         def dump_profile_slowest_example_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 do |loc, hash|
-            hash[:average] = hash[:total_time].to_f / hash[:count]
-          end
 
-          sorted_groups = example_groups.sort_by {|_, hash| -hash[:average]}.first(number_of_examples)
+          sorted_groups = slowest_groups
+          return if sorted_groups.empty?
 
           output.puts "\nTop #{sorted_groups.size} slowest example groups:"
-          sorted_groups.each do |loc, hash|
-            average = "#{failure_color(format_seconds(hash[:average]))} #{failure_color("seconds")} average"
+          slowest_groups.each do |loc, hash|
+            average = "#{bold(format_seconds(hash[:average]))} #{bold("seconds")} average"
             total   = "#{format_seconds(hash[:total_time])} seconds"
             count   = pluralize(hash[:count], "example")
             output.puts "  #{hash[:description]}"
-            output.puts detail_color("    #{average} (#{total} / #{count}) #{loc}")
+            output.puts "    #{average} (#{total} / #{count}) #{loc}"
           end
         end
 
@@ -144,10 +122,8 @@ module RSpec
               output.puts pending_color("  #{pending_example.full_description}")
               output.puts detail_color("    # #{pending_example.execution_result[:pending_message]}")
               output.puts detail_color("    # #{format_caller(pending_example.location)}")
-              # instance_variable_get is a hack to avoid a deprecation warning,
-              # it's only for 2.99.
               if pending_example.execution_result[:exception] \
-                && RSpec.configuration.instance_variable_get(:@show_failures_in_pending_blocks)
+                && RSpec.configuration.show_failures_in_pending_blocks?
                 dump_failure_info(pending_example)
                 dump_backtrace(pending_example)
               end
@@ -162,43 +138,44 @@ module RSpec
         end
 
         def close
-          return unless IO === output
-          return if output.closed? || output == $stdout
-
-          output.close
-        end
-
-        def self.const_missing(name)
-          base = "RSpec::Core::Formatters::"
-          case name
-            when :VT100_COLORS then
-              RSpec.deprecate("#{base}#{name}", :replacement => "#{base}ConsoleCodes::VT100_CODES")
-              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES
-            when :VT100_COLOR_CODES then
-              RSpec.deprecate("#{base}#{name}", :replacement => "#{base}ConsoleCodes::VT100_CODE_VALUES")
-              require 'set'
-              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.to_set
-          else
-            super
-          end
+          output.close if IO === output && output != $stdout
         end
 
+        VT100_COLORS = {
+          :black => 30,
+          :red => 31,
+          :green => 32,
+          :yellow => 33,
+          :blue => 34,
+          :magenta => 35,
+          :cyan => 36,
+          :white => 37
+        }
+
+        VT100_COLOR_CODES = VT100_COLORS.values.to_set
+
         def color_code_for(code_or_symbol)
-          ConsoleCodes.console_code_for(code_or_symbol)
+          if VT100_COLOR_CODES.include?(code_or_symbol)
+            code_or_symbol
+          else
+            VT100_COLORS.fetch(code_or_symbol) do
+              color_code_for(:white)
+            end
+          end
         end
 
         def colorize(text, code_or_symbol)
-          ConsoleCodes.wrap(text, code_or_symbol)
+          "\e[#{color_code_for(code_or_symbol)}m#{text}\e[0m"
         end
 
       protected
 
         def bold(text)
-          ConsoleCodes.wrap(text, :bold)
+          color_enabled? ? "\e[1m#{text}\e[0m" : text
         end
 
         def color(text, color_code)
-          ConsoleCodes.wrap(text, color_code)
+          color_enabled? ? colorize(text, color_code) : text
         end
 
         def failure_color(text)
@@ -271,7 +248,7 @@ module RSpec
       private
 
         def format_caller(caller_info)
-          backtrace_line(caller_info.to_s.split(':in `block').first)
+          configuration.backtrace_formatter.backtrace_line(caller_info.to_s.split(':in `block').first)
         end
 
         def dump_backtrace(example)
@@ -314,7 +291,7 @@ module RSpec
 
         def dump_shared_failure_info(group)
           output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
-            "#{backtrace_line(group.metadata[:example_group][:location])}"
+            "#{configuration.backtrace_formatter.backtrace_line(group.metadata[:example_group][:location])}"
         end
 
         def find_shared_group(example)