simple-templater 0.0.1

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

@@ -0,0 +1,195 @@
+require 'spec/extensions/instance_exec'
+require 'spec/matchers/pretty'
+require 'spec/matchers/matcher'
+require 'spec/matchers/operator_matcher'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/be_instance_of'
+require 'spec/matchers/be_kind_of'
+require 'spec/matchers/change'
+require 'spec/matchers/eql'
+require 'spec/matchers/equal'
+require 'spec/matchers/errors'
+require 'spec/matchers/exist'
+require 'spec/matchers/generated_descriptions'
+require 'spec/matchers/has'
+require 'spec/matchers/have'
+require 'spec/matchers/include'
+require 'spec/matchers/match'
+require 'spec/matchers/match_array'
+require 'spec/matchers/method_missing'
+require 'spec/matchers/raise_error'
+require 'spec/matchers/respond_to'
+require 'spec/matchers/satisfy'
+require 'spec/matchers/simple_matcher'
+require 'spec/matchers/throw_symbol'
+require 'spec/matchers/wrap_expectation'
+require 'spec/matchers/compatibility'
+require 'spec/matchers/dsl'
+
+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_for_should
+  #
+  # These methods are also part of the matcher protocol, but are optional:
+  #
+  #   does_not_match?(actual)
+  #   failure_message_for_should_not
+  #   description #optional
+  #
+  # These methods are from older versions of the protocol. They are still supported,
+  # but are not recommended:
+  #
+  #   failure_message          (use failure_message_for_should instead)
+  #   negative_failure_message (use failure_message_for_should_not instead)
+  #
+  # See Spec::Expectations to learn how to use these as Expectation Matchers.
+  #
+  # == 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 Matchers
+  #
+  # When you find that none of the stock Expectation Matchers provide a natural
+  # feeling expectation, you can very easily write your own using RSpec's matcher
+  # DSL or writing one from scratch.
+  #
+  # === Matcher DSL
+  #
+  # 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")
+  #
+  # You can create such a matcher like so:
+  #
+  #   Spec::Matchers.define :be_in_zone do |zone|
+  #     match do |player|
+  #       player.in_zone?(zone)
+  #     end
+  #   end
+  #
+  # This will generate a <tt>be_in_zone</tt> method that returns a matcher
+  # with logical default messages for failures. You can override the failure
+  # messages and the generated description as follows:
+  #
+  #   Spec::Matchers.define :be_in_zone do |zone|
+  #     match do |player|
+  #       player.in_zone?(zone)
+  #     end
+  #     failure_message_for_should do |player|
+  #       # generate and return the appropriate string.
+  #     end
+  #     failure_message_for_should_not do |player|
+  #       # generate and return the appropriate string.
+  #     end
+  #     description do
+  #       # generate and return the appropriate string.
+  #     end
+  #   end
+  #
+  # Each of the message-generation methods has access to the block arguments
+  # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
+  # failure message methods (<tt>failure_message_for_should</tt> and
+  # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
+  # receiver of <tt>should</tt> or <tt>should_not</tt>).
+  #
+  # === Custom Matcher from scratch
+  #
+  # You could also write a custom matcher from scratch, as follows:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(target)
+  #       @target = target
+  #       @target.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message_for_should
+  #       "expected #{@target.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def failure_message_for_should_not
+  #       "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; end
+end

data/vendor/rspec/lib/spec/mocks/argument_expectation.rb

@@ -0,0 +1,51 @@
+module Spec
+  module Mocks
+    
+    class ArgumentExpectation
+      attr_reader :args
+      
+      def initialize(args, &block)
+        @args = args
+        @matchers_block = block
+        @match_any_args = false
+        @matchers = nil
+        
+        if ArgumentMatchers::AnyArgsMatcher === args.first
+          @match_any_args = true
+        elsif ArgumentMatchers::NoArgsMatcher === args.first
+          @matchers = []
+        else
+          @matchers = args.collect {|arg| matcher_for(arg)}
+        end
+      end
+      
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg)   if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg) if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+      
+      def is_matcher?(obj)
+        return obj.respond_to?(:matches?) & obj.respond_to?(:description)
+      end
+      
+      def args_match?(given_args)
+        match_any_args? || matchers_block_matches?(given_args) || matchers_match?(given_args)
+      end
+      
+      def matchers_block_matches?(given_args)
+        @matchers_block ? @matchers_block.call(*given_args) : nil
+      end
+      
+      def matchers_match?(given_args)
+        @matchers == given_args
+      end
+      
+      def match_any_args?
+        @match_any_args
+      end
+      
+    end
+    
+  end
+end

data/vendor/rspec/lib/spec/mocks/argument_matchers.rb

@@ -0,0 +1,237 @@
+module Spec
+  module Mocks
+
+    # ArgumentMatchers are messages that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of any_args() and no_args(), the matchers
+    # are all positional - they match against the arg in the given position.
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+        
+        def description
+          "anything"
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          return value =~ @regexp unless value.is_a?(Regexp)
+          value == @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          TrueClass === value || FalseClass === value
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false unless actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class HashNotIncludingMatcher
+        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 DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @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(no_args())
+      #
+      # Passes if no arguments are passed along with the message
+      def no_args
+        NoArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(any_args())
+      #
+      # Passes if object receives :message with any args at all. This is
+      # really a more explicit variation of object.should_receive(:message)
+      def any_args
+        AnyArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(anything())
+      #
+      # Passes as long as there is an argument.
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      #
+      # Passes if the argument responds to the specified messages.
+      #
+      # == Examples
+      #
+      #   array = []
+      #   display = mock('display')
+      #   display.should_receive(:present_names).with(duck_type(:length, :each))
+      #   => passes
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(boolean())
+      #
+      # Passes if the argument is boolean.
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   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(*args)
+        HashIncludingMatcher.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)
+        HashNotIncludingMatcher.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
+end

data/vendor/rspec/lib/spec/mocks/error_generator.rb

@@ -0,0 +1,92 @@
+module Spec
+  module Mocks
+    class ErrorGenerator
+      attr_writer :opts
+      
+      def initialize(target, name, options={})
+        @declared_as = options[:__declared_as] || 'Mock'
+        @target = target
+        @name = name
+      end
+      
+      def opts
+        @opts ||= {}
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
+      end
+      
+      def raise_unexpected_message_args_error(expectation, *args)
+        expected_args = format_args(*expectation.expected_args)
+        actual_args = args.empty? ? "(no args)" : format_args(*args)
+        __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
+      end
+      
+      def raise_expectation_error(sym, expected_received_count, actual_received_count, *args)
+        __raise "#{intro} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{count_message(actual_received_count)}"
+      end
+      
+      def raise_out_of_order_error(sym)
+        __raise "#{intro} received :#{sym} out of order"
+      end
+      
+      def raise_block_failed_error(sym, detail)
+        __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
+      end
+      
+      def raise_missing_block_error(args_to_yield)
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+      
+      def raise_wrong_arity_error(args_to_yield, arity)
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+      
+    private
+
+      def intro
+        if @name
+          "#{@declared_as} #{@name.inspect}"
+        elsif Mock === @target
+          @declared_as
+        elsif Class === @target
+          "<#{@target.inspect} (class)>"
+        elsif @target
+          @target
+        else
+          "nil"
+        end
+      end
+      
+      def __raise(message)
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(Spec::Mocks::MockExpectationError, message)
+      end
+      
+      def arg_message(*args)
+        " with " + format_args(*args)
+      end
+      
+      def format_args(*args)
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
+      end
+
+      def arg_list(*args)
+        args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
+      end
+      
+      def count_message(count)
+        return "at least #{pretty_print(count.abs)}" if count < 0
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        return "once" if count == 1
+        return "twice" if count == 2
+        return "#{count} times"
+      end
+
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/errors.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Mocks
+    class MockExpectationError < Exception
+    end
+    
+    class AmbiguousReturnError < StandardError
+    end
+  end
+end
+

data/vendor/rspec/lib/spec/mocks/example_methods.rb

@@ -0,0 +1,69 @@
+module Spec
+  module Mocks
+    module ExampleMethods
+      include Spec::Mocks::ArgumentMatchers
+
+      # Shortcut for creating an instance of Spec::Mocks::Mock.
+      #
+      # +name+ is used for failure reporting, so you should use the
+      # role that the double is playing in the example.
+      #
+      # +stubs_and_options+ lets you assign options and stub values
+      # at the same time. The only option available is :null_object.
+      # Anything else is treated as a stub value.
+      #
+      # == Examples
+      #
+      #   thing = double("thing", :a => "A")
+      #   thing.a == "A" => true
+      #
+      #   person = double("thing", :name => "Joe", :email => "joe@domain.com")
+      #   person.name => "Joe"
+      #   person.email => "joe@domain.com"
+      def double(*args)
+        __declare_double('Double', *args)
+      end
+
+      # Alias for double
+      def mock(*args)
+        __declare_double('Mock', *args)
+      end
+
+      # Alias for double
+      def stub(*args)
+        __declare_double('Stub', *args)
+      end
+
+      def __declare_double(declared_as, *args) # :nodoc:
+        args << {} unless Hash === args.last
+        args.last[:__declared_as] = declared_as
+        Spec::Mocks::Mock.new(*args)
+      end
+
+      # DEPRECATED - use double('name').as_null_object instead
+      #
+      # Shortcut for creating a mock object that will return itself in response
+      # to any message it receives that it hasn't been explicitly instructed
+      # to respond to.
+      def stub_everything(name = 'stub')
+        Spec.warn(<<-WARNING)
+
+DEPRECATION: stub_everything('#{name}') is deprecated and will be removed
+from a future version of rspec. Please use double('#{name}').as_null_object
+(or stub('#{name}').as_null_object or mock('#{name}').as_null_object instead.
+
+WARNING
+        mock(name, :null_object => true)
+      end
+
+      # Disables warning messages about expectations being set on nil.
+      #
+      # By default warning messages are issued when expectations are set on nil.  This is to
+      # prevent false-positives and to catch potential bugs early on.
+      def allow_message_expectations_on_nil
+        Proxy.allow_message_expectations_on_nil
+      end
+
+    end
+  end
+end

data/vendor/rspec/lib/spec/mocks/extensions/object.rb

@@ -0,0 +1,3 @@
+class Object
+  include Spec::Mocks::Methods
+end

data/vendor/rspec/lib/spec/mocks/extensions.rb

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

data/vendor/rspec/lib/spec/mocks/framework.rb

@@ -0,0 +1,15 @@
+# Require everything except the global extensions of class and object. This
+# supports wrapping rspec's mocking functionality without invading every
+# object in the system.
+
+require 'spec/mocks/methods'
+require 'spec/mocks/argument_matchers'
+require 'spec/mocks/example_methods'
+require 'spec/mocks/proxy'
+require 'spec/mocks/mock'
+require 'spec/mocks/argument_expectation'
+require 'spec/mocks/message_expectation'
+require 'spec/mocks/order_group'
+require 'spec/mocks/errors'
+require 'spec/mocks/error_generator'
+require 'spec/mocks/space'