mack 0.8.2 → 0.8.3

data/lib/gems/rspec-1.1.12/lib/spec/matchers/match_array.rb

@@ -0,0 +1,79 @@
+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 negative_failure_message
+        "Matcher does not support should_not"
+      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/gems/rspec-1.1.12/lib/spec/matchers/method_missing.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Matchers
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return has(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/operator_matcher.rb

@@ -0,0 +1,70 @@
+module Spec
+  module Matchers
+
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= Hash.new {|h,k| h[k] = {}}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass][operator] = matcher
+        end
+
+        def get(klass, operator)
+          registry[klass][operator]
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.send(::Spec::Matchers.last_should, 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
+
+    end
+
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return true if actual.__send__(operator, expected)
+        if ['==','===', '=~'].include?(operator)
+          fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
+        else
+          fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+
+    end
+
+    class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return true unless actual.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/matchers/raise_error.rb

@@ -47,20 +47,16 @@ module Spec
       def verify_message
         case @expected_message
         when nil
-          return true
+          true
         when Regexp
-          return @expected_message =~ @given_error.message
+          @expected_message =~ @given_error.message
         else
-          return @expected_message == @given_error.message
+          @expected_message == @given_error.message
         end
       end
       
       def failure_message
-        if @eval_block
-          return @given_error.message
-        else
-          return "expected #{expected_error}#{given_error}"
-        end
+        @eval_block ? @given_error.message : "expected #{expected_error}#{given_error}"
       end
 
       def negative_failure_message

data/lib/gems/rspec-1.1.12/lib/spec/matchers/respond_to.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Matchers
+    
+    class RespondTo #:nodoc:
+      def initialize(*names)
+        @names = names
+        @expected_arity = nil
+        @names_not_responded_to = []
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @names.each do |name|
+          @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name)
+        end
+        return @names_not_responded_to.empty?
+      end
+      
+      def failure_message
+        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+      end
+      
+      def negative_failure_message
+        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def description
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+        "respond to #{pp_names}#{with_arity}"
+      end
+      
+      def with(n)
+        @expected_arity = n
+        self
+      end
+      
+      def argument
+        self
+      end
+      alias :arguments :argument
+      
+    private
+      
+      def matches_arity?(actual, name)
+        @expected_arity.nil?? true : @expected_arity == actual.method(name).arity 
+      end
+      
+      def with_arity
+        @expected_arity.nil?? "" :
+          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+      end
+      
+      def pp_names
+        @names.length == 1 ? "##{@names.first}" : @names.inspect
+      end
+    end
+    
+    # :call-seq:
+    #   should respond_to(*names)
+    #   should_not respond_to(*names)
+    #
+    # Matches if the target object responds to all of the names
+    # provided. Names can be Strings or Symbols.
+    #
+    # == Examples
+    # 
+    def respond_to(*names)
+      Matchers::RespondTo.new(*names)
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/throw_symbol.rb

@@ -0,0 +1,106 @@
+module Spec
+  module Matchers
+    
+    class ThrowSymbol #:nodoc:
+      def initialize(expected_symbol = nil, expected_arg=nil)
+        @expected_symbol = expected_symbol
+        @expected_arg = expected_arg
+        @caught_symbol = nil
+      end
+      
+      def matches?(given_proc)
+        begin
+          if @expected_symbol.nil?
+            given_proc.call
+          else
+            @caught_arg = catch :proc_did_not_throw_anything do
+              catch @expected_symbol do
+                given_proc.call
+                throw :proc_did_not_throw_anything, :nothing_thrown
+              end
+            end
+            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+          end
+
+        # Ruby 1.8 uses NameError with `symbol'
+        # Ruby 1.9 uses ArgumentError with :symbol
+        rescue NameError, ArgumentError => e
+          raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+          @caught_symbol = $2.to_sym
+
+        ensure
+          if @expected_symbol.nil?
+            return !@caught_symbol.nil?
+          else
+            if @expected_arg.nil?
+              return @caught_symbol == @expected_symbol
+            else
+              # puts [@caught_symbol, @expected_symbol].inspect
+              # puts [@caught_arg, @expected_arg].inspect
+              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+            end
+          end
+        end
+      end
+
+      def failure_message
+        if @caught_symbol
+          "expected #{expected}, got #{@caught_symbol.inspect}"
+        else
+          "expected #{expected} but nothing was thrown"
+        end
+      end
+      
+      def negative_failure_message
+        if @expected_symbol
+          "expected #{expected} not to be thrown"
+        else
+          "expected no Symbol, got :#{@caught_symbol}"
+        end
+      end
+      
+      def description
+        "throw #{expected}"
+      end
+      
+      private
+      
+        def expected
+          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+        end
+        
+        def args
+          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
+        end
+      
+    end
+ 
+    # :call-seq:
+    #   should throw_symbol()
+    #   should throw_symbol(:sym)
+    #   should throw_symbol(:sym, arg)
+    #   should_not throw_symbol()
+    #   should_not throw_symbol(:sym)
+    #   should_not throw_symbol(:sym, arg)
+    #
+    # Given no argument, matches if a proc throws any Symbol.
+    #
+    # Given a Symbol, matches if the given proc throws the specified Symbol.
+    #
+    # Given a Symbol and an arg, matches if the given proc throws the
+    # specified Symbol with the specified arg.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
+    #
+    #   lambda { do_something_risky }.should_not throw_symbol
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
+    def throw_symbol(sym=nil)
+      Matchers::ThrowSymbol.new(sym)
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/wrap_expectation.rb

@@ -0,0 +1,55 @@
+module Spec
+  module Matchers
+    # wraps an expectation in a block that will return true if the
+    # expectation passes and false if it fails (without bubbling up
+    # the failure).
+    #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
+    # == Examples
+    #
+    #   def eat_cheese(cheese)
+    #     simple_matcher do |mouse, matcher|
+    #       matcher.failure_message = "expected #{mouse} to eat cheese"
+    #       wrap_expectation do |matcher|
+    #         assert_eats_cheese(mouse)
+    #       end
+    #     end
+    #   end
+    #
+    #   describe Mouse do
+    #     it "eats cheese" do
+    #       Mouse.new.should eat_cheese
+    #     end
+    #   end
+    #
+    # You might be wondering "why would I do this if I could just say"
+    # assert_eats_cheese?", a fair question, indeed. You might prefer
+    # to replace the word assert with something more aligned with the
+    # rest of your code examples. You are using rspec, after all.
+    #
+    # The other benefit you get is that you can use the negative version
+    # of the matcher:
+    #
+    #   describe Cat do
+    #     it "does not eat cheese" do
+    #       Cat.new.should_not eat_cheese
+    #     end
+    #   end
+    #
+    # So in the event there is no assert_does_not_eat_cheese available,
+    # you're all set!
+    def wrap_expectation(matcher, &block)
+      begin
+        block.call(matcher)
+        return true
+      rescue Exception => e
+        matcher.failure_message = e.message
+        return false
+      end
+    end
+  end
+end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/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
@@ -102,6 +121,26 @@ module Spec
           @given == expected
         end
       end
+      
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+      
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
 
       # :call-seq:
       #   object.should_receive(:message).with(any_args())
@@ -153,12 +192,45 @@ 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
+      
+      # Passes if arg.instance_of?(klass)
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      
+      alias_method :an_instance_of, :instance_of
+      
+      # Passes if arg.kind_of?(klass)
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      
+      alias_method :a_kind_of, :kind_of
+      
+      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