spree 0.8.1 → 0.8.2

data/vendor/plugins/rspec/lib/spec/expectations/errors.rb

@@ -1,12 +0,0 @@
-module Spec
-  module Expectations
-    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
-    # will report unmet RSpec expectations as failures rather than errors.
-    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
-      eval(c) rescue nil
-    end.compact.first
-    
-    class ExpectationNotMetError < superclass
-    end
-  end
-end

data/vendor/plugins/rspec/lib/spec/expectations/extensions.rb

@@ -1,2 +0,0 @@
-require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/string_and_symbol'

data/vendor/plugins/rspec/lib/spec/expectations/extensions/object.rb

@@ -1,63 +0,0 @@
-module Spec
-  module Expectations
-    # rspec adds #should and #should_not to every Object (and,
-    # implicitly, every Class).
-    module ObjectExpectations
-      # :call-seq:
-      #   should(matcher)
-      #   should == expected
-      #   should === expected
-      #   should =~ expected
-      #
-      #   receiver.should(matcher)
-      #     => Passes if matcher.matches?(receiver)
-      #
-      #   receiver.should == expected #any value
-      #     => Passes if (receiver == expected)
-      #
-      #   receiver.should === expected #any value
-      #     => Passes if (receiver === expected)
-      #
-      #   receiver.should =~ regexp
-      #     => Passes if (receiver =~ regexp)
-      #
-      # See Spec::Matchers for more information about matchers
-      #
-      # == Warning
-      #
-      # NOTE that this does NOT support receiver.should != expected.
-      # Instead, use receiver.should_not == expected
-      def should(matcher=nil, &block)
-        ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
-      end
-
-      # :call-seq:
-      #   should_not(matcher)
-      #   should_not == expected
-      #   should_not === expected
-      #   should_not =~ expected
-      #
-      #   receiver.should_not(matcher)
-      #     => Passes unless matcher.matches?(receiver)
-      #
-      #   receiver.should_not == expected
-      #     => Passes unless (receiver == expected)
-      #
-      #   receiver.should_not === expected
-      #     => Passes unless (receiver === expected)
-      #
-      #   receiver.should_not =~ regexp
-      #     => Passes unless (receiver =~ regexp)
-      #
-      # See Spec::Matchers for more information about matchers
-      def should_not(matcher=nil, &block)
-        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
-      end
-
-    end
-  end
-end
-
-class Object
-  include Spec::Expectations::ObjectExpectations
-end

data/vendor/plugins/rspec/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -1,17 +0,0 @@
-module Spec
-  module Expectations
-    module StringHelpers
-      def starts_with?(prefix)
-        to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
-      end
-    end
-  end
-end
-
-class String
-  include Spec::Expectations::StringHelpers
-end
-
-class Symbol
-  include Spec::Expectations::StringHelpers
-end

data/vendor/plugins/rspec/lib/spec/expectations/handler.rb

@@ -1,47 +0,0 @@
-module Spec
-  module Expectations
-    class InvalidMatcherError < ArgumentError; end        
-    
-    class ExpectationMatcherHandler        
-      def self.handle_matcher(actual, matcher, &block)
-        ::Spec::Matchers.last_should = "should"
-        return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        unless matcher.respond_to?(:matches?)
-          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-        end
-        
-        match = matcher.matches?(actual, &block)
-        ::Spec::Matchers.last_matcher = matcher
-        Spec::Expectations.fail_with(matcher.failure_message) unless match
-        match
-      end
-    end
-
-    class NegativeExpectationMatcherHandler
-      def self.handle_matcher(actual, matcher, &block)
-        ::Spec::Matchers.last_should = "should not"
-        return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
-        
-        unless matcher.respond_to?(:matches?)
-          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-        end
-
-        unless matcher.respond_to?(:negative_failure_message)
-          Spec::Expectations.fail_with(
-<<-EOF
-Matcher does not support should_not.
-See Spec::Matchers for more information
-about matchers.
-EOF
-)
-        end
-        match = matcher.matches?(actual, &block)
-        ::Spec::Matchers.last_matcher = matcher
-        Spec::Expectations.fail_with(matcher.negative_failure_message) if match
-        match
-      end
-    end
-  end
-end
-

data/vendor/plugins/rspec/lib/spec/interop/test.rb

@@ -1,12 +0,0 @@
-require 'test/unit'
-require 'test/unit/testresult'
-
-require 'spec/interop/test/unit/testcase'
-require 'spec/interop/test/unit/testsuite_adapter'
-require 'spec/interop/test/unit/autorunner'
-require 'spec/interop/test/unit/testresult'
-require 'spec/interop/test/unit/ui/console/testrunner'
-
-Spec::Example::ExampleGroupFactory.default(Test::Unit::TestCase)
-
-Test::Unit.run = true

data/vendor/plugins/rspec/lib/spec/interop/test/unit/autorunner.rb

@@ -1,6 +0,0 @@
-class Test::Unit::AutoRunner
-  remove_method :process_args
-  def process_args(argv)
-    true
-  end
-end

data/vendor/plugins/rspec/lib/spec/interop/test/unit/testcase.rb

@@ -1,73 +0,0 @@
-require 'test/unit/testcase'
-
-module Test
-  module Unit
-    # This extension of the standard Test::Unit::TestCase makes RSpec
-    # available from within, so that you can do things like:
-    #
-    # require 'test/unit'
-    # require 'spec'
-    #
-    # class MyTest < Test::Unit::TestCase
-    #   it "should work with Test::Unit assertions" do
-    #     assert_equal 4, 2+1
-    #   end
-    #
-    #   def test_should_work_with_rspec_expectations
-    #     (3+1).should == 5
-    #   end
-    # end
-    #
-    # See also Spec::Example::ExampleGroup
-    class TestCase
-      extend Spec::Example::ExampleGroupMethods
-      include Spec::Example::ExampleMethods
-
-      def self.suite
-        Test::Unit::TestSuiteAdapter.new(self)
-      end
-
-      def self.example_method?(method_name)
-        should_method?(method_name) || test_method?(method_name)
-      end
-
-      def self.test_method?(method_name)
-        method_name =~ /^test[_A-Z]./ && (
-          instance_method(method_name).arity == 0 ||
-          instance_method(method_name).arity == -1
-        )
-      end
-
-      before(:each) {setup}
-      after(:each) {teardown}
-
-      def initialize(defined_description, options={}, &implementation)
-        @_defined_description = defined_description
-        
-        # TODO - examples fail in rspec-rails if we remove "|| pending_implementation"
-        #      - find a way to fail without it in rspec's code examples
-        @_implementation = implementation || pending_implementation
-
-        @_result = ::Test::Unit::TestResult.new
-        # @method_name is important to set here because it complies with Test::Unit's interface.
-        # Some Test::Unit extensions depend on @method_name being present.
-        @method_name = @_defined_description
-
-        # TODO - this is necessary to run single examples in rspec-rails, but I haven't
-        # found a good way to write a failing example just within rspec core
-        @_backtrace = caller
-      end
-
-      def run(ignore_this_argument=nil)
-        super()
-      end
-
-    private
-
-      def pending_implementation
-        error = Spec::Example::NotYetImplementedError.new(caller)
-        lambda { raise(error) }
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/lib/spec/interop/test/unit/testresult.rb

@@ -1,6 +0,0 @@
-class Test::Unit::TestResult
-  alias_method :tu_passed?, :passed?
-  def passed?
-    return tu_passed? & ::Spec::Runner.run
-  end
-end

data/vendor/plugins/rspec/lib/spec/interop/test/unit/testsuite_adapter.rb

@@ -1,34 +0,0 @@
-module Test
-  module Unit
-    class TestSuiteAdapter < TestSuite
-      attr_reader :example_group, :examples
-      alias_method :tests, :examples
-      def initialize(example_group)
-        @example_group = example_group
-        @examples = example_group.examples
-      end
-
-      def name
-        example_group.description
-      end
-
-      def run(*args)
-        return true unless args.empty?
-        example_group.run(Spec::Runner.options)
-      end
-
-      def size
-        example_group.number_of_examples
-      end
-
-      def delete(example)
-        examples.delete example
-      end
-
-      def empty?
-        examples.empty?
-      end
-    end
-  end
-end
-

data/vendor/plugins/rspec/lib/spec/interop/test/unit/ui/console/testrunner.rb

@@ -1,61 +0,0 @@
-require 'test/unit/ui/console/testrunner'
-
-module Test
-  module Unit
-    module UI
-      module Console
-        class TestRunner
-
-          alias_method :started_without_rspec, :started
-          def started_with_rspec(result)
-            @result = result
-            @need_to_output_started = true
-          end
-          alias_method :started, :started_with_rspec
-
-          alias_method :test_started_without_rspec, :test_started
-          def test_started_with_rspec(name)
-            if @need_to_output_started
-              if @rspec_io
-                @rspec_io.rewind
-                output(@rspec_io.read)
-              end
-              output("Started")
-              @need_to_output_started = false
-            end
-            test_started_without_rspec(name)
-          end
-          alias_method :test_started, :test_started_with_rspec
-
-          alias_method :test_finished_without_rspec, :test_finished
-          def test_finished_with_rspec(name)
-            test_finished_without_rspec(name)
-            @ran_test = true
-          end
-          alias_method :test_finished, :test_finished_with_rspec
-
-          alias_method :finished_without_rspec, :finished
-          def finished_with_rspec(elapsed_time)
-            @ran_test ||= false
-            if @ran_test
-              finished_without_rspec(elapsed_time)
-            end
-          end
-          alias_method :finished, :finished_with_rspec
-          
-          alias_method :setup_mediator_without_rspec, :setup_mediator
-          def setup_mediator_with_rspec
-            orig_io = @io
-            @io = StringIO.new
-            setup_mediator_without_rspec
-          ensure
-            @rspec_io = @io
-            @io = orig_io
-          end
-          alias_method :setup_mediator, :setup_mediator_with_rspec
-          
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/lib/spec/matchers.rb

@@ -1,141 +0,0 @@
-require 'spec/matchers/operator_matcher'
-require 'spec/matchers/generated_descriptions'
-require 'spec/matchers/errors'
-require 'spec/matchers/method_missing'
-require 'spec/matchers/simple_matcher'
-require 'spec/matchers/be'
-require 'spec/matchers/be_close'
-require 'spec/matchers/change'
-require 'spec/matchers/match_array'
-require 'spec/matchers/eql'
-require 'spec/matchers/equal'
-require 'spec/matchers/exist'
-require 'spec/matchers/has'
-require 'spec/matchers/have'
-require 'spec/matchers/include'
-require 'spec/matchers/match'
-require 'spec/matchers/raise_error'
-require 'spec/matchers/respond_to'
-require 'spec/matchers/satisfy'
-require 'spec/matchers/throw_symbol'
-require 'spec/matchers/wrap_expectation'
-
-module Spec
-
-  # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
-  # is any object that responds to the following methods:
-  #
-  #   matches?(actual)
-  #   failure_message
-  #   negative_failure_message #optional
-  #   description #optional
-  #
-  # See Spec::Expectations to learn how to use these as Expectation Matchers.
-  # See Spec::Mocks to learn how to use them as Mock Argument Constraints.
-  #
-  # == Predicates
-  #
-  # In addition to those Expression Matchers that are defined explicitly, RSpec will
-  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
-  # a much more natural language feel. 
-  #
-  # A Ruby predicate is a method that ends with a "?" and returns true or false.
-  # Common examples are +empty?+, +nil?+, and +instance_of?+.
-  #
-  # All you need to do is write +should be_+ followed by the predicate without
-  # the question mark, and RSpec will figure it out from there. For example:
-  #
-  #   [].should be_empty => [].empty? #passes
-  #   [].should_not be_empty => [].empty? #fails
-  #
-  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
-  # and "be_an_", making your specs read much more naturally:
-  #
-  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
-  #
-  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
-  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
-  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
-  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
-  #
-  # RSpec will also create custom matchers for predicates like +has_key?+. To
-  # use this feature, just state that the object should have_key(:key) and RSpec will
-  # call has_key?(:key) on the target. For example:
-  #
-  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
-  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
-  #
-  # You can use this feature to invoke any predicate that begins with "has_", whether it is
-  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
-  #
-  # == Custom Expectation Matchers
-  #
-  # When you find that none of the stock Expectation Matchers provide a natural
-  # feeling expectation, you can very easily write your own.
-  #
-  # For example, imagine that you are writing a game in which players can
-  # be in various zones on a virtual board. To specify that bob should
-  # be in zone 4, you could say:
-  #
-  #   bob.current_zone.should eql(Zone.new("4"))
-  #
-  # But you might find it more expressive to say:
-  #
-  #   bob.should be_in_zone("4")
-  #
-  # and/or
-  #
-  #   bob.should_not be_in_zone("3")
-  #
-  # To do this, you would need to write a class like this:
-  #
-  #   class BeInZone
-  #     def initialize(expected)
-  #       @expected = expected
-  #     end
-  #     def matches?(target)
-  #       @target = target
-  #       @target.current_zone.eql?(Zone.new(@expected))
-  #     end
-  #     def failure_message
-  #       "expected #{@target.inspect} to be in Zone #{@expected}"
-  #     end
-  #     def negative_failure_message
-  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
-  #     end
-  #   end
-  #
-  # ... and a method like this:
-  #
-  #   def be_in_zone(expected)
-  #     BeInZone.new(expected)
-  #   end
-  #
-  # And then expose the method to your specs. This is normally done
-  # by including the method and the class in a module, which is then
-  # included in your spec:
-  #
-  #   module CustomGameMatchers
-  #     class BeInZone
-  #       ...
-  #     end
-  #
-  #     def be_in_zone(expected)
-  #       ...
-  #     end
-  #   end
-  #
-  #   describe "Player behaviour" do
-  #     include CustomGameMatchers
-  #     ...
-  #   end
-  #
-  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
-  # from your spec file(s):
-  #
-  #   Spec::Runner.configure do |config|
-  #     config.include(CustomGameMatchers)
-  #   end
-  #
-  module Matchers; end
-end