dchelimsky-rspec 1.1.11.1 → 1.1.11.2

data/lib/spec/example/example_group_methods.rb

@@ -13,13 +13,13 @@ module Spec
       end
 
       def self.description_text(*args)
-        args.inject("") do |result, arg|
-          result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
-          result << arg.to_s
+        args.inject("") do |description, arg|
+          description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
+          description << arg.to_s
         end
       end
 
-      attr_reader :description_text, :description_options, :spec_path
+      attr_reader :description_options, :spec_path
       alias :options :description_options
       
       # Provides the backtrace up to where this example_group was declared.
@@ -42,7 +42,7 @@ WARNING
 
       def inherited(klass)
         super
-        klass.register
+        Spec::Runner.options.add_example_group klass
         Spec::Runner.register_at_exit_hook
       end
       
@@ -61,11 +61,9 @@ WARNING
       #   end
       #
       def describe(*args, &example_group_block)
-        args << {} unless Hash === args.last
         if example_group_block
+          Spec::Example::add_spec_path_to(args)
           options = args.last
-          # Ruby 1.9 - the next line uses example_group_block.binding instead of example_group_block
-          options[:spec_path] = eval("caller(0)[1]", example_group_block.binding) unless options[:spec_path]
           if options[:shared]
             create_shared_example_group(*args, &example_group_block)
           else
@@ -82,12 +80,28 @@ WARNING
       end
       
       def create_subclass(*args, &example_group_block) # :nodoc:
-        self.subclass("Subclass") do
+        subclass("Subclass") do
           set_description(*args)
           module_eval(&example_group_block)
         end
       end
       
+      # 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) # :nodoc:
+        @class_count ||= 0
+        @class_count += 1
+        klass = Class.new(self)
+        class_name = "#{base_name}_#{@class_count}"
+        const_set(class_name, klass)
+        klass.instance_eval(&body)
+        klass
+      end
+      
       # Use this to pull in examples from shared example groups.
       # See Spec::Runner for information about shared example groups.
       def it_should_behave_like(*shared_example_groups)
@@ -147,18 +161,18 @@ WARNING
       alias_method :xit, :xexample
       alias_method :xspecify, :xexample
 
-      def run
-        examples = examples_to_run
-        reporter.add_example_group(self) unless examples_to_run.empty?
+      def run(run_options)
+        examples = examples_to_run(run_options)
+        run_options.reporter.add_example_group(self) unless examples.empty?
         return true if examples.empty?
-        return dry_run(examples) if dry_run?
+        return dry_run(examples, run_options) if run_options.dry_run?
 
         plugin_mock_framework
         define_methods_from_predicate_matchers
 
-        success, before_all_instance_variables = run_before_all
-        success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples)
-        success                                = run_after_all(success, after_all_instance_variables)
+        success, before_all_instance_variables = run_before_all(run_options)
+        success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples, run_options)
+        success                                = run_after_all(success, after_all_instance_variables, run_options)
       end
 
       def description
@@ -208,10 +222,10 @@ WARNING
         self
       end
       
-      def examples #:nodoc:
+      def examples(run_options=nil) #:nodoc:
         examples = example_objects.dup
         add_method_examples(examples)
-        Spec::Runner.options.reverse ? examples.reverse : examples
+        (run_options && run_options.reverse) ? examples.reverse : examples
       end
 
       def number_of_examples #:nodoc:
@@ -226,14 +240,6 @@ WARNING
         @after_each_parts = nil
       end
 
-      def register
-        Spec::Runner.options.add_example_group self
-      end
-
-      def unregister #:nodoc:
-        Spec::Runner.options.remove_example_group self
-      end
-
       def run_before_each(example)
         each_ancestor_example_group_class do |example_group_class|
           example.eval_each_fail_fast(example_group_class.before_each_parts)
@@ -247,15 +253,14 @@ WARNING
       end
 
     private
-      def dry_run(examples)
+      def dry_run(examples, run_options)
         examples.each do |example|
-          Spec::Runner.options.reporter.example_started(example)
-          Spec::Runner.options.reporter.example_finished(example)
+          run_options.reporter.example_started(example)
+          run_options.reporter.example_finished(example)
         end
-        return true
       end
 
-      def run_before_all
+      def run_before_all(run_options)
         before_all = new("before(:all)")
         begin
           each_ancestor_example_group_class do |example_group_class|
@@ -263,23 +268,23 @@ WARNING
           end
           return [true, before_all.instance_variable_hash]
         rescue Exception => e
-          reporter.failure(before_all, e)
+          run_options.reporter.failure(before_all, e)
           return [false, before_all.instance_variable_hash]
         end
       end
 
-      def execute_examples(success, instance_variables, examples)
+      def execute_examples(success, instance_variables, examples, run_options)
         return [success, instance_variables] unless success
 
         after_all_instance_variables = instance_variables
         examples.each do |example_group_instance|
-          success &= example_group_instance.execute(Spec::Runner.options, instance_variables)
+          success &= example_group_instance.execute(run_options, instance_variables)
           after_all_instance_variables = example_group_instance.instance_variable_hash
         end
         return [success, after_all_instance_variables]
       end
 
-      def run_after_all(success, instance_variables)
+      def run_after_all(success, instance_variables, run_options)
         after_all = new("after(:all)")
         after_all.set_instance_variables_from_hash(instance_variables)
         each_ancestor_example_group_class(:superclass_first) do |example_group_class|
@@ -287,34 +292,22 @@ WARNING
         end
         return success
       rescue Exception => e
-        reporter.failure(after_all, e)
+        run_options.reporter.failure(after_all, e)
         return false
       end
 
-      def examples_to_run
-        all_examples = examples
-        return all_examples unless specified_examples?
+      def examples_to_run(run_options)
+        all_examples = examples(run_options)
+        return all_examples unless specified_examples?(run_options)
         all_examples.reject do |example|
           matcher = ExampleGroupMethods.matcher_class.
             new(description.to_s, example.description)
-          !matcher.matches?(specified_examples)
+          !matcher.matches?(run_options.examples)
         end
       end
 
-      def specified_examples?
-        specified_examples && !specified_examples.empty?
-      end
-
-      def specified_examples
-        Spec::Runner.options.examples
-      end
-
-      def reporter
-        Spec::Runner.options.reporter
-      end
-
-      def dry_run?
-        Spec::Runner.options.dry_run
+      def specified_examples?(run_options)
+        run_options.examples && !run_options.examples.empty?
       end
 
       def example_objects

data/lib/spec/example/shared_example_group.rb

@@ -34,11 +34,11 @@ module Spec
           existing_example_group = find(new_example_group.description)
           return false unless existing_example_group
           return true if new_example_group.equal?(existing_example_group)
-          return true if spec_path(new_example_group) == spec_path(existing_example_group)
+          return true if expanded_path(new_example_group) == expanded_path(existing_example_group)
           raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
         end
 
-        def spec_path(example_group)
+        def expanded_path(example_group)
           File.expand_path(example_group.spec_path)
         end
       end

data/lib/spec/example.rb

@@ -1,24 +1,173 @@
 module Spec
+  # == Example Groups and Code Examples
+  #
+  # A Code Example is an executable example of how a bit of code is expected
+  # to behave.
+  #
+  # An Example Group is a group of code examples.
+  #
+  # RSpec exposes a DSL to describe groups of examples.
+  #  
+  #   describe Account do
+  #     it "should have a balance of $0" do
+  #       account = Account.new
+  #       account.balance.should == Money.new(0, :dollars)
+  #     end
+  #   end
+  #  
+  # == Before and After
+  #  
+  # You can use the <tt>before()</tt> and <tt>after()</tt> methods to extract
+  # common code within an Example Group. Both methods take an optional scope
+  # argument so you can run the block before :each example or before :all
+  # examples
+  #  
+  #   describe "..." do
+  #     before :all do
+  #       ...
+  #     end
+  #  
+  #     before :each do
+  #       ...
+  #     end
+  #  
+  #     it "should do something" do
+  #       ...
+  #     end
+  #  
+  #     it "should do something else" do
+  #       ...
+  #     end
+  #  
+  #     after :each do
+  #       ...
+  #     end
+  #  
+  #     after :all do
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # The <tt>before :each</tt> block will run before each of the examples, once
+  # for each example. Likewise, the <tt>after :each</tt> block will run after
+  # each of the examples.
+  #  
+  # It is also possible to specify a <tt>before :all</tt> and <tt>after
+  # :all</tt> block that will run only once for each example group, before the
+  # first <code>before :each</code> and after the last <code>after
+  # :each</code> respectively. The use of these is generally discouraged,
+  # because it introduces dependencies between the examples. Still, it might
+  # prove useful for very expensive operations if you know what you are doing.
+  #  
+  # == Local helper methods
+  #  
+  # You can include local helper methods by simply expressing them within an
+  # example group:
+  #  
+  #   describe "..." do
+  #    
+  #     it "..." do
+  #       helper_method
+  #     end
+  #  
+  #     def helper_method
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # == Included helper methods
+  #  
+  # You can include helper methods in multiple example groups by expressing
+  # them within a module, and then including that module in your example
+  # groups:
+  #  
+  #   module AccountExampleHelperMethods
+  #     def helper_method
+  #       ...
+  #     end
+  #   end
+  #  
+  #   describe "A new account" do
+  #     include AccountExampleHelperMethods
+  #     before do
+  #       @account = Account.new
+  #     end
+  #  
+  #     it "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  #  
+  # == Shared Example Groups
+  #  
+  # You can define a shared example group, that may be used on other groups
+  #
+  #  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
+  #
+  # You can also assign the shared group to a module and include that
+  #
+  #  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
   module Example
-    def self.args_and_options(*args)
-      with_options_from(args) do |options|
-        return args, options
+    class << self
+      def args_and_options(*args) # :nodoc:
+        with_options_from(args) do |options|
+          return args, options
+        end
       end
-    end
 
-    def self.scope_from(*args)
-      args[0] || :each
-    end
+      def scope_from(*args) # :nodoc:
+        args[0] || :each
+      end
 
-    def self.scope_and_options(*args)
-      args, options = args_and_options(*args)
-      return scope_from(*args), options
-    end
+      def scope_and_options(*args) # :nodoc:
+        args, options = args_and_options(*args)
+        return scope_from(*args), options
+      end
+
+      def add_spec_path_to(args) # :nodoc:
+        args << {} unless Hash === args.last
+        args.last[:spec_path] ||= caller(0)[2]
+      end
 
-  private
+    private
     
-    def self.with_options_from(args)
-      yield Hash === args.last ? args.pop : {} if block_given?
+      def with_options_from(args)
+        yield Hash === args.last ? args.pop : {} if block_given?
+      end
     end
   end
 end

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

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

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

@@ -14,7 +14,7 @@ module Test
 
       def run(*args)
         return true unless args.empty?
-        example_group.run
+        example_group.run(Spec::Runner.options)
       end
 
       def size

data/lib/spec/matchers/match_array.rb

@@ -0,0 +1,75 @@
+module Spec
+  module Matchers
+
+    class MatchArray #:nodoc:
+
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual        
+        @extra_items = difference_between_arrays(@actual, @expected)
+        @missing_items = difference_between_arrays(@expected, @actual)
+        @extra_items.empty? && @missing_items.empty?
+      end
+
+      def failure_message
+        message =  "expected collection contained:  #{@expected.sort.inspect}\n"
+        message += "actual collection contained:    #{@actual.sort.inspect}\n"
+        message += "the missing elements were:      #{@missing_items.sort.inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{@extra_items.sort.inspect}\n" unless @extra_items.empty?
+        message
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        def difference_between_arrays(array_1, array_2)
+          difference = array_1.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+
+        def _pretty_print(array)
+          result = ""
+          array.each_with_index do |item, index|
+            if index < (array.length - 2)
+              result << "#{item.inspect}, "
+            elsif index < (array.length - 1)
+              result << "#{item.inspect} and "
+            else
+              result << "#{item.inspect}"
+            end
+          end
+          result
+        end
+
+    end
+
+    # :call-seq:
+    #   should =~ expected
+    #
+    # Passes if actual contains all of the expected regardless of order. 
+    # This works for collections. Pass in multiple args  and it will only 
+    # pass if all args are found in collection.
+    #
+    # NOTE: there is no should_not version of array.should =~ other_array
+    # 
+    # == Examples
+    #
+    #   [1,2,3].should   =~ [1,2,3]   # => would pass
+    #   [1,2,3].should   =~ [2,3,1]   # => would pass
+    #   [1,2,3,4].should =~ [1,2,3]   # => would fail
+    #   [1,2,2,3].should =~ [1,2,3]   # => would fail
+    #   [1,2,3].should   =~ [1,2,3,4] # => would fail
+    OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray)
+  end
+end

data/lib/spec/matchers/operator_matcher.rb

@@ -1,22 +1,43 @@
 module Spec
   module Matchers
+
     class OperatorMatcher
+      @operator_registry = {}
+
+      def self.register(klass, operator, matcher)
+        @operator_registry[klass] ||= {}
+        @operator_registry[klass][operator] = matcher
+      end
+
+      def self.get(klass, operator)
+        return @operator_registry[klass][operator] if @operator_registry[klass]
+        nil
+      end
+
       def initialize(actual)
         @actual = actual
       end
-      
-      ['==','===','<','<=','>=','>','=~'].each do |operator|
-        define_method operator do |expected|
-          ::Spec::Matchers.last_matcher = self
-          @operator, @expected = operator, expected
-          __delegate_operator(@actual, operator, expected)
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if matcher = OperatorMatcher.get(@actual.class, operator)
+            return @actual.send(matcher_method, matcher.new(expected))
+          else
+            ::Spec::Matchers.last_matcher = self
+            @operator, @expected = operator, expected
+            __delegate_operator(@actual, operator, expected)
+          end
         end
       end
 
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
       def fail_with_message(message)
         Spec::Expectations.fail_with(message, @expected, @actual)
       end
-      
+
       def description
         "#{@operator} #{@expected.inspect}"
       end
@@ -24,6 +45,9 @@ module Spec
     end
 
     class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def matcher_method
+        :should
+      end
 
       def __delegate_operator(actual, operator, expected)
         return true if actual.__send__(operator, expected)
@@ -37,6 +61,9 @@ module Spec
     end
 
     class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+      def matcher_method
+        :should_not
+      end
 
       def __delegate_operator(actual, operator, expected)
         return true unless actual.__send__(operator, expected)

data/lib/spec/matchers.rb

@@ -1,3 +1,4 @@
+require 'spec/matchers/operator_matcher'
 require 'spec/matchers/generated_descriptions'
 require 'spec/matchers/errors'
 require 'spec/matchers/method_missing'
@@ -5,6 +6,7 @@ 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'
@@ -16,7 +18,6 @@ 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
 

data/lib/spec/mocks/argument_constraints.rb

@@ -73,6 +73,25 @@ module Spec
         end
       end
       
+      class HashNotIncludingConstraint
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false if actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
       class DuckTypeConstraint
         def initialize(*methods_to_respond_to)
           @methods_to_respond_to = methods_to_respond_to
@@ -153,12 +172,31 @@ module Spec
       end
       
       # :call-seq:
-      #   object.should_receive(:message).with(hash_including(:this => that))
-      #
-      # Passes if the argument is a hash that includes the specified key/value
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
       # pairs. If the hash includes other keys, it will still pass.
-      def hash_including(expected={})
-        HashIncludingConstraint.new(expected)
+      def hash_including(*args)
+        HashIncludingConstraint.new(anythingize_lonely_keys(*args))
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_not_including(:key => val))
+      #   object.should_receive(:message).with(hash_not_including(:key))
+      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
+      #
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      def hash_not_including(*args)
+        HashNotIncludingConstraint.new(anythingize_lonely_keys(*args))
+      end
+      
+      private
+      
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
       end
     end
   end

data/lib/spec/runner/example_group_runner.rb

@@ -15,11 +15,11 @@ module Spec
         end
       end
 
-      def run
+      def run(run_options)
         prepare
         success = true
         example_groups.each do |example_group|
-          success = success & example_group.run
+          success = success & example_group.run(run_options)
         end
         return success
       ensure