picolena 0.1.8 → 0.2.0

data/rails_plugins/rspec/lib/spec/matchers/include.rb

@@ -1,70 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers/match.rb

@@ -1,41 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers/operator_matcher.rb

@@ -1,73 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers/raise_error.rb

@@ -1,109 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers/respond_to.rb

@@ -1,45 +0,0 @@
-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/rails_plugins/rspec/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
-        "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/rails_plugins/rspec/lib/spec/matchers/simple_matcher.rb

@@ -1,29 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers/throw_symbol.rb

@@ -1,74 +0,0 @@
-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/rails_plugins/rspec/lib/spec/matchers.rb

@@ -1,156 +0,0 @@
-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/rails_plugins/rspec/lib/spec/mocks/argument_constraint_matchers.rb

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