has_finder 0.1.3 → 0.1.4

data/spec/rails/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/spec/rails/vendor/plugins/rspec/lib/spec/expectations/handler.rb

@@ -1,43 +0,0 @@
-module Spec
-  module Expectations
-    
-    module MatcherHandlerHelper
-      def describe(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)
-          match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
-          Spec::Expectations.fail_with(matcher.failure_message) unless match
-        end
-      end
-    end
-
-    class NegativeExpectationMatcherHandler
-      class << self
-        include MatcherHandlerHelper
-        def handle_matcher(actual, matcher, &block)
-          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)}"
-          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
-        end
-      end
-    end
-
-  end
-end
-

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

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

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

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

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

@@ -1,166 +0,0 @@
-require 'spec/matchers/be'
-require 'spec/matchers/be_close'
-require 'spec/matchers/change'
-require 'spec/matchers/eql'
-require 'spec/matchers/equal'
-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
-      def description_generated(callback)
-        description_generated_callbacks << callback
-      end
-
-      def unregister_description_generated(callback)
-        description_generated_callbacks.delete(callback)
-      end
-
-      def generated_description=(name)
-        description_generated_callbacks.each do |callback|
-          callback.call(name)
-        end
-      end
-
-      private
-      def description_generated_callbacks
-        @description_generated_callbacks ||= []
-      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

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

@@ -1,206 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Be #:nodoc:
-      def initialize(*args)
-        @expected = parse_expected(args.shift)
-        @args = args
-        @comparison = ""
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        return true if match_or_compare unless handling_predicate?
-        if handling_predicate?
-          begin
-            return @result = actual.__send__(predicate, *@args)
-          rescue => predicate_error
-            # This clause should be empty, but rcov will not report it as covered
-            # unless something (anything) is executed within the clause
-            rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
-          end
-
-          # This supports should_exist > target.exists? in the old world.
-          # We should consider deprecating that ability as in the new world
-          # you can't write "should exist" unless you have your own custom matcher.
-          begin
-            return @result = actual.__send__(present_tense_predicate, *@args)
-          rescue
-            raise predicate_error
-          end
-        end
-        return false
-      end
-      
-      def failure_message
-        return "expected #{@comparison}#{expected}, got #{@actual.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
-      end
-      
-      def negative_failure_message
-        return "expected not #{expected}, got #{@actual.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
-      end
-      
-      def expected
-        return true if @expected == :true
-        return false if @expected == :false
-        return "nil" if @expected == :nil
-        return @expected.inspect
-      end
-      
-      def match_or_compare
-        return @actual == true if @expected == :true
-        return @actual == false if @expected == :false
-        return @actual.nil? if @expected == :nil
-        return @actual < @expected if @less_than
-        return @actual <= @expected if @less_than_or_equal
-        return @actual >= @expected if @greater_than_or_equal
-        return @actual > @expected if @greater_than
-        return @actual == @expected if @double_equal
-        return @actual === @expected if @triple_equal
-        return @actual.equal?(@expected)
-      end
-      
-      def ==(expected)
-        @double_equal = true
-        @comparison = "== "
-        @expected = expected
-        self
-      end
-
-      def ===(expected)
-        @triple_equal = true
-        @comparison = "=== "
-        @expected = expected
-        self
-      end
-
-      def <(expected)
-        @less_than = true
-        @comparison = "< "
-        @expected = expected
-        self
-      end
-
-      def <=(expected)
-        @less_than_or_equal = true
-        @comparison = "<= "
-        @expected = expected
-        self
-      end
-
-      def >=(expected)
-        @greater_than_or_equal = true
-        @comparison = ">= "
-        @expected = expected
-        self
-      end
-
-      def >(expected)
-        @greater_than = true
-        @comparison = "> "
-        @expected = expected
-        self
-      end
-      
-      def description
-        "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}"
-      end
-
-      private
-        def parse_expected(expected)
-          if Symbol === expected
-            @handling_predicate = true
-            ["be_an_","be_a_","be_"].each do |@prefix|
-              return "#{expected.to_s.sub(@prefix,"")}".to_sym if expected.starts_with?(@prefix)
-            end
-          end
-          @prefix = "be "
-          return expected
-        end
-        
-        def handling_predicate?
-          return false if [:true, :false, :nil].include?(@expected)
-          return @handling_predicate
-        end
-
-        def predicate
-          "#{@expected.to_s}?".to_sym
-        end
-        
-        def present_tense_predicate
-          "#{@expected.to_s}s?".to_sym
-        end
-        
-        def args_to_s
-          return "" if @args.empty?
-          inspected_args = @args.collect{|a| a.inspect}
-          return "(#{inspected_args.join(', ')})"
-        end
-        
-        def comparison
-          @comparison
-        end
-        
-        def expected_to_sentence
-          split_words(@expected)
-        end
-        
-        def prefix_to_sentence
-          split_words(@prefix)
-        end
-
-        def split_words(sym)
-          sym.to_s.gsub(/_/,' ')
-        end
-
-        def args_to_sentence
-          case @args.length
-            when 0
-              ""
-            when 1
-              " #{@args[0]}"
-            else
-              " #{@args[0...-1].join(', ')} and #{@args[-1]}"
-          end
-        end
-        
-    end
- 
-    # :call-seq:
-    #   should be_true
-    #   should be_false
-    #   should be_nil
-    #   should be_arbitrary_predicate(*args)
-    #   should_not be_nil
-    #   should_not be_arbitrary_predicate(*args)
-    #
-    # Given true, false, or nil, will pass if actual is
-    # true, false or nil (respectively).
-    #
-    # Predicates are any Ruby method that ends in a "?" and returns true or false.
-    # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
-    # convert that into a query against the target object.
-    #
-    # The arbitrary_predicate feature will handle any predicate
-    # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
-    # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
-    #
-    # == Examples 
-    #
-    #   target.should be_true
-    #   target.should be_false
-    #   target.should be_nil
-    #   target.should_not be_nil
-    #
-    #   collection.should be_empty #passes if target.empty?
-    #   "this string".should be_an_intance_of(String)
-    #
-    #   target.should_not be_empty #passes unless target.empty?
-    #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
-    def be(*args)
-      Matchers::Be.new(*args)
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Spec
-  module Matchers
-
-    class BeClose #:nodoc:
-      def initialize(expected, delta)
-        @expected = expected
-        @delta = delta
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        (@actual - @expected).abs < @delta
-      end
-      
-      def failure_message
-        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
-      end
-      
-      def description
-        "be close to #{@expected} (within +- #{@delta})"
-      end
-    end
-    
-    # :call-seq:
-    #   should be_close(expected, delta)
-    #   should_not be_close(expected, delta)
-    #
-    # Passes if actual == expected +/- delta
-    #
-    # == Example
-    #
-    #   result.should be_close(3.0, 0.5)
-    def be_close(expected, delta)
-      Matchers::BeClose.new(expected, delta)
-    end
-  end
-end