simple-templater 0.0.1.4 → 0.0.1.5

data/gems/gems/rspec-1.2.9/lib/spec/matchers/raise_error.rb

@@ -1,129 +0,0 @@
-module Spec
-  module Matchers
-    class RaiseError #:nodoc:
-      def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
-        @block = block
-        @actual_error = nil
-        case expected_error_or_message
-        when String, Regexp
-          @expected_error, @expected_message = Exception, expected_error_or_message
-        else
-          @expected_error, @expected_message = expected_error_or_message, expected_message
-        end
-      end
-
-      def matches?(given_proc)
-        @raised_expected_error = false
-        @with_expected_message = false
-        @eval_block = false
-        @eval_block_passed = false
-        begin
-          given_proc.call
-        rescue @expected_error => @actual_error
-          @raised_expected_error = true
-          @with_expected_message = verify_message
-        rescue Exception => @actual_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
-
-        unless negative_expectation?
-          eval_block if @raised_expected_error && @with_expected_message && @block
-        end
-      ensure
-        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
-      end
-      
-      def eval_block
-        @eval_block = true
-        begin
-          @block[@actual_error]
-          @eval_block_passed = true
-        rescue Exception => err
-          @actual_error = err
-        end
-      end
-
-      def verify_message
-        case @expected_message
-        when nil
-          true
-        when Regexp
-          @expected_message =~ @actual_error.message
-        else
-          @expected_message == @actual_error.message
-        end
-      end
-      
-      def failure_message_for_should
-        @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
-      end
-
-      def failure_message_for_should_not
-        "expected no #{expected_error}#{given_error}"
-      end
-      
-      def description
-        "raise #{expected_error}"
-      end
-      
-      private
-        def expected_error
-          case @expected_message
-          when nil
-            @expected_error
-          when Regexp
-            "#{@expected_error} with message matching #{@expected_message.inspect}"
-          else
-            "#{@expected_error} with #{@expected_message.inspect}"
-          end
-        end
-
-        def given_error
-          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
-        end
-        
-        def negative_expectation?
-          # YES - I'm a bad person... help me find a better way - ryand
-          caller.first(3).find { |s| s =~ /should_not/ }
-        end
-    end
-    
-    # :call-seq:
-    #   should raise_error()
-    #   should raise_error(NamedError)
-    #   should raise_error(NamedError, String)
-    #   should raise_error(NamedError, Regexp)
-    #   should raise_error() { |error| ... }
-    #   should raise_error(NamedError) { |error| ... }
-    #   should raise_error(NamedError, String) { |error| ... }
-    #   should raise_error(NamedError, Regexp) { |error| ... }
-    #   should_not raise_error()
-    #   should_not raise_error(NamedError)
-    #   should_not raise_error(NamedError, String)
-    #   should_not raise_error(NamedError, Regexp)
-    #
-    # With no args, matches if any error is raised.
-    # With a named error, matches only if that specific error is raised.
-    # With a named error and messsage specified as a String, matches only if both match.
-    # With a named error and messsage specified as a Regexp, matches only if both match.
-    # Pass an optional block to perform extra verifications on the exception matched
-    #
-    # == Examples
-    #
-    #   lambda { do_something_risky }.should raise_error
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
-    #
-    #   lambda { do_something_risky }.should_not raise_error
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil, &block)
-      Matchers::RaiseError.new(error, message, &block)
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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_for_should
-        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
-      end
-      
-      def failure_message_for_should_not
-        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
-      end
-      
-      def description
-        "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
-        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
-        @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/gems/gems/rspec-1.2.9/lib/spec/matchers/satisfy.rb

@@ -1,47 +0,0 @@
-module Spec
-  module Matchers
-    
-    class Satisfy #:nodoc:
-      def initialize(&block)
-        @block = block
-      end
-      
-      def matches?(actual, &block)
-        @block = block if block
-        @actual = actual
-        @block.call(actual)
-      end
-      
-      def failure_message_for_should
-        "expected #{@actual} to satisfy block"
-      end
-
-      def failure_message_for_should_not
-        "expected #{@actual} not to satisfy block"
-      end
-    end
-    
-    # :call-seq:
-    #   should satisfy {}
-    #   should_not satisfy {}
-    #
-    # Passes if the submitted block returns true. Yields target to the
-    # block.
-    #
-    # Generally speaking, this should be thought of as a last resort when
-    # you can't find any other way to specify the behaviour you wish to
-    # specify.
-    #
-    # If you do find yourself in such a situation, you could always write
-    # a custom matcher, which would likely make your specs more expressive.
-    #
-    # == Examples
-    #
-    #   5.should satisfy { |n|
-    #     n > 3
-    #   }
-    def satisfy(&block)
-      Matchers::Satisfy.new(&block)
-    end
-  end
-end

data/gems/gems/rspec-1.2.9/lib/spec/matchers/simple_matcher.rb

@@ -1,133 +0,0 @@
-module Spec
-  module Matchers
-    class SimpleMatcher
-      attr_writer :failure_message, :negative_failure_message, :description
-      
-      def initialize(description, &match_block)
-        @description = description
-        @match_block = match_block
-        @failure_message = @negative_failure_message = nil
-      end
-
-      def matches?(given)
-        @given = given
-        case @match_block.arity
-        when 2
-          @match_block.call(@given, self)
-        else
-          @match_block.call(@given)
-        end
-      end
-      
-      def description
-        @description || explanation
-      end
-
-      def failure_message_for_should
-        @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}])
-      end
-
-      def failure_message_for_should_not
-        @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}])
-      end
-
-      def explanation
-        "No description provided. See RDoc for simple_matcher()"
-      end
-    end
-  
-    # simple_matcher makes it easy for you to create your own custom matchers
-    # in just a few lines of code when you don't need all the power of a
-    # completely custom matcher object.
-    #
-    # The <tt>description</tt> argument will appear as part of any failure
-    # message, and is also the source for auto-generated descriptions.
-    #
-    # The <tt>match_block</tt> can have an arity of 1 or 2. The first block
-    # argument will be the given value. The second, if the block accepts it
-    # will be the matcher itself, giving you access to set custom failure
-    # messages in favor of the defaults.
-    #
-    # The <tt>match_block</tt> should return a boolean: <tt>true</tt>
-    # indicates a match, which will pass if you use <tt>should</tt> and fail
-    # if you use <tt>should_not</tt>. false (or nil) indicates no match,
-    # which will do the reverse: fail if you use <tt>should</tt> and pass if
-    # you use <tt>should_not</tt>.
-    #
-    # An error in the <tt>match_block</tt> will bubble up, resulting in a
-    # failure.
-    #
-    # == Example with default messages
-    #
-    #   def be_even
-    #     simple_matcher("an even number") { |given| given % 2 == 0 }
-    #   end
-    #                    
-    #   describe 2 do
-    #     it "should be even" do
-    #       2.should be_even
-    #     end
-    #   end
-    #
-    # Given an odd number, this example would produce an error message stating:
-    # expected "an even number", got 3.
-    #
-    # Unfortunately, if you're a fan of auto-generated descriptions, this will
-    # produce "should an even number." Not the most desirable result. You can
-    # control that using custom messages:
-    #
-    # == Example with custom messages
-    #
-    #   def rhyme_with(expected)
-    #     simple_matcher("rhyme with #{expected.inspect}") do |given, matcher|
-    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
-    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
-    #       given.rhymes_with? expected
-    #     end
-    #   end
-    #
-    #   # OR
-    #
-    #   def rhyme_with(expected)
-    #     simple_matcher do |given, matcher|
-    #       matcher.description = "rhyme with #{expected.inspect}"
-    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
-    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
-    #       given.rhymes_with? expected
-    #     end
-    #   end
-    #
-    #   describe "pecan" do
-    #     it "should rhyme with 'be gone'" do
-    #       nut = "pecan"
-    #       nut.extend Rhymer
-    #       nut.should rhyme_with("be gone")
-    #     end
-    #   end
-    #
-    # The resulting messages would be:
-    #   description:              rhyme with "be gone"
-    #   failure_message:          expected "pecan" to rhyme with "be gone"
-    #   negative failure_message: expected "pecan" not to rhyme with "be gone"
-    #
-    # == Wrapped Expectations
-    #
-    # Because errors will bubble up, it is possible to wrap other expectations
-    # in a SimpleMatcher.
-    #
-    #   def be_even
-    #     simple_matcher("an even number") { |given| (given % 2).should == 0 }
-    #   end
-    #
-    # BE VERY CAREFUL when you do this. Only use wrapped expectations for
-    # matchers that will always be used in only the positive
-    # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both.
-    # The reason is that is you wrap a <tt>should</tt> and call the wrapper
-    # with <tt>should_not</tt>, the correct result (the <tt>should</tt>
-    # failing), will fail when you want it to pass.
-    #
-    def simple_matcher(description=nil, &match_block)
-      SimpleMatcher.new(description, &match_block)
-    end
-  end
-end

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

@@ -1,104 +0,0 @@
-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 = @caught_arg = 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
-              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
-            end
-          end
-        end
-      end
-
-      def failure_message_for_should
-        if @caught_symbol
-          "expected #{expected}, got #{@caught_symbol.inspect}"
-        else
-          "expected #{expected} but nothing was thrown"
-        end
-      end
-      
-      def failure_message_for_should_not
-        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/gems/gems/rspec-1.2.9/lib/spec/matchers/wrap_expectation.rb

@@ -1,55 +0,0 @@
-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