rspec 0.0.10

data/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -0,0 +1,17 @@
+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/lib/spec/expectations/handler.rb

@@ -0,0 +1,62 @@
+module Spec
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    module MatcherHandlerHelper
+      def describe_matcher(matcher)
+        matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
+      end
+    end
+    
+    class ExpectationMatcherHandler        
+      class << self
+        include MatcherHandlerHelper
+        def handle_matcher(actual, matcher, &block)
+          if :use_operator_matcher == matcher
+            return Spec::Matchers::PositiveOperatorMatcher.new(actual)
+          end
+
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+          
+          match = matcher.matches?(actual, &block)
+          ::Spec::Matchers.generated_description = "should #{describe_matcher(matcher)}"
+          Spec::Expectations.fail_with(matcher.failure_message) unless match
+          match
+        end
+      end
+    end
+
+    class NegativeExpectationMatcherHandler
+      class << self
+        include MatcherHandlerHelper
+        def handle_matcher(actual, matcher, &block)
+          if :use_operator_matcher == matcher
+            return Spec::Matchers::NegativeOperatorMatcher.new(actual)
+          end
+          
+          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.generated_description = "should not #{describe_matcher(matcher)}"
+          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+          match
+        end
+      end
+    end
+
+  end
+end
+

data/lib/spec/extensions.rb

@@ -0,0 +1,4 @@
+require 'spec/extensions/object'
+require 'spec/extensions/class'
+require 'spec/extensions/main'
+require 'spec/extensions/metaclass'

data/lib/spec/extensions/class.rb

@@ -0,0 +1,24 @@
+class Class
+  # Creates a new subclass of self, with a name "under" our own name.
+  # Example:
+  #
+  #   x = Foo::Bar.subclass('Zap'){}
+  #   x.name # => Foo::Bar::Zap_1
+  #   x.superclass.name # => Foo::Bar
+  def subclass(base_name, &body)
+    klass = Class.new(self)
+    class_name = "#{base_name}_#{class_count!}"
+    instance_eval do
+      const_set(class_name, klass)
+    end
+    klass.instance_eval(&body)
+    klass
+  end
+
+  private
+  def class_count!
+    @class_count ||= 0
+    @class_count += 1
+    @class_count
+  end
+end

data/lib/spec/extensions/main.rb

@@ -0,0 +1,102 @@
+module Spec
+  module Extensions
+    module Main
+      # Creates and returns a class that includes the ExampleGroupMethods
+      # module. Which ExampleGroup type is created depends on the directory of the file
+      # calling this method. For example, Spec::Rails will use different
+      # classes for specs living in <tt>spec/models</tt>,
+      # <tt>spec/helpers</tt>, <tt>spec/views</tt> and
+      # <tt>spec/controllers</tt>.
+      #
+      # It is also possible to override autodiscovery of the example group
+      # type with an options Hash as the last argument:
+      #
+      #   describe "name", :type => :something_special do ...
+      #
+      # The reason for using different behaviour classes is to have different
+      # matcher methods available from within the <tt>describe</tt> block.
+      #
+      # See Spec::Example::ExampleFactory#register for details about how to
+      # register special implementations.
+      #
+      def describe(*args, &block)
+        raise ArgumentError if args.empty?
+        raise ArgumentError unless block
+        args << {} unless Hash === args.last
+        args.last[:spec_path] = caller(0)[1]
+        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
+      end
+      alias :context :describe
+      
+      # Creates an example group that can be shared by other example groups
+      #
+      # == Examples
+      #
+      #  share_examples_for "All Editions" do
+      #    it "all editions behaviour" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like "All Editions"
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_examples_for(name, &block)
+        describe(name, :shared => true, &block)
+      end
+      
+      alias :shared_examples_for :share_examples_for
+      
+      # Creates a Shared Example Group and assigns it to a constant
+      #
+      #  share_as :AllEditions do
+      #    it "should do all editions stuff" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like AllEditions
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      #
+      # And, for those of you who prefer to use something more like Ruby, you
+      # can just include the module directly
+      #
+      #  describe SmallEdition do
+      #    include AllEditions
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_as(name, &block)
+        begin
+          Object.const_set(name, share_examples_for(name, &block))
+        rescue NameError => e
+          raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
+        end
+      end
+
+    private
+    
+      def rspec_options
+        $rspec_options ||= begin; \
+          parser = ::Spec::Runner::OptionParser.new(STDERR, STDOUT); \
+          parser.order!(ARGV); \
+          $rspec_options = parser.options; \
+        end
+        $rspec_options
+      end
+      
+      def init_rspec_options(options)
+        $rspec_options = options if $rspec_options.nil?
+      end
+    end
+  end
+end
+
+include Spec::Extensions::Main

data/lib/spec/extensions/metaclass.rb

@@ -0,0 +1,7 @@
+module Spec
+  module MetaClass
+    def metaclass
+      class << self; self; end
+    end
+  end
+end

data/lib/spec/extensions/object.rb

@@ -0,0 +1,6 @@
+class Object
+  def args_and_options(*args)
+    options = Hash === args.last ? args.pop : {}
+    return args, options
+  end
+end

data/lib/spec/interop/test.rb

@@ -0,0 +1,12 @@
+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/lib/spec/interop/test/unit/autorunner.rb

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

data/lib/spec/interop/test/unit/testcase.rb

@@ -0,0 +1,61 @@
+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
+
+      before(:each) {setup}
+      after(:each) {teardown}
+
+      class << self
+        def suite
+          Test::Unit::TestSuiteAdapter.new(self)
+        end
+
+        def example_method?(method_name)
+          should_method?(method_name) || test_method?(method_name)
+        end
+
+        def test_method?(method_name)
+          method_name =~ /^test[_A-Z]./ && (
+            instance_method(method_name).arity == 0 ||
+            instance_method(method_name).arity == -1
+          )
+        end
+      end
+
+      def initialize(defined_description, &implementation)
+        @_defined_description = defined_description
+        @_implementation = 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
+      end
+
+      def run(ignore_this_argument=nil)
+        super()
+      end
+    end
+  end
+end

data/lib/spec/interop/test/unit/testresult.rb

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

data/lib/spec/interop/test/unit/testsuite_adapter.rb

@@ -0,0 +1,34 @@
+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
+      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/lib/spec/interop/test/unit/ui/console/testrunner.rb

@@ -0,0 +1,61 @@
+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/lib/spec/matchers.rb

@@ -0,0 +1,156 @@
+require 'spec/matchers/simple_matcher'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/change'
+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/operator_matcher'
+
+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
+    module ModuleMethods
+      attr_accessor :generated_description
+
+      def clear_generated_description
+        self.generated_description = nil
+      end
+    end
+
+    extend ModuleMethods
+
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+
+    class MatcherError < StandardError
+    end
+    
+  end
+end