opal-rspec-cj 0.4.4

data/vendor_lib/rspec/core/backport_random.rb

@@ -0,0 +1,302 @@
+# This code was (mostly) ported from the backports gem (https://github.com/marcandre/backports).
+# The goal is to provide a random number generator in Ruby versions that do not have one.
+# This was added to support localization of random spec ordering.
+#
+# These were in multiple files in backports, but merged into one here.
+
+module RSpec
+  module Core
+    # Methods used internally by the backports.
+    module Backports
+      # Helper method to coerce a value into a specific class.
+      # Raises a TypeError if the coercion fails or the returned value
+      # is not of the right class.
+      # (from Rubinius)
+      def self.coerce_to(obj, cls, meth)
+        return obj if obj.kind_of?(cls)
+
+        begin
+          ret = obj.__send__(meth)
+        rescue Exception => e
+          raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed:\n" \
+                           "(#{e.message})"
+        end
+        raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.kind_of? cls
+        ret
+      end
+
+      def self.coerce_to_int(obj)
+        coerce_to(obj, Integer, :to_int)
+      end
+
+      # Used internally to make it easy to deal with optional arguments
+      # (from Rubinius)
+      Undefined = Object.new
+
+      class Random
+        # An implementation of Mersenne Twister MT19937 in Ruby
+        class MT19937
+          STATE_SIZE = 624
+          LAST_STATE = STATE_SIZE - 1
+          PAD_32_BITS = 0xffffffff
+
+          # See seed=
+          def initialize(seed)
+            self.seed = seed
+          end
+
+          LAST_31_BITS = 0x7fffffff
+          OFFSET = 397
+
+          # Generates a completely new state out of the previous one.
+          def next_state
+            STATE_SIZE.times do |i|
+              mix = @state[i] & 0x80000000 | @state[i+1 - STATE_SIZE] & 0x7fffffff
+              @state[i] = @state[i+OFFSET - STATE_SIZE] ^ (mix >> 1)
+              @state[i] ^= 0x9908b0df if mix.odd?
+            end
+            @last_read = -1
+          end
+
+          # Seed must be either an Integer (only the first 32 bits will be used)
+          # or an Array of Integers (of which only the first 32 bits will be used)
+          #
+          # No conversion or type checking is done at this level
+          def seed=(seed)
+            case seed
+            when Integer
+              @state = Array.new(STATE_SIZE)
+              @state[0] = seed & PAD_32_BITS
+              (1..LAST_STATE).each do |i|
+                @state[i] = (1812433253 * (@state[i-1]  ^ @state[i-1]>>30) + i)& PAD_32_BITS
+              end
+              @last_read = LAST_STATE
+            when Array
+              self.seed = 19650218
+              i=1
+              j=0
+              [STATE_SIZE, seed.size].max.times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1664525) + j + seed[j] & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+                j = 0 if (j+=1) >= seed.size
+              end
+              (STATE_SIZE-1).times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1566083941) - i & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+              end
+              @state[0] = 0x80000000
+            else
+              raise ArgumentError, "Seed must be an Integer or an Array"
+            end
+          end
+
+          # Returns a random Integer from the range 0 ... (1 << 32)
+          def random_32_bits
+            next_state if @last_read >= LAST_STATE
+            @last_read += 1
+            y = @state[@last_read]
+            # Tempering
+            y ^= (y >> 11)
+            y ^= (y << 7) & 0x9d2c5680
+            y ^= (y << 15) & 0xefc60000
+            y ^= (y >> 18)
+          end
+
+          # Supplement the MT19937 class with methods to do
+          # conversions the same way as MRI.
+          # No argument checking is done here either.
+
+          FLOAT_FACTOR = 1.0/9007199254740992.0
+          # generates a random number on [0,1) with 53-bit resolution
+          def random_float
+            ((random_32_bits >> 5) * 67108864.0 + (random_32_bits >> 6)) * FLOAT_FACTOR;
+          end
+
+          # Returns an integer within 0...upto
+          def random_integer(upto)
+            n = upto - 1
+            nb_full_32 = 0
+            while n > PAD_32_BITS
+              n >>= 32
+              nb_full_32 += 1
+            end
+            mask = mask_32_bits(n)
+            begin
+              rand = random_32_bits & mask
+              nb_full_32.times do
+                rand <<= 32
+                rand |= random_32_bits
+              end
+            end until rand < upto
+            rand
+          end
+
+          def random_bytes(nb)
+            nb_32_bits = (nb + 3) / 4
+            random = nb_32_bits.times.map { random_32_bits }
+            random.pack("L" * nb_32_bits)[0, nb]
+          end
+
+          def state_as_bignum
+            b = 0
+            @state.each_with_index do |val, i|
+              b |= val << (32 * i)
+            end
+            b
+          end
+
+          def left # It's actually the number of words left + 1, as per MRI...
+            MT19937::STATE_SIZE - @last_read
+          end
+
+          def marshal_dump
+            [state_as_bignum, left]
+          end
+
+          def marshal_load(ary)
+            b, left = ary
+            @last_read = MT19937::STATE_SIZE - left
+            @state = Array.new(STATE_SIZE)
+            STATE_SIZE.times do |i|
+              @state[i] = b & PAD_32_BITS
+              b >>= 32
+            end
+          end
+
+          # Convert an Integer seed of arbitrary size to either a single 32 bit integer, or an Array of 32 bit integers
+          def self.convert_seed(seed)
+            seed = seed.abs
+            long_values = []
+            begin
+              long_values << (seed & PAD_32_BITS)
+              seed >>= 32
+            end until seed == 0
+
+            long_values.pop if long_values[-1] == 1 && long_values.size > 1 # Done to allow any kind of sequence of integers
+
+            long_values.size > 1 ? long_values : long_values.first
+          end
+
+          def self.[](seed)
+            new(convert_seed(seed))
+          end
+
+          private
+
+          MASK_BY = [1,2,4,8,16]
+          def mask_32_bits(n)
+            MASK_BY.each do |shift|
+              n |= n >> shift
+            end
+            n
+          end
+        end
+
+        # Implementation corresponding to the actual Random class of Ruby
+        # The actual random generator (mersenne twister) is in MT19937.
+        # Ruby specific conversions are handled in bits_and_bytes.
+        # The high level stuff (argument checking) is done here.
+        module Implementation
+          attr_reader :seed
+
+          def initialize(seed = 0)
+            super()
+            seed_rand seed
+          end
+
+          def seed_rand(new_seed = 0)
+            new_seed = Backports.coerce_to_int(new_seed)
+            @seed = nil unless defined?(@seed)
+            old, @seed = @seed, new_seed.nonzero? || Random.new_seed
+            @mt = MT19937[ @seed ]
+            old
+          end
+
+          def rand(limit = Backports::Undefined)
+            case limit
+              when Backports::Undefined
+                @mt.random_float
+              when Float
+                limit * @mt.random_float unless limit <= 0
+              when Range
+                _rand_range(limit)
+              else
+                limit = Backports.coerce_to_int(limit)
+                @mt.random_integer(limit) unless limit <= 0
+            end || raise(ArgumentError, "invalid argument #{limit}")
+          end
+
+          def bytes(nb)
+            nb = Backports.coerce_to_int(nb)
+            raise ArgumentError, "negative size" if nb < 0
+            @mt.random_bytes(nb)
+          end
+
+          def ==(other)
+            other.is_a?(Random) &&
+              seed == other.seed &&
+              left == other.send(:left) &&
+              state == other.send(:state)
+          end
+
+          def marshal_dump
+            @mt.marshal_dump << @seed
+          end
+
+          def marshal_load(ary)
+            @seed = ary.pop
+            @mt = MT19937.allocate
+            @mt.marshal_load(ary)
+          end
+
+          private
+
+          def state
+            @mt.state_as_bignum
+          end
+
+          def left
+            @mt.left
+          end
+
+          def _rand_range(limit)
+            range = limit.end - limit.begin
+            if (!range.is_a?(Float)) && range.respond_to?(:to_int) && range = Backports.coerce_to_int(range)
+              range += 1 unless limit.exclude_end?
+              limit.begin + @mt.random_integer(range) unless range <= 0
+            elsif range = Backports.coerce_to(range, Float, :to_f)
+              if range < 0
+                nil
+              elsif limit.exclude_end?
+                limit.begin + @mt.random_float * range unless range <= 0
+              else
+                # cheat a bit... this will reduce the nb of random bits
+                loop do
+                  r = @mt.random_float * range * 1.0001
+                  break limit.begin + r unless r > range
+                end
+              end
+            end
+          end
+        end
+
+        def self.new_seed
+          (2 ** 62) + Kernel.rand(2 ** 62)
+        end
+      end
+
+      class Random
+        include Implementation
+        class << self
+          include Implementation
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/backtrace_formatter.rb

@@ -0,0 +1,65 @@
+module RSpec
+  module Core
+    class BacktraceFormatter
+      # This is only used externally by rspec-expectations. Can be removed once
+      # rspec-expectations uses
+      # RSpec.configuration.backtrace_formatter.format_backtrace instead.
+      def self.format_backtrace(backtrace, options = {})
+        RSpec.configuration.backtrace_formatter.format_backtrace(backtrace, options)
+      end
+
+      attr_accessor :exclusion_patterns, :inclusion_patterns
+
+      def initialize
+        @full_backtrace = false
+        @exclusion_patterns = [] << Regexp.union(
+          *["/lib\d*/ruby/",
+            "org/jruby/",
+            "bin/",
+            "/gems/",
+            "lib/rspec/(core|expectations|matchers|mocks)"].
+          map {|s| Regexp.new(s.gsub("/", File::SEPARATOR))}
+        )
+        @inclusion_patterns = [Regexp.new(Dir.getwd)]
+      end
+
+      def full_backtrace=(full_backtrace)
+        @full_backtrace = full_backtrace
+      end
+
+      def full_backtrace?
+        @full_backtrace || @exclusion_patterns.empty?
+      end
+
+      def format_backtrace(backtrace, options = {})
+        return backtrace if options[:full_backtrace]
+        backtrace.
+          take_while {|l| l != RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE}.
+          map        {|l| backtrace_line(l)}.
+          compact.
+          tap do |filtered|
+            if filtered.empty?
+              filtered.concat backtrace
+              filtered << ""
+              filtered << "  Showing full backtrace because every line was filtered out."
+              filtered << "  See docs for RSpec::Configuration#backtrace_exclusion_patterns and"
+              filtered << "  RSpec::Configuration#backtrace_inclusion_patterns for more information."
+            end
+          end
+      end
+
+      # @api private
+      def backtrace_line(line)
+        RSpec::Core::Metadata::relative_path(line) unless exclude?(line)
+      rescue SecurityError
+        nil
+      end
+
+      # @api private
+      def exclude?(line)
+        return false if @full_backtrace
+        @exclusion_patterns.any? {|p| p =~ line} && @inclusion_patterns.none? {|p| p =~ line}
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/command_line.rb

@@ -0,0 +1,36 @@
+module RSpec
+  module Core
+    class CommandLine
+      def initialize(options, configuration=RSpec::configuration, world=RSpec::world)
+        if Array === options
+          options = ConfigurationOptions.new(options)
+          options.parse_options
+        end
+        @options       = options
+        @configuration = configuration
+        @world         = world
+      end
+
+      # Configures and runs a suite
+      #
+      # @param [IO] err
+      # @param [IO] out
+      def run(err, out)
+        @configuration.error_stream = err
+        @configuration.output_stream = out if @configuration.output_stream == $stdout
+        @options.configure(@configuration)
+        @configuration.load_spec_files
+        @world.announce_filters
+
+        @configuration.reporter.report(@world.example_count) do |reporter|
+          begin
+            @configuration.run_hook(:before, :suite)
+            @world.ordered_example_groups.map {|g| g.run(reporter) }.all? ? 0 : @configuration.failure_exit_code
+          ensure
+            @configuration.run_hook(:after, :suite)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/configuration.rb

@@ -0,0 +1,1129 @@
+require 'fileutils'
+require 'rspec/core/backtrace_formatter'
+require 'rspec/core/ruby_project'
+require 'rspec/core/formatters/deprecation_formatter'
+
+module RSpec
+  module Core
+    # Stores runtime configuration information.
+    #
+    # Configuration options are loaded from `~/.rspec`, `.rspec`,
+    # `.rspec-local`, command line switches, and the `SPEC_OPTS` environment
+    # variable (listed in lowest to highest precedence; for example, an option
+    # in `~/.rspec` can be overridden by an option in `.rspec-local`).
+    #
+    # @example Standard settings
+    #     RSpec.configure do |c|
+    #       c.drb          = true
+    #       c.drb_port     = 1234
+    #       c.default_path = 'behavior'
+    #     end
+    #
+    # @example Hooks
+    #     RSpec.configure do |c|
+    #       c.before(:suite) { establish_connection }
+    #       c.before(:each)  { log_in_as :authorized }
+    #       c.around(:each)  { |ex| Database.transaction(&ex) }
+    #     end
+    #
+    # @see RSpec.configure
+    # @see Hooks
+    class Configuration
+      include RSpec::Core::Hooks
+
+      class MustBeConfiguredBeforeExampleGroupsError < StandardError; end
+
+      # @private
+      def self.define_reader(name)
+        define_method(name) do
+          variable = instance_variable_defined?("@#{name}") ? instance_variable_get("@#{name}") : nil
+          value_for(name, variable)
+        end
+      end
+
+      # @private
+      def self.deprecate_alias_key
+        RSpec.deprecate("add_setting with :alias option", :replacement => ":alias_with")
+      end
+
+      # @private
+      def self.define_aliases(name, alias_name)
+        alias_method alias_name, name
+        alias_method "#{alias_name}=", "#{name}="
+        define_predicate_for alias_name
+      end
+
+      # @private
+      def self.define_predicate_for(*names)
+        names.each {|name| alias_method "#{name}?", name}
+      end
+
+      # @private
+      #
+      # Invoked by the `add_setting` instance method. Use that method on a
+      # `Configuration` instance rather than this class method.
+      def self.add_setting(name, opts={})
+        raise "Use the instance add_setting method if you want to set a default" if opts.has_key?(:default)
+        if opts[:alias]
+          deprecate_alias_key
+          define_aliases(opts[:alias], name)
+        else
+          attr_writer name
+          define_reader name
+          define_predicate_for name
+        end
+        Array(opts[:alias_with]).each do |alias_name|
+          define_aliases(name, alias_name)
+        end
+      end
+
+      # @macro [attach] add_setting
+      #   @attribute $1
+      #
+      # @macro [attach] define_reader
+      #   @attribute $1
+
+      # @macro add_setting
+      # Path to use if no path is provided to the `rspec` command (default:
+      # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to
+      # run all the examples in the `spec` directory.
+      add_setting :default_path
+
+      # @macro add_setting
+      # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb
+      # server, but you can use tools like spork.
+      add_setting :drb
+
+      # @macro add_setting
+      # The drb_port (default: nil).
+      add_setting :drb_port
+
+      # @macro add_setting
+      # Default: `$stderr`.
+      add_setting :error_stream
+
+      # @macro add_setting
+      # Default: `$stderr`.
+      add_setting :deprecation_stream
+
+      # @macro add_setting
+      # Clean up and exit after the first failure (default: `false`).
+      add_setting :fail_fast
+
+      # @macro add_setting
+      # Prints the formatter output of your suite without running any
+      # examples or hooks.
+      add_setting :dry_run
+
+      # @macro add_setting
+      # The exit code to return if there are any failures (default: 1).
+      add_setting :failure_exit_code
+
+      # @macro define_reader
+      # Indicates files configured to be required
+      define_reader :requires
+
+      # @macro define_reader
+      # Returns dirs that have been prepended to the load path by #lib=
+      define_reader :libs
+
+      # @macro add_setting
+      # Default: `$stdout`.
+      # Also known as `output` and `out`
+      define_reader :output_stream
+      def output_stream=(value)
+        if @reporter && !value.equal?(@output_stream)
+          warn "RSpec's reporter has already been initialized with " +
+            "#{output_stream.inspect} as the output stream, so your change to "+
+            "`output_stream` will be ignored. You should configure it earlier for " +
+            "it to take effect. (Called from #{CallerFilter.first_non_rspec_line})"
+        else
+          @output_stream = value
+        end
+      end
+
+      # @macro add_setting
+      # Load files matching this pattern (default: `'**/*_spec.rb'`)
+      add_setting :pattern, :alias_with => :filename_pattern
+
+      def pattern= value
+        if @spec_files_loaded
+          RSpec.warning "Configuring `pattern` to #{value} has no effect since RSpec has already loaded the spec files."
+        end
+        @pattern = value
+      end
+      alias :filename_pattern= :pattern=
+
+      # @macro add_setting
+      # Report the times for the slowest examples (default: `false`).
+      # Use this to specify the number of examples to include in the profile.
+      add_setting :profile_examples
+
+      # @macro add_setting
+      # Run all examples if none match the configured filters (default: `false`).
+      add_setting :run_all_when_everything_filtered
+
+      # @macro add_setting
+      # Color to use to indicate success.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :success_color
+
+      # @macro add_setting
+      # Color to use to print pending examples.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :pending_color
+
+      # @macro add_setting
+      # Color to use to indicate failure.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :failure_color
+
+      # @macro add_setting
+      # The default output color.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :default_color
+
+      # @macro add_setting
+      # Color used when a pending example is fixed.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :fixed_color
+
+      # @macro add_setting
+      # Color used to print details.
+      # @param [Symbol] color one of the following: [:black, :white, :red, :green, :yellow, :blue, :magenta, :cyan]
+      add_setting :detail_color
+
+      # @macro add_setting
+      # When a block passed to pending fails (as expected), display the failure
+      # without reporting it as a failure (default: false).
+      add_setting :show_failures_in_pending_blocks
+
+      # Deprecated. This config option was added in RSpec 2 to pave the way
+      # for this being the default behavior in RSpec 3. Now this option is
+      # a no-op.
+      def treat_symbols_as_metadata_keys_with_true_values=(value)
+        RSpec.deprecate("RSpec::Core::Configuration#treat_symbols_as_metadata_keys_with_true_values=")
+      end
+
+      # @private
+      add_setting :tty
+      # @private
+      add_setting :include_or_extend_modules
+      # @private
+      add_setting :files_to_run
+      # @private
+      add_setting :expecting_with_rspec
+      # @private
+      attr_accessor :filter_manager
+      # @private
+      attr_reader :backtrace_formatter, :ordering_manager
+
+      # Alias for rspec-2.x's backtrace_cleaner (now backtrace_formatter)
+      #
+      # TODO: consider deprecating and removing this rather than aliasing in rspec-3?
+      alias backtrace_cleaner backtrace_formatter
+
+      def initialize
+        @expectation_frameworks = []
+        @include_or_extend_modules = []
+        @mock_framework = nil
+        @files_to_run = []
+        @formatters = []
+        @color = false
+        @pattern = '**/*_spec.rb'
+        @failure_exit_code = 1
+        @spec_files_loaded = false
+
+        @backtrace_formatter = BacktraceFormatter.new
+
+        @default_path = 'spec'
+        @deprecation_stream = $stderr
+        @output_stream = $stdout
+        @reporter = nil
+        @filter_manager = FilterManager.new
+        @ordering_manager = Ordering::ConfigurationManager.new
+        @preferred_options = {}
+        @failure_color = :red
+        @success_color = :green
+        @pending_color = :yellow
+        @default_color = :white
+        @fixed_color = :blue
+        @detail_color = :cyan
+        @profile_examples = false
+        @requires = []
+        @libs = []
+      end
+
+      # @private
+      #
+      # Used to set higher priority option values from the command line.
+      def force(hash)
+        ordering_manager.force(hash)
+        @preferred_options.merge!(hash)
+        self.warnings = value_for :warnings, nil
+      end
+
+      # @private
+      def reset
+        @spec_files_loaded = false
+        @reporter = nil
+        @formatters.clear
+      end
+
+      # @overload add_setting(name)
+      # @overload add_setting(name, opts)
+      # @option opts [Symbol] :default
+      #
+      #   set a default value for the generated getter and predicate methods:
+      #
+      #       add_setting(:foo, :default => "default value")
+      #
+      # @option opts [Symbol] :alias_with
+      #
+      #   Use `:alias_with` to alias the setter, getter, and predicate to another
+      #   name, or names:
+      #
+      #       add_setting(:foo, :alias_with => :bar)
+      #       add_setting(:foo, :alias_with => [:bar, :baz])
+      #
+      # Adds a custom setting to the RSpec.configuration object.
+      #
+      #     RSpec.configuration.add_setting :foo
+      #
+      # Used internally and by extension frameworks like rspec-rails, so they
+      # can add config settings that are domain specific. For example:
+      #
+      #     RSpec.configure do |c|
+      #       c.add_setting :use_transactional_fixtures,
+      #         :default => true,
+      #         :alias_with => :use_transactional_examples
+      #     end
+      #
+      # `add_setting` creates three methods on the configuration object, a
+      # setter, a getter, and a predicate:
+      #
+      #     RSpec.configuration.foo=(value)
+      #     RSpec.configuration.foo
+      #     RSpec.configuration.foo? # returns true if foo returns anything but nil or false
+      def add_setting(name, opts={})
+        default = opts.delete(:default)
+        (class << self; self; end).class_eval do
+          add_setting(name, opts)
+        end
+        send("#{name}=", default) if default
+      end
+
+      # Returns the configured mock framework adapter module
+      def mock_framework
+        mock_with :rspec unless @mock_framework
+        @mock_framework
+      end
+
+      # Delegates to mock_framework=(framework)
+      def mock_framework=(framework)
+        mock_with framework
+      end
+
+      # Regexps used to exclude lines from backtraces.
+      #
+      # Excludes lines from ruby (and jruby) source, installed gems, anything
+      # in any "bin" directory, and any of the rspec libs (outside gem
+      # installs) by default.
+      #
+      # You can modify the list via the getter, or replace it with the setter.
+      #
+      # To override this behaviour and display a full backtrace, use
+      # `--backtrace`on the command line, in a `.rspec` file, or in the
+      # `rspec_options` attribute of RSpec's rake task.
+      def backtrace_exclusion_patterns
+        @backtrace_formatter.exclusion_patterns
+      end
+
+      def backtrace_exclusion_patterns=(patterns)
+        @backtrace_formatter.exclusion_patterns = patterns
+      end
+
+      # Regexps used to include lines in backtraces.
+      #
+      # Defaults to [Regexp.new Dir.getwd].
+      #
+      # Lines that match an exclusion _and_ an inclusion pattern
+      # will be included.
+      #
+      # You can modify the list via the getter, or replace it with the setter.
+      def backtrace_inclusion_patterns
+        @backtrace_formatter.inclusion_patterns
+      end
+
+      def backtrace_inclusion_patterns=(patterns)
+        @backtrace_formatter.inclusion_patterns = patterns
+      end
+
+      # Sets the mock framework adapter module.
+      #
+      # `framework` can be a Symbol or a Module.
+      #
+      # Given any of `:rspec`, `:mocha`, `:flexmock`, or `:rr`, configures the
+      # named framework.
+      #
+      # Given `:nothing`, configures no framework. Use this if you don't use
+      # any mocking framework to save a little bit of overhead.
+      #
+      # Given a Module, includes that module in every example group. The module
+      # should adhere to RSpec's mock framework adapter API:
+      #
+      #     setup_mocks_for_rspec
+      #       - called before each example
+      #
+      #     verify_mocks_for_rspec
+      #       - called after each example. Framework should raise an exception
+      #         when expectations fail
+      #
+      #     teardown_mocks_for_rspec
+      #       - called after verify_mocks_for_rspec (even if there are errors)
+      #
+      # If the module responds to `configuration` and `mock_with` receives a block,
+      # it will yield the configuration object to the block e.g.
+      #
+      #     config.mock_with OtherMockFrameworkAdapter do |mod_config|
+      #       mod_config.custom_setting = true
+      #     end
+      def mock_with(framework)
+        framework_module = case framework
+        when Module
+          framework
+        when String, Symbol
+          require case framework.to_s
+                  when /rspec/i
+                    'rspec/core/mocking/with_rspec'
+                  when /mocha/i
+                    'rspec/core/mocking/with_mocha'
+                  when /rr/i
+                    'rspec/core/mocking/with_rr'
+                  when /flexmock/i
+                    'rspec/core/mocking/with_flexmock'
+                  else
+                    'rspec/core/mocking/with_absolutely_nothing'
+                  end
+          RSpec::Core::MockFrameworkAdapter
+        end
+
+        new_name, old_name = [framework_module, @mock_framework].map do |mod|
+          mod.respond_to?(:framework_name) ?  mod.framework_name : :unnamed
+        end
+
+        unless new_name == old_name
+          assert_no_example_groups_defined(:mock_framework)
+        end
+
+        if block_given?
+          raise "#{framework_module} must respond to `configuration` so that mock_with can yield it." unless framework_module.respond_to?(:configuration)
+          yield framework_module.configuration
+        end
+
+        @mock_framework = framework_module
+      end
+
+      # Returns the configured expectation framework adapter module(s)
+      def expectation_frameworks
+        expect_with :rspec if @expectation_frameworks.empty?
+        @expectation_frameworks
+      end
+
+      # Delegates to expect_with(framework)
+      def expectation_framework=(framework)
+        expect_with(framework)
+      end
+
+      # Sets the expectation framework module(s) to be included in each example
+      # group.
+      #
+      # `frameworks` can be `:rspec`, `:stdlib`, a custom module, or any
+      # combination thereof:
+      #
+      #     config.expect_with :rspec
+      #     config.expect_with :stdlib
+      #     config.expect_with :rspec, :stdlib
+      #     config.expect_with OtherExpectationFramework
+      #
+      # RSpec will translate `:rspec` and `:stdlib` into the appropriate
+      # modules.
+      #
+      # ## Configuration
+      #
+      # If the module responds to `configuration`, `expect_with` will
+      # yield the `configuration` object if given a block:
+      #
+      #     config.expect_with OtherExpectationFramework do |custom_config|
+      #       custom_config.custom_setting = true
+      #     end
+      def expect_with(*frameworks)
+        modules = frameworks.map do |framework|
+          case framework
+          when Module
+            framework
+          when :rspec
+            require 'rspec/expectations'
+            self.expecting_with_rspec = true
+            ::RSpec::Matchers
+          when :stdlib
+            require 'test/unit/assertions'
+            ::Test::Unit::Assertions
+          else
+            raise ArgumentError, "#{framework.inspect} is not supported"
+          end
+        end
+
+        if (modules - @expectation_frameworks).any?
+          assert_no_example_groups_defined(:expect_with)
+        end
+
+        if block_given?
+          raise "expect_with only accepts a block with a single argument. Call expect_with #{modules.length} times, once with each argument, instead." if modules.length > 1
+          raise "#{modules.first} must respond to `configuration` so that expect_with can yield it." unless modules.first.respond_to?(:configuration)
+          yield modules.first.configuration
+        end
+
+        @expectation_frameworks.push(*modules)
+      end
+
+      def full_backtrace?
+        @backtrace_formatter.full_backtrace?
+      end
+
+      def full_backtrace=(true_or_false)
+        @backtrace_formatter.full_backtrace = true_or_false
+      end
+
+      def color(output=output_stream)
+        # rspec's built-in formatters all call this with the output argument,
+        # but defaulting to output_stream for backward compatibility with
+        # formatters in extension libs
+        return false unless output_to_tty?(output)
+        value_for(:color, @color)
+      end
+
+      def color=(bool)
+        if bool
+          if RSpec.windows_os? and not ENV['ANSICON']
+            RSpec.warning "You must use ANSICON 1.31 or later (http://adoxa.3eeweb.com/ansicon/) to use colour on Windows"
+            @color = false
+          else
+            @color = true
+          end
+        end
+      end
+
+      # TODO - deprecate color_enabled - probably not until the last 2.x
+      # release before 3.0
+      alias_method :color_enabled, :color
+      alias_method :color_enabled=, :color=
+      define_predicate_for :color_enabled, :color
+
+      def libs=(libs)
+        libs.map do |lib|
+          @libs.unshift lib
+          $LOAD_PATH.unshift lib
+        end
+      end
+
+      def requires=(paths)
+        RSpec.deprecate("RSpec::Core::Configuration#requires=(paths)",
+                        :replacement => "paths.each {|path| require path}")
+        paths.map {|path| require path}
+        @requires += paths
+      end
+
+      # Run examples defined on `line_numbers` in all files to run.
+      def line_numbers=(line_numbers)
+        filter_run :line_numbers => line_numbers.map{|l| l.to_i}
+      end
+
+      def line_numbers
+        filter.fetch(:line_numbers,[])
+      end
+
+      def full_description=(description)
+        filter_run :full_description => Regexp.union(*Array(description).map {|d| Regexp.new(d) })
+      end
+
+      def full_description
+        filter.fetch :full_description, nil
+      end
+
+      # @overload add_formatter(formatter)
+      #
+      # Adds a formatter to the formatters collection. `formatter` can be a
+      # string representing any of the built-in formatters (see
+      # `built_in_formatter`), or a custom formatter class.
+      #
+      # ### Note
+      #
+      # For internal purposes, `add_formatter` also accepts the name of a class
+      # and paths to use for output streams, but you should consider that a
+      # private api that may change at any time without notice.
+      def add_formatter(formatter_to_use, *paths)
+        formatter_class =
+          built_in_formatter(formatter_to_use) ||
+          custom_formatter(formatter_to_use) ||
+          (raise ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?.")
+
+        paths << output_stream if paths.empty?
+        formatters << formatter_class.new(*paths.map {|p| String === p ? file_at(p) : p})
+      end
+
+      alias_method :formatter=, :add_formatter
+
+      def formatters
+        @formatters ||= []
+      end
+
+      def reporter
+        @reporter ||= begin
+                        add_formatter('progress') if formatters.empty?
+                        add_formatter(RSpec::Core::Formatters::DeprecationFormatter, deprecation_stream, output_stream)
+                        Reporter.new(self, *formatters)
+                      end
+      end
+
+      # @api private
+      #
+      # Defaults `profile_examples` to 10 examples when `@profile_examples` is `true`.
+      #
+      def profile_examples
+        profile = value_for(:profile_examples, @profile_examples)
+        if profile && !profile.is_a?(Integer)
+          10
+        else
+          profile
+        end
+      end
+
+      # @private
+      def files_or_directories_to_run=(*files)
+        files = files.flatten
+        files << default_path if (command == 'rspec' || Runner.running_in_drb?) && default_path && files.empty?
+        self.files_to_run = get_files_to_run(files)
+      end
+
+      # Creates a method that delegates to `example` including the submitted
+      # `args`. Used internally to add variants of `example` like `pending`:
+      #
+      # @example
+      #     alias_example_to :pending, :pending => true
+      #
+      #     # This lets you do this:
+      #
+      #     describe Thing do
+      #       pending "does something" do
+      #         thing = Thing.new
+      #       end
+      #     end
+      #
+      #     # ... which is the equivalent of
+      #
+      #     describe Thing do
+      #       it "does something", :pending => true do
+      #         thing = Thing.new
+      #       end
+      #     end
+      def alias_example_to(new_name, *args)
+        extra_options = Metadata.build_hash_from(args)
+        RSpec::Core::ExampleGroup.alias_example_to(new_name, extra_options)
+      end
+
+      # Define an alias for it_should_behave_like that allows different
+      # language (like "it_has_behavior" or "it_behaves_like") to be
+      # employed when including shared examples.
+      #
+      # Example:
+      #
+      #     alias_it_behaves_like_to(:it_has_behavior, 'has behavior:')
+      #
+      # allows the user to include a shared example group like:
+      #
+      #     describe Entity do
+      #       it_has_behavior 'sortability' do
+      #         let(:sortable) { Entity.new }
+      #       end
+      #     end
+      #
+      # which is reported in the output as:
+      #
+      #     Entity
+      #       has behavior: sortability
+      #         # sortability examples here
+      def alias_it_behaves_like_to(new_name, report_label = '')
+        RSpec::Core::ExampleGroup.alias_it_behaves_like_to(new_name, report_label)
+      end
+
+      alias_method :alias_it_should_behave_like_to, :alias_it_behaves_like_to
+
+      # Adds key/value pairs to the `inclusion_filter`. If `args`
+      # includes any symbols that are not part of the hash, each symbol
+      # is treated as a key in the hash with the value `true`.
+      #
+      # ### Note
+      #
+      # Filters set using this method can be overridden from the command line
+      # or config files (e.g. `.rspec`).
+      #
+      # @example
+      #     # given this declaration
+      #     describe "something", :foo => 'bar' do
+      #       # ...
+      #     end
+      #
+      #     # any of the following will include that group
+      #     config.filter_run_including :foo => 'bar'
+      #     config.filter_run_including :foo => /^ba/
+      #     config.filter_run_including :foo => lambda {|v| v == 'bar'}
+      #     config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+      #
+      #     # given a proc with an arity of 1, the lambda is passed the value related to the key, e.g.
+      #     config.filter_run_including :foo => lambda {|v| v == 'bar'}
+      #
+      #     # given a proc with an arity of 2, the lambda is passed the value related to the key,
+      #     # and the metadata itself e.g.
+      #     config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+      #
+      #     filter_run_including :foo # same as filter_run_including :foo => true
+      def filter_run_including(*args)
+        filter_manager.include_with_low_priority Metadata.build_hash_from(args)
+      end
+
+      alias_method :filter_run, :filter_run_including
+
+      # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't
+      # want any inclusion filter at all.
+      #
+      # ### Warning
+      #
+      # This overrides any inclusion filters/tags set on the command line or in
+      # configuration files.
+      def inclusion_filter=(filter)
+        filter_manager.include! Metadata.build_hash_from([filter])
+      end
+
+      alias_method :filter=, :inclusion_filter=
+
+      # Returns the `inclusion_filter`. If none has been set, returns an empty
+      # hash.
+      def inclusion_filter
+        filter_manager.inclusions
+      end
+
+      alias_method :filter, :inclusion_filter
+
+      # Adds key/value pairs to the `exclusion_filter`. If `args`
+      # includes any symbols that are not part of the hash, each symbol
+      # is treated as a key in the hash with the value `true`.
+      #
+      # ### Note
+      #
+      # Filters set using this method can be overridden from the command line
+      # or config files (e.g. `.rspec`).
+      #
+      # @example
+      #     # given this declaration
+      #     describe "something", :foo => 'bar' do
+      #       # ...
+      #     end
+      #
+      #     # any of the following will exclude that group
+      #     config.filter_run_excluding :foo => 'bar'
+      #     config.filter_run_excluding :foo => /^ba/
+      #     config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
+      #     config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
+      #
+      #     # given a proc with an arity of 1, the lambda is passed the value related to the key, e.g.
+      #     config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
+      #
+      #     # given a proc with an arity of 2, the lambda is passed the value related to the key,
+      #     # and the metadata itself e.g.
+      #     config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
+      #
+      #     filter_run_excluding :foo # same as filter_run_excluding :foo => true
+      def filter_run_excluding(*args)
+        filter_manager.exclude_with_low_priority Metadata.build_hash_from(args)
+      end
+
+      # Clears and reassigns the `exclusion_filter`. Set to `nil` if you don't
+      # want any exclusion filter at all.
+      #
+      # ### Warning
+      #
+      # This overrides any exclusion filters/tags set on the command line or in
+      # configuration files.
+      def exclusion_filter=(filter)
+        filter_manager.exclude! Metadata.build_hash_from([filter])
+      end
+
+      # Returns the `exclusion_filter`. If none has been set, returns an empty
+      # hash.
+      def exclusion_filter
+        filter_manager.exclusions
+      end
+
+      # Tells RSpec to include `mod` in example groups. Methods defined in
+      # `mod` are exposed to examples (not example groups).  Use `filters` to
+      # constrain the groups in which to include the module.
+      #
+      # @example
+      #
+      #     module AuthenticationHelpers
+      #       def login_as(user)
+      #         # ...
+      #       end
+      #     end
+      #
+      #     module UserHelpers
+      #       def users(username)
+      #         # ...
+      #       end
+      #     end
+      #
+      #     RSpec.configure do |config|
+      #       config.include(UserHelpers) # included in all modules
+      #       config.include(AuthenticationHelpers, :type => :request)
+      #     end
+      #
+      #     describe "edit profile", :type => :request do
+      #       it "can be viewed by owning user" do
+      #         login_as users(:jdoe)
+      #         get "/profiles/jdoe"
+      #         assert_select ".username", :text => 'jdoe'
+      #       end
+      #     end
+      #
+      # @see #extend
+      def include(mod, *filters)
+        include_or_extend_modules << [:include, mod, Metadata.build_hash_from(filters)]
+      end
+
+      # Tells RSpec to extend example groups with `mod`.  Methods defined in
+      # `mod` are exposed to example groups (not examples).  Use `filters` to
+      # constrain the groups to extend.
+      #
+      # Similar to `include`, but behavior is added to example groups, which
+      # are classes, rather than the examples, which are instances of those
+      # classes.
+      #
+      # @example
+      #
+      #     module UiHelpers
+      #       def run_in_browser
+      #         # ...
+      #       end
+      #     end
+      #
+      #     RSpec.configure do |config|
+      #       config.extend(UiHelpers, :type => :request)
+      #     end
+      #
+      #     describe "edit profile", :type => :request do
+      #       run_in_browser
+      #
+      #       it "does stuff in the client" do
+      #         # ...
+      #       end
+      #     end
+      #
+      # @see #include
+      def extend(mod, *filters)
+        include_or_extend_modules << [:extend, mod, Metadata.build_hash_from(filters)]
+      end
+
+      # @private
+      #
+      # Used internally to extend a group with modules using `include` and/or
+      # `extend`.
+      def configure_group(group)
+        include_or_extend_modules.each do |include_or_extend, mod, filters|
+          next unless filters.empty? || group.any_apply?(filters)
+          send("safe_#{include_or_extend}", mod, group)
+        end
+      end
+
+      # @private
+      def safe_include(mod, host)
+        host.send(:include,mod) unless host < mod
+      end
+
+      # @private
+      def setup_load_path_and_require(paths)
+        directories = ['lib', default_path].select { |p| File.directory? p }
+        RSpec::Core::RubyProject.add_to_load_path(*directories)
+        paths.each {|path| require path}
+        @requires += paths
+      end
+
+      # @private
+      if RUBY_VERSION.to_f >= 1.9
+        def safe_extend(mod, host)
+          host.extend(mod) unless (class << host; self; end) < mod
+        end
+      else
+        def safe_extend(mod, host)
+          host.extend(mod) unless (class << host; self; end).included_modules.include?(mod)
+        end
+      end
+
+      # @private
+      def configure_mock_framework
+        RSpec::Core::ExampleGroup.send(:include, mock_framework)
+      end
+
+      # @private
+      def configure_expectation_framework
+        expectation_frameworks.each do |framework|
+          RSpec::Core::ExampleGroup.send(:include, framework)
+        end
+      end
+
+      # @private
+      def load_spec_files
+        files_to_run.uniq.each {|f| load File.expand_path(f) }
+        @spec_files_loaded = true
+      end
+
+      # @private
+      DEFAULT_FORMATTER = lambda { |string| string }
+
+      # Formats the docstring output using the block provided.
+      #
+      # @example
+      #   # This will strip the descriptions of both examples and example groups.
+      #   RSpec.configure do |config|
+      #     config.format_docstrings { |s| s.strip }
+      #   end
+      def format_docstrings(&block)
+        @format_docstrings_block = block_given? ? block : DEFAULT_FORMATTER
+      end
+
+      # @private
+      def format_docstrings_block
+        @format_docstrings_block ||= DEFAULT_FORMATTER
+      end
+
+      # @private
+      def self.delegate_to_ordering_manager(*methods)
+        methods.each do |method|
+          define_method method do |*args, &block|
+            ordering_manager.__send__(method, *args, &block)
+          end
+        end
+      end
+
+      # @macro delegate_to_ordering_manager
+      #
+      # Sets the seed value and sets the default global ordering to random.
+      delegate_to_ordering_manager :seed=
+
+      # @macro delegate_to_ordering_manager
+      # Seed for random ordering (default: generated randomly each run).
+      #
+      # When you run specs with `--order random`, RSpec generates a random seed
+      # for the randomization and prints it to the `output_stream` (assuming
+      # you're using RSpec's built-in formatters). If you discover an ordering
+      # dependency (i.e. examples fail intermittently depending on order), set
+      # this (on Configuration or on the command line with `--seed`) to run
+      # using the same seed while you debug the issue.
+      #
+      # We recommend, actually, that you use the command line approach so you
+      # don't accidentally leave the seed encoded.
+      delegate_to_ordering_manager :seed
+
+      # @macro delegate_to_ordering_manager
+      #
+      # Sets the default global order and, if order is `'rand:<seed>'`, also sets the seed.
+      delegate_to_ordering_manager :order=
+
+      # @macro delegate_to_ordering_manager
+      # Registers a named ordering strategy that can later be
+      # used to order an example group's subgroups by adding
+      # `:order => <name>` metadata to the example group.
+      #
+      # @param name [Symbol] The name of the ordering.
+      # @yield Block that will order the given examples or example groups
+      # @yieldparam list [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The examples or groups to order
+      # @yieldreturn [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The re-ordered examples or groups
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.register_ordering :reverse do |list|
+      #       list.reverse
+      #     end
+      #   end
+      #
+      #   describe MyClass, :order => :reverse do
+      #     # ...
+      #   end
+      #
+      # @note Pass the symbol `:global` to set the ordering strategy that
+      #   will be used to order the top-level example groups and any example
+      #   groups that do not have declared `:order` metadata.
+      delegate_to_ordering_manager :register_ordering
+
+      # @private
+      delegate_to_ordering_manager :seed_used?, :ordering_registry
+
+      # Set Ruby warnings on or off
+      def warnings= value
+        $VERBOSE = !!value
+      end
+
+      def warnings
+        $VERBOSE
+      end
+
+      # Exposes the current running example via the named
+      # helper method. RSpec 2.x exposed this via `example`,
+      # but in RSpec 3.0, the example is instead exposed via
+      # an arg yielded to `it`, `before`, `let`, etc. However,
+      # some extension gems (such as Capybara) depend on the
+      # RSpec 2.x's `example` method, so this config option
+      # can be used to maintain compatibility.
+      #
+      # @param method_name [Symbol] the name of the helper method
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.expose_current_running_example_as :example
+      #   end
+      #
+      #   describe MyClass do
+      #     before do
+      #       # `example` can be used here because of the above config.
+      #       do_something if example.metadata[:type] == "foo"
+      #     end
+      #   end
+      def expose_current_running_example_as(method_name)
+        ExposeCurrentExample.module_eval do
+          extend RSpec::SharedContext
+          let(method_name) { |ex| ex }
+        end
+
+        include ExposeCurrentExample
+      end
+
+      module ExposeCurrentExample; end
+
+      # Turns deprecation warnings into errors, in order to surface
+      # the full backtrace of the call site. This can be useful when
+      # you need more context to address a deprecation than the
+      # single-line call site normally provided.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.raise_errors_for_deprecations!
+      #   end
+      def raise_errors_for_deprecations!
+        self.deprecation_stream = Formatters::DeprecationFormatter::RaiseErrorStream.new
+      end
+
+    private
+
+      def get_files_to_run(paths)
+        FlatMap.flat_map(paths) do |path|
+          path = path.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+          File.directory?(path) ? gather_directories(path) : extract_location(path)
+        end.sort
+      end
+
+      def gather_directories(path)
+        stripped = "{#{pattern.gsub(/\s*,\s*/, ',')}}"
+        files    = pattern =~ /^#{Regexp.escape path}/ ? Dir[stripped] : Dir["#{path}/#{stripped}"]
+        files.sort
+      end
+
+      def extract_location(path)
+        if path =~ /^(.*?)((?:\:\d+)+)$/
+          path, lines = $1, $2[1..-1].split(":").map{|n| n.to_i}
+          filter_manager.add_location path, lines
+        end
+        path
+      end
+
+      def command
+        $0.split(File::SEPARATOR).last
+      end
+
+      def value_for(key, default=nil)
+        @preferred_options.has_key?(key) ? @preferred_options[key] : default
+      end
+
+      def assert_no_example_groups_defined(config_option)
+        if RSpec.world.example_groups.any?
+          raise MustBeConfiguredBeforeExampleGroupsError.new(
+            "RSpec's #{config_option} configuration option must be configured before " +
+            "any example groups are defined, but you have already defined a group."
+          )
+        end
+      end
+
+      def output_to_tty?(output=output_stream)
+        tty? || (output.respond_to?(:tty?) && output.tty?)
+      end
+
+      def built_in_formatter(key)
+        case key.to_s
+        when 'd', 'doc', 'documentation', 's', 'n', 'spec', 'nested'
+          require 'rspec/core/formatters/documentation_formatter'
+          RSpec::Core::Formatters::DocumentationFormatter
+        when 'h', 'html'
+          require 'rspec/core/formatters/html_formatter'
+          RSpec::Core::Formatters::HtmlFormatter
+        when 'p', 'progress'
+          require 'rspec/core/formatters/progress_formatter'
+          RSpec::Core::Formatters::ProgressFormatter
+        when 'j', 'json'
+          require 'rspec/core/formatters/json_formatter'
+          RSpec::Core::Formatters::JsonFormatter
+        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
+end