horseman 0.0.2 → 0.0.3

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/have.rb

@@ -0,0 +1,162 @@
+module RSpec
+  module Matchers
+    class Have
+      def initialize(expected, relativity=:exactly)
+        @expected = case expected
+                    when :no then 0
+                    when String then expected.to_i
+                    else expected
+                    end
+        @relativity = relativity
+        @actual = @collection_name = @plural_collection_name = nil
+      end
+    
+      def relativities
+        @relativities ||= {
+          :exactly => "",
+          :at_least => "at least ",
+          :at_most => "at most "
+        }
+      end
+    
+      def matches?(collection_or_owner)
+        collection = determine_collection(collection_or_owner)
+        query_method = determine_query_method(collection)
+        raise not_a_collection unless query_method
+        @actual = collection.send(query_method)
+        case @relativity
+        when :at_least then @actual >= @expected
+        when :at_most  then @actual <= @expected
+        else                @actual == @expected
+        end
+      end
+
+      def determine_collection(collection_or_owner)
+        if collection_or_owner.respond_to?(@collection_name)
+          collection_or_owner.send(@collection_name, *@args, &@block)
+        elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+          collection_or_owner.send(@plural_collection_name, *@args, &@block)
+        elsif determine_query_method(collection_or_owner)
+          collection_or_owner
+        else
+          collection_or_owner.send(@collection_name, *@args, &@block)
+        end
+      end
+
+      def determine_query_method(collection)
+        [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+      end
+
+      def not_a_collection
+        "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
+      end
+    
+      def failure_message_for_should
+        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+      end
+
+      def failure_message_for_should_not
+        if @relativity == :exactly
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+        elsif @relativity == :at_most
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_least(#{@expected + 1}).#{@collection_name}
+EOF
+        elsif @relativity == :at_least
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_most(#{@expected - 1}).#{@collection_name}
+EOF
+        end
+      end
+      
+      def description
+        "have #{relative_expectation} #{@collection_name}"
+      end
+      
+      def respond_to?(m)
+        @expected.respond_to?(m) || super
+      end
+    
+      private
+      
+      def method_missing(method, *args, &block)
+        @collection_name = method
+        if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(method.to_s)
+        end
+        @args = args
+        @block = block
+        self
+      end
+      
+      def relative_expectation
+        "#{relativities[@relativity]}#{@expected}"
+      end
+    end
+
+    # Passes if receiver is a collection with the submitted number of items OR
+    # if the receiver OWNS a collection with the submitted number of items.
+    #
+    # If the receiver OWNS the collection, you must use the name of the
+    # collection. So if a `Team` instance has a collection named `#players`,
+    # you must use that name to set the expectation.
+    #
+    # If the receiver IS the collection, you can use any name you like for
+    # `named_collection`. We'd recommend using either "elements", "members", or
+    # "items" as these are all standard ways of describing the things IN a
+    # collection.
+    #
+    # This also works for Strings, letting you set expectations about their
+    # lengths.
+    #
+    # @example
+    #
+    #   # Passes if team.players.size == 11
+    #   team.should have(11).players
+    #
+    #   # Passes if [1,2,3].length == 3
+    #   [1,2,3].should have(3).items #"items" is pure sugar
+    #
+    #   # Passes if ['a', 'b', 'c'].count == 3
+    #   [1,2,3].should have(3).items #"items" is pure sugar
+    #
+    #   # Passes if "this string".length == 11
+    #   "this string".should have(11).characters #"characters" is pure sugar
+    def have(n)
+      Matchers::Have.new(n)
+    end
+    alias :have_exactly :have
+
+    # Exactly like have() with >=.
+    #
+    # @example
+    #   "this".should have_at_least(3).letters
+    #
+    # ### Warning:
+    #
+    # `should_not have_at_least` is not supported
+    def have_at_least(n)
+      Matchers::Have.new(n, :at_least)
+    end
+
+    # Exactly like have() with <=.
+    #
+    # @example
+    #   should have_at_most(number).items
+    #
+    # ### Warning:
+    #
+    # `should_not have_at_most` is not supported
+    def have_at_most(n)
+      Matchers::Have.new(n, :at_most)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/include.rb

@@ -0,0 +1,66 @@
+module RSpec
+  module Matchers
+    class Include
+      include BaseMatcher
+
+      def initialize(*expected)
+        super(expected)
+      end
+
+      def matches?(actual)
+        perform_match(:all?, :all?, super(actual), expected)
+      end
+
+      def does_not_match?(actual)
+        @actual = actual
+        perform_match(:none?, :any?, actual, expected)
+      end
+
+      def description
+        "include#{expected_to_sentence}"
+      end
+
+      def diffable?
+        true
+      end
+
+    private
+
+      def perform_match(predicate, hash_predicate, actuals, expecteds)
+        expecteds.send(predicate) do |expected|
+          if comparing_hash_values?(actuals, expected)
+            expected.send(hash_predicate) {|k,v| actuals[k] == v}
+          elsif comparing_hash_keys?(actuals, expected)
+            actuals.has_key?(expected)
+          else
+            actuals.include?(expected)
+          end
+        end
+      end
+
+      def comparing_hash_keys?(actual, expected)
+        actual.is_a?(Hash) && !expected.is_a?(Hash)
+      end
+
+      def comparing_hash_values?(actual, expected)
+        actual.is_a?(Hash) && expected.is_a?(Hash)
+      end
+    end
+
+    # Passes if actual includes expected. This works for
+    # collections and Strings. You can also pass in multiple args
+    # and it will only pass if all args are found in collection.
+    #
+    # @example
+    #
+    #   [1,2,3].should include(3)
+    #   [1,2,3].should include(2,3) #would pass
+    #   [1,2,3].should include(2,3,4) #would fail
+    #   [1,2,3].should_not include(4)
+    #   "spread".should include("read")
+    #   "spread".should_not include("red")
+    def include(*expected)
+      Include.new(*expected)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/match.rb

@@ -0,0 +1,21 @@
+module RSpec
+  module Matchers
+    class Match
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).match(expected)
+      end
+    end
+
+    # Given a Regexp or String, passes if actual.match(pattern)
+    #
+    # @example
+    #
+    #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    #   email.should match("@example.com")
+    def match(expected)
+      Match.new(expected)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/match_array.rb

@@ -0,0 +1,65 @@
+module RSpec
+  module Matchers
+    class MatchArray
+      include RSpec::Matchers::Pretty
+      
+      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_for_should
+        message =  "expected collection contained:  #{safe_sort(@expected).inspect}\n"
+        message += "actual collection contained:    #{safe_sort(@actual).inspect}\n"
+        message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
+        message
+      end
+      
+      def failure_message_for_should_not
+        "Matcher does not support should_not"
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        def safe_sort(array)
+          array.sort rescue array
+        end
+
+        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
+    end
+
+    # 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
+    # 
+    # @example
+    #
+    #   [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, '=~', RSpec::Matchers::MatchArray)
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/matcher.rb

@@ -0,0 +1,268 @@
+module RSpec
+  module Matchers
+    # Provides the context in which the block passed to RSpec::Matchers.define
+    # will be evaluated.
+    class Matcher
+      include RSpec::Matchers::Extensions::InstanceEvalWithArgs
+      include RSpec::Matchers::Pretty
+      include RSpec::Matchers
+
+      attr_reader :expected, :actual, :rescued_exception
+
+      # @api private
+      def initialize(name, &declarations)
+        @name         = name
+        @declarations = declarations
+        @actual       = nil
+        @diffable     = false
+        @expected_exception, @rescued_exception = nil, nil
+        @match_for_should_not_block = nil
+
+        @messages = {
+          :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
+        }
+      end
+
+      # @api private
+      def for_expected(*expected)
+        @expected = expected
+        making_declared_methods_public do
+          instance_eval_with_args(*@expected, &@declarations)
+        end
+        self
+      end
+
+      # @api private
+      # Used internally by +should+ and +should_not+.
+      def matches?(actual)
+        @actual = actual
+        if @expected_exception
+          begin
+            instance_eval_with_args(actual, &@match_block)
+            true
+          rescue @expected_exception => @rescued_exception
+            false
+          end
+        else
+          begin
+            instance_eval_with_args(actual, &@match_block)
+          rescue RSpec::Expectations::ExpectationNotMetError
+            false
+          end
+        end
+      end
+
+      # Stores the block that is used to determine whether this matcher passes
+      # or fails. The block should return a boolean value. When the matcher is
+      # passed to `should` and the block returns `true`, then the expectation
+      # passes. Similarly, when the matcher is passed to `should_not` and the
+      # block returns `false`, then the expectation passes.
+      #
+      # Use `match_for_should` when used in conjuntion with
+      # `match_for_should_not`.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :be_even do
+      #       match do |actual|
+      #         actual.even?
+      #       end
+      #     end
+      #
+      #     4.should be_even     # passes
+      #     3.should_not be_even # passes
+      #     3.should be_even     # fails
+      #     4.should_not be_even # fails
+      #
+      # @yield [Object] actual the actual value (or receiver of should)
+      def match(&block)
+        @match_block = block
+      end
+
+      alias_method :match_for_should, :match
+
+      # Use this to define the block for a negative expectation (`should_not`)
+      # when the positive and negative forms require different handling. This
+      # is rarely necessary, but can be helpful, for example, when specifying
+      # asynchronous processes that require different timeouts.
+      #
+      # @yield [Object] actual the actual value (or receiver of should)
+      def match_for_should_not(&block)
+        @match_for_should_not_block = block
+      end
+
+      # Use this instead of `match` when the block will raise an exception
+      # rather than returning false to indicate a failure.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
+      #       match_unless_raises ValidationException do |validator|
+      #         validator.validate(candidate_address)
+      #       end
+      #     end
+      #
+      #     email_validator.should accept_as_valid("person@company.com")
+      def match_unless_raises(exception=Exception, &block)
+        @expected_exception = exception
+        match(&block)
+      end
+
+      # Customize the failure messsage to use when this matcher is invoked with
+      # `should`. Only use this when the message generated by default doesn't
+      # suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_strength do |expected|
+      #       match { ... }
+      #
+      #       failure_message_for_should do |actual|
+      #         "Expected strength of #{expected}, but had #{actual.strength}"
+      #       end
+      #     end
+      #
+      # @yield [Object] actual the actual object
+      def failure_message_for_should(&block)
+        cache_or_call_cached(:failure_message_for_should, &block)
+      end
+
+      # Customize the failure messsage to use when this matcher is invoked with
+      # `should_not`. Only use this when the message generated by default
+      # doesn't suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_strength do |expected|
+      #       match { ... }
+      #
+      #       failure_message_for_should_not do |actual|
+      #         "Expected not to have strength of #{expected}, but did"
+      #       end
+      #     end
+      #
+      # @yield [Object] actual the actual object
+      # @yield [Object] actual the actual object
+      def failure_message_for_should_not(&block)
+        cache_or_call_cached(:failure_message_for_should_not, &block)
+      end
+
+
+      # Customize the description to use for one-liners.  Only use this when
+      # the description generated by default doesn't suit your needs.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :qualify_for do |expected|
+      #       match { ... }
+      #
+      #       description do
+      #         "qualify for #{expected}"
+      #       end
+      #     end
+      def description(&block)
+        cache_or_call_cached(:description, &block)
+      end
+
+      # Tells the matcher to diff the actual and expected values in the failure
+      # message.
+      def diffable
+        @diffable = true
+      end
+      
+      # Convenience for defining methods on this matcher to create a fluent
+      # interface. The trick about fluent interfaces is that each method must
+      # return self in order to chain methods together. `chain` handles that
+      # for you.
+      #
+      # @example
+      #
+      #     RSpec::Matchers.define :have_errors_on do |key|
+      #       chain :with do |message|
+      #         @message = message
+      #       end
+      #
+      #       match do |actual|
+      #         actual.errors[key] == @message
+      #       end
+      #     end
+      #
+      #     minor.should have_errors_on(:age).with("Not old enough to participate")
+      def chain(method, &block)
+        define_method method do |*args|
+          block.call(*args)
+          self
+        end
+      end
+      
+      # @api private
+      # Used internally by objects returns by +should+ and +should_not+.
+      def diffable?
+        @diffable
+      end
+
+      # @api private
+      # Used internally by +should_not+
+      def does_not_match?(actual)
+        @actual = actual
+        @match_for_should_not_block ?
+          instance_eval_with_args(actual, &@match_for_should_not_block) :
+          !matches?(actual)
+      end
+
+    private
+
+      def include(*args)
+        singleton_class.__send__(:include, *args)
+      end
+
+      def define_method(name, &block)
+        singleton_class.__send__(:define_method, name, &block)
+      end
+
+      def method_missing(method, *args, &block)
+        if $matcher_execution_context.respond_to?(method)
+          $matcher_execution_context.send method, *args, &block
+        else
+          super(method, *args, &block)
+        end
+      end
+    
+      def making_declared_methods_public
+        # Our home-grown instance_exec in ruby 1.8.6 results in any methods
+        # declared in the block eval'd by instance_exec in the block to which we
+        # are yielding here are scoped private. This is NOT the case for Ruby
+        # 1.8.7 or 1.9.
+        #
+        # Also, due some crazy scoping that I don't understand, these methods
+        # are actually available in the specs (something about the matcher being
+        # defined in the scope of RSpec::Matchers or within an example), so not
+        # doing the following will not cause specs to fail, but they *will*
+        # cause features to fail and that will make users unhappy. So don't.
+        orig_private_methods = private_methods
+        yield
+        (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
+      end
+
+      def cache_or_call_cached(key, &block)
+        block ? cache(key, &block) : call_cached(key)
+      end
+
+      def cache(key, &block)
+        @messages[key] = block
+      end
+
+      def call_cached(key)
+        @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
+      end
+
+      unless method_defined?(:singleton_class)
+        def singleton_class
+          class << self; self; end
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/method_missing.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Matchers
+
+    private
+
+    def method_missing(method, *args, &block)
+      return Matchers::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
+      return Matchers::Has.new(method, *args, &block) if method.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-expectations-2.8.0/lib/rspec/matchers/operator_matcher.rb

@@ -0,0 +1,85 @@
+module RSpec
+  module Matchers
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def get(klass, operator)
+          registry[klass] && 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(::RSpec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+                  "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        RSpec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::RSpec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+
+    end
+
+    class PositiveOperatorMatcher < OperatorMatcher
+      def __delegate_operator(actual, operator, expected)
+        if actual.__send__(operator, expected)
+          true
+        elsif ['==','===', '=~'].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
+      def __delegate_operator(actual, operator, expected)
+        return false unless actual.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      end
+
+    end
+  end
+end