dxruby_rp5 0.0.1

data/spec/vendor/rspec-core-2.14.7/lib/rspec/core/filter_manager.rb

@@ -0,0 +1,203 @@
+module RSpec
+  module Core
+    # 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
+      DEFAULT_EXCLUSIONS = {
+        :if     => lambda { |value| !value },
+        :unless => lambda { |value| value }
+      }
+
+      STANDALONE_FILTERS = [:locations, :line_numbers, :full_description]
+
+      module Describable
+        PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+        PROJECT_DIR = File.expand_path('.')
+
+        def description
+          reject { |k, v| RSpec::Core::FilterManager::DEFAULT_EXCLUSIONS[k] == v }.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+        end
+
+        def empty_without_conditional_filters?
+          reject { |k, v| RSpec::Core::FilterManager::DEFAULT_EXCLUSIONS[k] == v }.empty?
+        end
+      end
+
+      module BackwardCompatibility
+        def merge(orig, opposite, *updates)
+          _warn_deprecated_keys(updates.last)
+          super
+        end
+
+        def reverse_merge(orig, opposite, *updates)
+          _warn_deprecated_keys(updates.last)
+          super
+        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
+
+        # 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
+      end
+
+      attr_reader :exclusions, :inclusions
+
+      def initialize
+        @exclusions = DEFAULT_EXCLUSIONS.dup.extend(Describable)
+        @inclusions = {}.extend(Describable)
+        extend(BackwardCompatibility)
+      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
+      end
+
+      def empty?
+        inclusions.empty? && exclusions.empty_without_conditional_filters?
+      end
+
+      def prune(examples)
+        examples.select {|e| !exclude?(e) && include?(e)}
+      end
+
+      def exclude(*args)
+        merge(@exclusions, @inclusions, *args)
+      end
+
+      def exclude!(*args)
+        replace(@exclusions, @inclusions, *args)
+      end
+
+      def exclude_with_low_priority(*args)
+        reverse_merge(@exclusions, @inclusions, *args)
+      end
+
+      def exclude?(example)
+        @exclusions.empty? ? false : example.any_apply?(@exclusions)
+      end
+
+      def include(*args)
+        unless_standalone(*args) { merge(@inclusions, @exclusions, *args) }
+      end
+
+      def include!(*args)
+        unless_standalone(*args) { replace(@inclusions, @exclusions, *args) }
+      end
+
+      def include_with_low_priority(*args)
+        unless_standalone(*args) { reverse_merge(@inclusions, @exclusions, *args) }
+      end
+
+      def include?(example)
+        @inclusions.empty? ? true : example.any_apply?(@inclusions)
+      end
+
+      private
+
+      def unless_standalone(*args)
+        is_standalone_filter?(args.last) ? @inclusions.replace(args.last) : yield unless already_set_standalone_filter?
+      end
+
+      def merge(orig, opposite, *updates)
+        orig.merge!(updates.last).each_key {|k| opposite.delete(k)}
+      end
+
+      def replace(orig, opposite, *updates)
+        updates.last.each_key {|k| opposite.delete(k)}
+        orig.replace(updates.last)
+      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)
+      end
+
+      def already_set_standalone_filter?
+        is_standalone_filter?(inclusions)
+      end
+
+      def is_standalone_filter?(filter)
+        STANDALONE_FILTERS.any? {|key| filter.has_key?(key)}
+      end
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/lib/rspec/core/formatters/base_formatter.rb

@@ -0,0 +1,246 @@
+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.
+      #
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      class BaseFormatter
+        include Helpers
+        attr_accessor :example_group
+        attr_reader :duration, :examples, :output
+        attr_reader :example_count, :pending_count, :failure_count
+        attr_reader :failed_examples, :pending_examples
+
+        # @api public
+        #
+        # @param output
+        def initialize(output)
+          @output = output || StringIO.new
+          @example_count = @pending_count = @failure_count = 0
+          @examples = []
+          @failed_examples = []
+          @pending_examples = []
+          @example_group = nil
+        end
+
+        # @api public
+        #
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones).
+        #
+        # This will only be invoked once, and the next one to be invoked
+        # is {#example_group_started}.
+        #
+        # @param example_count
+        def start(example_count)
+          start_sync_output
+          @example_count = example_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
+        end
+
+        # @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
+
+        # @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
+
+        # @api public
+        #
+        # Invoked when an example passes.
+        #
+        # @param example instance of subclass of `RSpec::Core::ExampleGroup`
+        def example_passed(example)
+        end
+
+        # 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
+
+        # @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
+
+        # @api public
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param [String] message
+        def message(message)
+        end
+
+        # @api public
+        #
+        # Invoked after all examples have executed, before dumping post-run reports.
+        #
+        # @return [nil]
+        def stop
+        end
+
+        # @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
+
+        # @api public
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @return [nil]
+        def dump_failures
+        end
+
+        # @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
+
+        # @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
+
+        # @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"
+        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
+
+        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 and !output.closed?
+        end
+
+        def output_supports_sync
+          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
+end