picolena 0.0.99

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/include.rb

@@ -0,0 +1,70 @@
+module Spec
+  module Matchers
+
+    class Include #:nodoc:
+      
+      def initialize(*expecteds)
+        @expecteds = expecteds
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @expecteds.each do |expected|
+          return false unless actual.include?(expected)
+        end
+        true
+      end
+      
+      def failure_message
+        _message
+      end
+      
+      def negative_failure_message
+        _message("not ")
+      end
+      
+      def description
+        "include #{_pretty_print(@expecteds)}"
+      end
+      
+      private
+        def _message(maybe_not="")
+          "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
+        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 include(expected)
+    #   should_not include(expected)
+    #
+    # 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.
+    #
+    # == Examples
+    #
+    #   [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)
+      Matchers::Include.new(*expected)
+    end
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/match.rb

@@ -0,0 +1,41 @@
+module Spec
+  module Matchers
+    
+    class Match #:nodoc:
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        return true if actual =~ @expected
+        return false
+      end
+      
+      def failure_message
+        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
+      end
+      
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
+      end
+      
+      def description
+        "match #{@expected.inspect}"
+      end
+    end
+    
+    # :call-seq:
+    #   should match(regexp)
+    #   should_not match(regexp)
+    #
+    # Given a Regexp, passes if actual =~ regexp
+    #
+    # == Examples
+    #
+    #   email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    def match(regexp)
+      Matchers::Match.new(regexp)
+    end
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/operator_matcher.rb

@@ -0,0 +1,73 @@
+module Spec
+  module Matchers
+    class BaseOperatorMatcher
+      attr_reader :generated_description
+      
+      def initialize(target)
+        @target = target
+      end
+
+      def ==(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("==", expected)
+      end
+
+      def ===(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("===", expected)
+      end
+
+      def =~(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("=~", expected)
+      end
+
+      def >(expected)
+        @expected = expected
+        __delegate_method_missing_to_target(">", expected)
+      end
+
+      def >=(expected)
+        @expected = expected
+        __delegate_method_missing_to_target(">=", expected)
+      end
+
+      def <(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("<", expected)
+      end
+
+      def <=(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("<=", expected)
+      end
+
+      def fail_with_message(message)
+        Spec::Expectations.fail_with(message, @expected, @target)
+      end
+
+    end
+
+    class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc:
+
+      def __delegate_method_missing_to_target(operator, expected)
+        ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}"
+        return if @target.send(operator, expected)
+        return fail_with_message("expected: #{expected.inspect},\n     got: #{@target.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator)
+        return fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
+      end
+
+    end
+
+    class NegativeOperatorMatcher < BaseOperatorMatcher #:nodoc:
+
+      def __delegate_method_missing_to_target(operator, expected)
+        ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}"
+        return unless @target.send(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
+      end
+
+    end
+
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/raise_error.rb

@@ -0,0 +1,109 @@
+module Spec
+  module Matchers
+    
+    class RaiseError #:nodoc:
+      def initialize(error_or_message=Exception, message=nil)
+        if String === error_or_message
+          @expected_error = Exception
+          @expected_message = error_or_message
+        else
+          @expected_error = error_or_message
+          @expected_message = message
+        end
+      end
+      
+      def matches?(proc)
+        @raised_expected_error = false
+        @raised_other = false
+        begin
+          proc.call
+        rescue @expected_error => @actual_error
+          if @expected_message.nil?
+            @raised_expected_error = true
+          else
+            verify_message
+          end
+        rescue Exception => @actual_error
+          @raised_other = true
+        ensure
+          return @raised_expected_error
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when Regexp
+          if @expected_message =~ @actual_error.message
+            @raised_expected_error = true
+          else
+            @raised_other = true
+          end
+        else
+          if @expected_message == @actual_error.message
+            @raised_expected_error = true
+          else
+            @raised_other = true
+          end
+        end
+      end
+      
+      def failure_message
+        return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
+      end
+
+      def negative_failure_message
+        "expected no #{expected_error}#{actual_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 actual_error
+          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
+        end
+    end
+    
+    # :call-seq:
+    #   should raise_error()
+    #   should raise_error(NamedError)
+    #   should raise_error(NamedError, String)
+    #   should raise_error(NamedError, Regexp)
+    #   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.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should raise_error
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #   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)
+      Matchers::RaiseError.new(error, message)
+    end
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/respond_to.rb

@@ -0,0 +1,45 @@
+module Spec
+  module Matchers
+    
+    class RespondTo #:nodoc:
+      def initialize(*names)
+        @names = names
+        @names_not_responded_to = []
+      end
+      
+      def matches?(target)
+        @names.each do |name|
+          unless target.respond_to?(name)
+            @names_not_responded_to << name
+          end
+        end
+        return @names_not_responded_to.empty?
+      end
+      
+      def failure_message
+        "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def negative_failure_message
+        "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def description
+        "respond to ##{@names.to_s}"
+      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/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/satisfy.rb

@@ -0,0 +1,47 @@
+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
+        "expected #{@actual} to satisfy block"
+      end
+
+      def negative_failure_message
+        "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/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/simple_matcher.rb

@@ -0,0 +1,29 @@
+module Spec
+  module Matchers
+    class SimpleMatcher
+      attr_reader :description
+      
+      def initialize(description, &match_block)
+        @description = description
+        @match_block = match_block
+      end
+
+      def matches?(actual)
+        @actual = actual
+        return @match_block.call(@actual)
+      end
+
+      def failure_message()
+        return %[expected #{@description.inspect} but got #{@actual.inspect}]
+      end
+        
+      def negative_failure_message()
+        return %[expected not to get #{@description.inspect}, but got #{@actual.inspect}]
+      end
+    end
+    
+    def simple_matcher(message, &match_block)
+      SimpleMatcher.new(message, &match_block)
+    end
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers/throw_symbol.rb

@@ -0,0 +1,74 @@
+module Spec
+  module Matchers
+    
+    class ThrowSymbol #:nodoc:
+      def initialize(expected=nil)
+        @expected = expected
+        @actual = nil
+      end
+      
+      def matches?(proc)
+        begin
+          proc.call
+        rescue NameError => e
+          raise e unless e.message =~ /uncaught throw/
+          @actual = e.name.to_sym
+        ensure
+          if @expected.nil?
+            return @actual.nil? ? false : true
+          else
+            return @actual == @expected
+          end
+        end
+      end
+
+      def failure_message
+        if @actual
+          "expected #{expected}, got #{@actual.inspect}"
+        else
+          "expected #{expected} but nothing was thrown"
+        end
+      end
+      
+      def negative_failure_message
+        if @expected
+          "expected #{expected} not to be thrown"
+        else
+          "expected no Symbol, got :#{@actual}"
+        end
+      end
+      
+      def description
+        "throw #{expected}"
+      end
+      
+      private
+      
+        def expected
+          @expected.nil? ? "a Symbol" : @expected.inspect
+        end
+      
+    end
+ 
+    # :call-seq:
+    #   should throw_symbol()
+    #   should throw_symbol(:sym)
+    #   should_not throw_symbol()
+    #   should_not throw_symbol(:sym)
+    #
+    # Given a Symbol argument, matches if a proc throws the specified Symbol.
+    #
+    # Given no argument, matches if a proc throws any Symbol.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #
+    #   lambda { do_something_risky }.should_not throw_symbol
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    def throw_symbol(sym=nil)
+      Matchers::ThrowSymbol.new(sym)
+    end
+  end
+end

data/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/matchers.rb

@@ -0,0 +1,156 @@
+require 'spec/matchers/simple_matcher'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/change'
+require 'spec/matchers/eql'
+require 'spec/matchers/equal'
+require 'spec/matchers/exist'
+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
+      attr_accessor :generated_description
+
+      def clear_generated_description
+        self.generated_description = nil
+      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/app_generators/picolena/templates/vendor/plugins/rspec/lib/spec/mocks/argument_constraint_matchers.rb

@@ -0,0 +1,27 @@
+module Spec
+  module Mocks
+    module ArgumentConstraintMatchers
+
+      # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
+      def duck_type(*args)
+        DuckTypeArgConstraint.new(*args)
+      end
+
+      def any_args
+        AnyArgsConstraint.new
+      end
+      
+      def anything
+        AnyArgConstraint.new(nil)
+      end
+      
+      def boolean
+        BooleanArgConstraint.new(nil)
+      end
+      
+      def no_args
+        NoArgsConstraint.new
+      end
+    end
+  end
+end