opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-core/lib/rspec/core/filter_manager.rb

@@ -0,0 +1,259 @@
+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
+    # and/or example declarations. For example, given this declaration:
+    #
+    #     describe Thing, :awesome => true do
+    #       it "does something" do
+    #         # ...
+    #       end
+    #     end
+    #
+    # That group (or any other with `:awesome => true`) would be filtered in
+    # with any of the following commands:
+    #
+    #     rspec --tag awesome:true
+    #     rspec --tag awesome
+    #     rspec -t awesome:true
+    #     rspec -t awesome
+    #
+    # Prefixing the tag names with `~` negates the tags, thus excluding this group with
+    # any of:
+    #
+    #     rspec --tag ~awesome:true
+    #     rspec --tag ~awesome
+    #     rspec -t ~awesome:true
+    #     rspec -t ~awesome
+    #
+    # ## Options files and command line overrides
+    #
+    # Tag declarations can be stored in `.rspec`, `~/.rspec`, or a custom
+    # options file.  This is useful for storing defaults. For example, let's
+    # say you've got some slow specs that you want to suppress most of the
+    # time. You can tag them like this:
+    #
+    #     describe Something, :slow => true do
+    #
+    # And then store this in `.rspec`:
+    #
+    #     --tag ~slow:true
+    #
+    # Now when you run `rspec`, that group will be excluded.
+    #
+    # ## Overriding
+    #
+    # Of course, you probably want to run them sometimes, so you can override
+    # this tag on the command line like this:
+    #
+    #     rspec --tag slow:true
+    #
+    # ## RSpec.configure
+    #
+    # You can also store default tags with `RSpec.configure`. We use `tag` on
+    # the command line (and in options files like `.rspec`), but for historical
+    # reasons we use the term `filter` in `RSpec.configure:
+    #
+    #     RSpec.configure do |c|
+    #       c.filter_run_including :foo => :bar
+    #       c.filter_run_excluding :foo => :bar
+    #     end
+    #
+    # These declarations can also be overridden from the command line.
+    #
+    # @see RSpec.configure
+    # @see Configuration#filter_run_including
+    # @see Configuration#filter_run_excluding
+    class FilterManager
+      attr_reader :exclusions, :inclusions
+
+      def initialize
+        @exclusions, @inclusions = FilterRules.build
+      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
+
+      def empty?
+        inclusions.empty? && exclusions.empty?
+      end
+
+      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 exclude(*args)
+        exclusions.add(args.last)
+      end
+
+      def exclude_only(*args)
+        exclusions.use_only(args.last)
+      end
+
+      def exclude_with_low_priority(*args)
+        exclusions.add_with_low_priority(args.last)
+      end
+
+      def exclude?(example)
+        exclusions.include_example?(example)
+      end
+
+      def include(*args)
+        inclusions.add(args.last)
+      end
+
+      def include_only(*args)
+        inclusions.use_only(args.last)
+      end
+
+      def include_with_low_priority(*args)
+        inclusions.add_with_low_priority(args.last)
+      end
+
+      def include?(example)
+        inclusions.include_example?(example)
+      end
+    end
+
+    # @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 initialize(*args, &block)
+        @rules = Hash.new(*args, &block)
+      end
+
+      def add(updated)
+        @rules.merge!(updated).each_key { |k| opposite.delete(k) }
+      end
+
+      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 use_only(updated)
+        updated.each_key { |k| opposite.delete(k) }
+        @rules.replace(updated)
+      end
+
+      def clear
+        @rules.clear
+      end
+
+      def delete(key)
+        @rules.delete(key)
+      end
+
+      def fetch(*args, &block)
+        @rules.fetch(*args, &block)
+      end
+
+      def [](key)
+        @rules[key]
+      end
+
+      def empty?
+        rules.empty?
+      end
+
+      def each_pair(&block)
+        @rules.each_pair(&block)
+      end
+
+      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 add(*args)
+        apply_standalone_filter(*args) || super
+      end
+
+      def add_with_low_priority(*args)
+        apply_standalone_filter(*args) || super
+      end
+
+      def use(*args)
+        apply_standalone_filter(*args) || super
+      end
+
+      def include_example?(example)
+        @rules.empty? ? true : example.any_apply?(@rules)
+      end
+
+      def standalone?
+        is_standalone_filter?(@rules)
+      end
+
+    private
+
+      def apply_standalone_filter(updated)
+        return true if standalone?
+        return nil unless is_standalone_filter?(updated)
+
+        replace_filters(updated)
+        true
+      end
+
+      def replace_filters(new_rules)
+        @rules.replace(new_rules)
+        opposite.clear
+      end
+
+      def is_standalone_filter?(rules)
+        STANDALONE_FILTERS.any? { |key| rules.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
+end

data/{vendor_lib → rspec-core/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/rspec-core/lib/rspec/core/formatters/base_formatter.rb

@@ -0,0 +1,67 @@
+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.
+      #
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      # @see RSpec::Core::Formatters::Protocol
+      class BaseFormatter
+        # all formatters inheriting from this formatter will receive these notifications
+        Formatters.register self, :start, :example_group_started, :close
+        attr_accessor :example_group
+        attr_reader :output
+
+        # @api public
+        # @param output [IO] the formatter output
+        # @see RSpec::Core::Formatters::Protocol#initialize
+        def initialize(output)
+          @output = output || StringIO.new
+          @example_group = nil
+        end
+
+        # @api public
+        #
+        # @param notification [StartNotification]
+        # @see RSpec::Core::Formatters::Protocol#start
+        def start(notification)
+          start_sync_output
+          @example_count = notification.count
+        end
+
+        # @api public
+        #
+        # @param notification [GroupNotification] containing example_group subclass of `RSpec::Core::ExampleGroup`
+        # @see RSpec::Core::Formatters::Protocol#example_group_started
+        def example_group_started(notification)
+          @example_group = notification.group
+        end
+
+        # @api public
+        #
+        # @param notification [NullNotification]
+        # @see RSpec::Core::Formatters::Protocol#close
+        def close(_notification)
+          restore_sync_output
+        end
+
+      private
+
+        def start_sync_output
+          @old_sync, output.sync = output.sync, true if output_supports_sync
+        end
+
+        def restore_sync_output
+          output.sync = @old_sync if output_supports_sync && !output.closed?
+        end
+
+        def output_supports_sync
+          output.respond_to?(:sync=)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+RSpec::Support.require_rspec_core "formatters/base_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+      # Base for all of RSpec's built-in formatters. See RSpec::Core::Formatters::BaseFormatter
+      # to learn more about all of the methods called by the reporter.
+      #
+      # @see RSpec::Core::Formatters::BaseFormatter
+      # @see RSpec::Core::Reporter
+      class BaseTextFormatter < BaseFormatter
+        Formatters.register self,
+                            :message, :dump_summary, :dump_failures, :dump_pending, :seed
+
+        # @method message
+        # @api public
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param notification [MessageNotification] containing message
+        def message(notification)
+          output.puts notification.message
+        end
+
+        # @method dump_failures
+        # @api public
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @param notification [NullNotification]
+        def dump_failures(notification)
+          return if notification.failure_notifications.empty?
+          output.puts notification.fully_formatted_failed_examples
+        end
+
+        # @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 summary [SummaryNotification] containing duration, example_count,
+        #                                      failure_count and pending_count
+        def dump_summary(summary)
+          output.puts summary.fully_formatted
+        end
+
+        # @private
+        def dump_pending(notification)
+          return if notification.pending_examples.empty?
+          output.puts notification.fully_formatted_pending_examples
+        end
+
+        # @private
+        def seed(notification)
+          return unless notification.seed_used?
+          output.puts notification.fully_formatted
+        end
+
+        # @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)
+          return unless IO === output
+          return if output.closed? || output == $stdout
+
+          output.close
+        end
+      end
+    end
+  end
+end

data/rspec-core/lib/rspec/core/formatters/console_codes.rb

@@ -0,0 +1,64 @@
+module RSpec
+  module Core
+    module Formatters
+      # ConsoleCodes provides helpers for formatting console output
+      # with ANSI codes, e.g. color's and bold.
+      module ConsoleCodes
+        # @private
+        VT100_CODES =
+          {
+            :black   => 30,
+            :red     => 31,
+            :green   => 32,
+            :yellow  => 33,
+            :blue    => 34,
+            :magenta => 35,
+            :cyan    => 36,
+            :white   => 37,
+            :bold    => 1,
+          }
+        # @private
+        VT100_CODE_VALUES = VT100_CODES.invert
+
+        module_function
+
+        # Fetches the correct code for the supplied symbol, or checks
+        # that a code is valid. Defaults to white (37).
+        #
+        # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
+        # @return [Fixnum] a console code
+        def console_code_for(code_or_symbol)
+          if RSpec.configuration.respond_to?(:"#{code_or_symbol}_color")
+            console_code_for configuration_color(code_or_symbol)
+          elsif VT100_CODE_VALUES.key?(code_or_symbol)
+            code_or_symbol
+          else
+            VT100_CODES.fetch(code_or_symbol) do
+              console_code_for(:white)
+            end
+          end
+        end
+
+        # Wraps a piece of text in ANSI codes with the supplied code. Will
+        # only apply the control code if `RSpec.configuration.color_enabled?`
+        # returns true.
+        #
+        # @param text [String] the text to wrap
+        # @param code_or_symbol [Symbol, Fixnum] the desired control code
+        # @return [String] the wrapped text
+        def wrap(text, code_or_symbol)
+          if RSpec.configuration.color_enabled?
+            "\e[#{console_code_for(code_or_symbol)}m#{text}\e[0m"
+          else
+            text
+          end
+        end
+
+        # @private
+        def configuration_color(code)
+          RSpec.configuration.__send__(:"#{code}_color")
+        end
+      end
+    end
+  end
+end

data/{vendor_lib → rspec-core/lib}/rspec/core/formatters/deprecation_formatter.rb

@@ -1,10 +1,13 @@
-require 'rspec/core/formatters/helpers'
+RSpec::Support.require_rspec_core "formatters/helpers"
 require 'set'
 
 module RSpec
   module Core
     module Formatters
+      # @private
       class DeprecationFormatter
+        Formatters.register self, :deprecation, :deprecation_summary
+
         attr_reader :count, :deprecation_stream, :summary_stream
 
         def initialize(deprecation_stream, summary_stream)
@@ -13,30 +16,33 @@ module RSpec
           @seen_deprecations = Set.new
           @count = 0
         end
+        alias :output :deprecation_stream
 
         def printer
           @printer ||= case deprecation_stream
-                       when File, RaiseErrorStream
+                       when File
+                         ImmediatePrinter.new(FileStream.new(deprecation_stream), summary_stream, self)
+                       when RaiseErrorStream
                          ImmediatePrinter.new(deprecation_stream, summary_stream, self)
                        else
                          DelayedPrinter.new(deprecation_stream, summary_stream, self)
                        end
         end
 
-        def deprecation(data)
-          return if @seen_deprecations.include?(data)
+        def deprecation(notification)
+          return if @seen_deprecations.include? notification
 
           @count += 1
-          printer.print_deprecation_message data
-          @seen_deprecations << data
+          printer.print_deprecation_message notification
+          @seen_deprecations << notification
         end
 
-        def deprecation_summary
+        def deprecation_summary(_notification)
           printer.deprecation_summary
         end
 
         def deprecation_message_for(data)
-          if data[:message]
+          if data.message
             SpecifiedDeprecationMessage.new(data)
           else
             GeneratedDeprecationMessage.new(data)
@@ -51,63 +57,65 @@ module RSpec
           |deprecation warnings into errors, giving you the full backtrace.
         EOS
 
+        DEPRECATION_STREAM_NOTICE = "Pass `--deprecation-out` or set " \
+          "`config.deprecation_stream` to a file for full output."
+
         SpecifiedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
-            @message = data[:message]
+            @message = data.message
             super deprecation_type_for(data)
           end
 
           def to_s
-            @message
+            output_formatted @message
           end
 
           def too_many_warnings_message
-            msg = "Too many similar deprecation messages reported, disregarding further reports."
-            msg << " Set config.deprecation_stream to a File for full output."
+            msg = "Too many similar deprecation messages reported, disregarding further reports. "
+            msg << DEPRECATION_STREAM_NOTICE
             msg
           end
 
           private
 
+          def output_formatted(str)
+            return str unless str.lines.count > 1
+            separator = "#{'-' * 80}"
+            "#{separator}\n#{str.chomp}\n#{separator}"
+          end
+
           def deprecation_type_for(data)
-            data[:message].gsub(/(\w+\/)+\w+\.rb:\d+/, '')
+            data.message.gsub(/(\w+\/)+\w+\.rb:\d+/, '')
           end
         end
 
         GeneratedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
             @data = data
-            super data[:deprecated]
+            super data.deprecated
           end
 
           def to_s
-            msg =  "#{@data[:deprecated]} is deprecated."
-            msg << " Use #{@data[:replacement]} instead." if @data[:replacement]
-            msg << " Called from #{@data[:call_site]}." if @data[:call_site]
+            msg =  "#{@data.deprecated} is deprecated."
+            msg << " Use #{@data.replacement} instead." if @data.replacement
+            msg << " Called from #{@data.call_site}." if @data.call_site
             msg
           end
 
           def too_many_warnings_message
-            msg = "Too many uses of deprecated '#{type}'."
-            msg << " Set config.deprecation_stream to a File for full output."
+            msg = "Too many uses of deprecated '#{type}'. "
+            msg << DEPRECATION_STREAM_NOTICE
             msg
           end
         end
 
+        # @private
         class ImmediatePrinter
-          include ::RSpec::Core::Formatters::Helpers
-
           attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
 
           def initialize(deprecation_stream, summary_stream, deprecation_formatter)
             @deprecation_stream = deprecation_stream
 
-            # In one of my test suites, I got lots of duplicate output in the
-            # deprecation file (e.g. 200 of the same deprecation, even though
-            # the `puts` below was only called 6 times). Setting `sync = true`
-            # fixes this (but we really have no idea why!).
-            @deprecation_stream.sync = true
-
             @summary_stream = summary_stream
             @deprecation_formatter = deprecation_formatter
           end
@@ -118,18 +126,15 @@ module RSpec
           end
 
           def deprecation_summary
-            if deprecation_formatter.count > 0
-              summary_stream.puts "\n#{pluralize(deprecation_formatter.count, 'deprecation')} logged to #{deprecation_stream.path}"
-              deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
-            end
+            return if deprecation_formatter.count.zero?
+            deprecation_stream.summarize(summary_stream, deprecation_formatter.count)
           end
         end
 
+        # @private
         class DelayedPrinter
           TOO_MANY_USES_LIMIT = 4
 
-          include ::RSpec::Core::Formatters::Helpers
-
           attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
 
           def initialize(deprecation_stream, summary_stream, deprecation_formatter)
@@ -161,7 +166,7 @@ module RSpec
             print_deferred_deprecation_warnings
             deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
 
-            summary_stream.puts "\n#{pluralize(deprecation_formatter.count, 'deprecation warning')} total"
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_formatter.count, 'deprecation warning')} total"
           end
 
           def print_deferred_deprecation_warnings
@@ -174,20 +179,44 @@ module RSpec
           end
         end
 
+        # @private
         # Not really a stream, but is usable in place of one.
         class RaiseErrorStream
           def puts(message)
             raise DeprecationError, message
           end
 
-          def sync=(value)
-            # no-op
+          def summarize(summary_stream, deprecation_count)
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} found."
           end
         end
 
+        # @private
+        # Wraps a File object and provides file-specific operations.
+        class FileStream
+          def initialize(file)
+            @file = file
+
+            # In one of my test suites, I got lots of duplicate output in the
+            # deprecation file (e.g. 200 of the same deprecation, even though
+            # the `puts` below was only called 6 times). Setting `sync = true`
+            # fixes this (but we really have no idea why!).
+            @file.sync = true
+          end
+
+          def puts(*args)
+            @file.puts(*args)
+          end
+
+          def summarize(summary_stream, deprecation_count)
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} logged to #{@file.path}"
+            puts RAISE_ERROR_CONFIG_NOTICE
+          end
+        end
       end
     end
 
+    # Deprecation Error
     DeprecationError = Class.new(StandardError)
   end
 end