picolena 0.1.8 → 0.2.0

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

@@ -1,224 +0,0 @@
-module Spec
-  module Matchers
-
-    class Be #:nodoc:
-      def initialize(*args)
-        if args.empty?
-          @expected = :satisfy_if
-        else
-          @expected = parse_expected(args.shift)
-        end
-        @args = args
-        @comparison = ""
-      end
-
-      def matches?(actual)
-        @actual = actual
-        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
-        else
-          return match_or_compare
-        end
-      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 "if to be satisfied" if @expected == :satisfy_if
-        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 : false if @expected == :satisfy_if
-        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)
-        @prefix = "be "
-        @double_equal = true
-        @comparison = "== "
-        @expected = expected
-        self
-      end
-
-      def ===(expected)
-        @prefix = "be "
-        @triple_equal = true
-        @comparison = "=== "
-        @expected = expected
-        self
-      end
-
-      def <(expected)
-        @prefix = "be "
-        @less_than = true
-        @comparison = "< "
-        @expected = expected
-        self
-      end
-
-      def <=(expected)
-        @prefix = "be "
-        @less_than_or_equal = true
-        @comparison = "<= "
-        @expected = expected
-        self
-      end
-
-      def >=(expected)
-        @prefix = "be "
-        @greater_than_or_equal = true
-        @comparison = ">= "
-        @expected = expected
-        self
-      end
-
-      def >(expected)
-        @prefix = "be "
-        @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|
-              if expected.starts_with?(prefix)
-                @prefix = prefix
-                return "#{expected.to_s.sub(@prefix,"")}".to_sym
-              end
-            end
-          end
-          @prefix = ""
-          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
-    #   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). Given no args means
-    # the caller should satisfy an if condition (to be or not to be).
-    #
-    # 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
-    #   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/rails_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

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

@@ -1,144 +0,0 @@
-module Spec
-  module Matchers
-
-    #Based on patch from Wilson Bilkovich
-    class Change #:nodoc:
-      def initialize(receiver=nil, message=nil, &block)
-        @receiver = receiver
-        @message = message
-        @block = block
-      end
-
-      def matches?(target, &block)
-        if block
-          raise MatcherError.new(<<-EOF
-block passed to should or should_not change must use {} instead of do/end
-EOF
-)
-        end
-        @target = target
-        execute_change
-        return false if @from && (@from != @before)
-        return false if @to && (@to != @after)
-        return (@before + @amount == @after) if @amount
-        return ((@after - @before) >= @minimum) if @minimum
-        return ((@after - @before) <= @maximum) if @maximum
-        return @before != @after
-      end
-
-      def execute_change
-        @before = @block.nil? ? @receiver.send(@message) : @block.call
-        @target.call
-        @after = @block.nil? ? @receiver.send(@message) : @block.call
-      end
-
-      def failure_message
-        if @to
-          "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
-        elsif @from
-          "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}"
-        elsif @amount
-          "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
-        elsif @minimum
-          "#{result} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
-        elsif @maximum
-          "#{result} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
-        else
-          "#{result} should have changed, but is still #{@before.inspect}"
-        end
-      end
-
-      def result
-        @message || "result"
-      end
-
-      def actual_delta
-        @after - @before
-      end
-
-      def negative_failure_message
-        "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
-      end
-
-      def by(amount)
-        @amount = amount
-        self
-      end
-
-      def by_at_least(minimum)
-        @minimum = minimum
-        self
-      end
-
-      def by_at_most(maximum)
-        @maximum = maximum
-        self
-      end
-
-      def to(to)
-        @to = to
-        self
-      end
-
-      def from (from)
-        @from = from
-        self
-      end
-    end
-
-    # :call-seq:
-    #   should change(receiver, message, &block)
-    #   should change(receiver, message, &block).by(value)
-    #   should change(receiver, message, &block).from(old).to(new)
-    #   should_not change(receiver, message, &block)
-    #
-    # Allows you to specify that a Proc will cause some value to change.
-    #
-    # == Examples
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count)
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count).by(1)
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count).by_at_least(1)
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count).by_at_most(1)
-    #
-    #   string = "string"
-    #   lambda {
-    #     string.reverse
-    #   }.should change { string }.from("string").to("gnirts")
-    #
-    #   lambda {
-    #     person.happy_birthday
-    #   }.should change(person, :birthday).from(32).to(33)
-    #
-    #   lambda {
-    #     employee.develop_great_new_social_networking_app
-    #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
-    #
-    # Evaluates +receiver.message+ or +block+ before and
-    # after it evaluates the c object (generated by the lambdas in the examples above).
-    #
-    # Then compares the values before and after the +receiver.message+ and
-    # evaluates the difference compared to the expected difference.
-    #
-    # == Warning
-    # +should_not+ +change+ only supports the form with no subsequent calls to
-    # +by+, +by_at_least+, +by_at_most+, +to+ or +from+.
-    #
-    # blocks passed to +should+ +change+ and +should_not+ +change+
-    # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported)
-    def change(target=nil, message=nil, &block)
-      Matchers::Change.new(target, message, &block)
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module Spec
-  module Matchers
-
-    class Eql #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-
-      def matches?(actual)
-        @actual = actual
-        @actual.eql?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
-      end
-
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual
-      end
-
-      def description
-        "eql #{@expected.inspect}"
-      end
-    end
-
-    # :call-seq:
-    #   should eql(expected)
-    #   should_not eql(expected)
-    #
-    # Passes if actual and expected are of equal value, but not necessarily the same object.
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # == Examples
-    #
-    #   5.should eql(5)
-    #   5.should_not eql(3)
-    def eql(expected)
-      Matchers::Eql.new(expected)
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module Spec
-  module Matchers
-
-    class Equal #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-
-      def matches?(actual)
-        @actual = actual
-        @actual.equal?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
-      end
-
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual
-      end
-
-      def description
-        "equal #{@expected.inspect}"
-      end
-    end
-
-    # :call-seq:
-    #   should equal(expected)
-    #   should_not equal(expected)
-    #
-    # Passes if actual and expected are the same object (object identity).
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # == Examples
-    #
-    #   5.should equal(5) #Fixnums are equal
-    #   "5".should_not equal("5") #Strings that look the same are not the same object
-    def equal(expected)
-      Matchers::Equal.new(expected)
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Spec
-  module Matchers
-    class Exist
-      def matches? actual
-        @actual = actual
-        @actual.exist?
-      end
-      def failure_message
-        "expected #{@actual.inspect} to exist, but it doesn't."
-      end
-      def negative_failure_message
-        "expected #{@actual.inspect} to not exist, but it does."
-      end
-    end
-    def exist; Exist.new; end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Spec
-  module Matchers
-
-    class Has #:nodoc:
-      def initialize(sym, *args)
-        @sym = sym
-        @args = args
-      end
-
-      def matches?(target)
-        @target = target
-        begin
-          return target.send(predicate, *@args)
-        rescue => @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
-        return false
-      end
-
-      def failure_message
-        raise @error if @error
-        "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
-      end
-
-      def negative_failure_message
-        raise @error if @error
-        "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
-      end
-
-      def description
-        "have key #{@args[0].inspect}"
-      end
-
-      private
-        def predicate
-          "#{@sym.to_s.sub("have_","has_")}?".to_sym
-        end
-
-    end
-
-  end
-end

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

@@ -1,145 +0,0 @@
-module Spec
-  module Matchers
-
-    class Have #:nodoc:
-      def initialize(expected, relativity=:exactly)
-        @expected = (expected == :no ? 0 : expected)
-        @relativity = relativity
-      end
-
-      def relativities
-        @relativities ||= {
-          :exactly => "",
-          :at_least => "at least ",
-          :at_most => "at most "
-        }
-      end
-
-      def method_missing(sym, *args, &block)
-        @collection_name = sym
-        @plural_collection_name = Inflector.pluralize(sym.to_s) if Object.const_defined?(:Inflector)
-        @args = args
-        @block = block
-        self
-      end
-
-      def matches?(collection_owner)
-        if collection_owner.respond_to?(@collection_name)
-          collection = collection_owner.send(@collection_name, *@args, &@block)
-        elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
-          collection = collection_owner.send(@plural_collection_name, *@args, &@block)
-        elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
-          collection = collection_owner
-        else
-          collection_owner.send(@collection_name, *@args, &@block)
-        end
-        @actual = collection.size if collection.respond_to?(:size)
-        @actual = collection.length if collection.respond_to?(:length)
-        raise not_a_collection if @actual.nil?
-        return @actual >= @expected if @relativity == :at_least
-        return @actual <= @expected if @relativity == :at_most
-        return @actual == @expected
-      end
-
-      def not_a_collection
-        "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
-      end
-
-      def failure_message
-        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
-      end
-
-      def negative_failure_message
-        if @relativity == :exactly
-          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
-        elsif @relativity == :at_most
-          return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_most(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should have_at_least(#{@expected + 1}).#{@collection_name}
-EOF
-        elsif @relativity == :at_least
-          return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  should_not have_at_least(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should have_at_most(#{@expected - 1}).#{@collection_name}
-EOF
-        end
-      end
-
-      def description
-        "have #{relative_expectation} #{@collection_name}"
-      end
-
-      private
-
-      def relative_expectation
-        "#{relativities[@relativity]}#{@expected}"
-      end
-    end
-
-    # :call-seq:
-    #   should have(number).named_collection__or__sugar
-    #   should_not have(number).named_collection__or__sugar
-    #
-    # Passes if receiver is a collection with the submitted
-    # number of items OR if the receiver OWNS a collection
-    # with the submitted number of items.
-    #
-    # If the receiver OWNS the collection, you must use the name
-    # of the collection. So if a <tt>Team</tt> instance has a
-    # collection named <tt>#players</tt>, you must use that name
-    # to set the expectation.
-    #
-    # If the receiver IS the collection, you can use any name
-    # you like for <tt>named_collection</tt>. We'd recommend using
-    # either "elements", "members", or "items" as these are all
-    # standard ways of describing the things IN a collection.
-    #
-    # This also works for Strings, letting you set an expectation
-    # about its length
-    #
-    # == Examples
-    #
-    #   # Passes if team.players.size == 11
-    #   team.should have(11).players
-    #
-    #   # Passes if [1,2,3].length == 3
-    #   [1,2,3].should have(3).items #"items" is pure sugar
-    #
-    #   # Passes if "this string".length == 11
-    #   "this string".should have(11).characters #"characters" is pure sugar
-    def have(n)
-      Matchers::Have.new(n)
-    end
-    alias :have_exactly :have
-
-    # :call-seq:
-    #   should have_at_least(number).items
-    #
-    # Exactly like have() with >=.
-    #
-    # == Warning
-    #
-    # +should_not+ +have_at_least+ is not supported
-    def have_at_least(n)
-      Matchers::Have.new(n, :at_least)
-    end
-
-    # :call-seq:
-    #   should have_at_most(number).items
-    #
-    # Exactly like have() with <=.
-    #
-    # == Warning
-    #
-    # +should_not+ +have_at_most+ is not supported
-    def have_at_most(n)
-      Matchers::Have.new(n, :at_most)
-    end
-  end
-end