mack 0.8.1 → 0.8.2

data/lib/gems/rspec-1.1.11/lib/spec/matchers/be.rb

@@ -0,0 +1,221 @@
+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?(given)
+        @given = given
+        if handling_predicate?
+          begin
+            return @result = given.__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
+
+          begin
+            return @result = given.__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 #{@given.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 #{@given.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 @given ? true : false if @expected == :satisfy_if
+        return @given == true if @expected == :true
+        return @given == false if @expected == :false
+        return @given.nil? if @expected == :nil
+        return @given < @expected if @less_than
+        return @given <= @expected if @less_than_or_equal
+        return @given >= @expected if @greater_than_or_equal
+        return @given > @expected if @greater_than
+        return @given == @expected if @double_equal
+        return @given === @expected if @triple_equal
+        return @given.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 given value 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/lib/gems/rspec-1.1.11/lib/spec/matchers/be_close.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Matchers
+
+    class BeClose #:nodoc:
+      def initialize(expected, delta)
+        @expected = expected
+        @delta = delta
+      end
+      
+      def matches?(given)
+        @given = given
+        (@given - @expected).abs < @delta
+      end
+      
+      def failure_message
+        "expected #{@expected} +/- (< #{@delta}), got #{@given}"
+      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 given == 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/lib/gems/rspec-1.1.11/lib/spec/matchers/change.rb

@@ -0,0 +1,148 @@
+module Spec
+  module Matchers
+    
+    #Based on patch from Wilson Bilkovich
+    class Change #:nodoc:
+      def initialize(receiver=nil, message=nil, &block)
+        @message = message || "result"
+        @value_proc = block || lambda {
+          receiver.__send__(message)
+        }
+      end
+      
+      def matches?(event_proc)
+        raise_block_syntax_error if block_given?
+        
+        @before = evaluate_value_proc
+        event_proc.call
+        @after = evaluate_value_proc
+        
+        return false if @from unless @from == @before
+        return false if @to unless @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 raise_block_syntax_error
+        raise MatcherError.new(<<-MESSAGE
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        )
+      end
+      
+      def evaluate_value_proc
+        @value_proc.call
+      end
+      
+      def failure_message
+        if @to
+          "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+        elsif @from
+          "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+        elsif @amount
+          "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @minimum
+          "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @maximum
+          "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+        else
+          "#{@message} should have changed, but is still #{@before.inspect}"
+        end
+      end
+      
+      def actual_delta
+        @after - @before
+      end
+      
+      def negative_failure_message
+        "#{@message} 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 <tt>receiver.message</tt> or <tt>block</tt> before and after
+    # it evaluates the c object (generated by the lambdas in the examples
+    # above).
+    #
+    # Then compares the values before and after the <tt>receiver.message</tt>
+    # and evaluates the difference compared to the expected difference.
+    #
+    # == WARNING
+    # <tt>should_not change</tt> only supports the form with no
+    # subsequent calls to <tt>by</tt>, <tt>by_at_least</tt>,
+    # <tt>by_at_most</tt>, <tt>to</tt> or <tt>from</tt>.
+    #
+    # blocks passed to <tt>should</tt> <tt>change</tt> and <tt>should_not</tt>
+    # <tt>change</tt> must use the <tt>{}</tt> form (<tt>do/end</tt> is not
+    # supported).
+    #
+    def change(receiver=nil, message=nil, &block)
+      Matchers::Change.new(receiver, message, &block)
+    end
+  end
+end

data/lib/gems/rspec-1.1.11/lib/spec/matchers/eql.rb

@@ -0,0 +1,43 @@
+module Spec
+  module Matchers
+  
+    class Eql #:nodoc:
+      def initialize(expected)
+        @expected = expected
+      end
+  
+      def matches?(given)
+        @given = given
+        @given.eql?(@expected)
+      end
+
+      def failure_message
+        return "expected #{@expected.inspect}, got #{@given.inspect} (using .eql?)", @expected, @given
+      end
+      
+      def negative_failure_message
+        return "expected #{@given.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @given
+      end
+
+      def description
+        "eql #{@expected.inspect}"
+      end
+    end
+    
+    # :call-seq:
+    #   should eql(expected)
+    #   should_not eql(expected)
+    #
+    # Passes if given 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