mack 0.8.2 → 0.8.3

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

@@ -0,0 +1,208 @@
+module Spec
+  module Matchers
+    
+    class Be #:nodoc:
+      def initialize(*args)
+        @expected = args.empty? ? true : set_expected(args.shift)
+        @args = args
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        handling_predicate? ? run_predicate_on(actual) : match_or_compare(actual)
+      end
+      
+      def run_predicate_on(actual)
+        begin
+          return @result = actual.__send__(predicate, *@args)
+        rescue NameError => predicate_missing_error
+          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+        end
+
+        begin
+          return @result = actual.__send__(present_tense_predicate, *@args)
+        rescue NameError
+          raise predicate_missing_error
+        end
+      end
+      
+      def failure_message
+        handling_predicate? ?
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}" :
+          "expected #{@comparison_method} #{expected}, got #{@actual.inspect}".gsub('  ',' ')
+      end
+      
+      def negative_failure_message
+        if handling_predicate?
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        else
+          message = <<-MESSAGE
+'should_not be #{@comparison_method} #{expected}' not only FAILED,
+it reads really poorly.
+          MESSAGE
+          
+          raise message << ([:===,:==].include?(@comparison_method) ?
+            "Why don't you try expressing it without the \"be\"?" :
+            "Why don't you try expressing it in the positive?")
+        end
+      end
+      
+      def description
+        "#{prefix_to_sentence}#{comparison} #{expected_to_sentence}#{args_to_sentence}".gsub(/\s+/,' ')
+      end
+
+      [:==, :<, :<=, :>=, :>, :===].each do |method|
+        define_method method do |expected|
+          compare_to(expected, :using => method)
+          self
+        end
+      end
+
+      private
+        def match_or_compare(actual)
+          case @expected
+          when TrueClass
+            @actual
+          else
+            @actual.__send__(comparison_method, @expected)
+          end
+        end
+      
+        def comparison_method
+          @comparison_method || :equal?
+        end
+      
+        def expected
+          @expected
+        end
+
+        def compare_to(expected, opts)
+          @expected, @comparison_method = expected, opts[:using]
+        end
+
+        def set_expected(expected)
+          Symbol === expected ? parse_expected(expected) : expected
+        end
+        
+        def parse_expected(expected)
+          ["be_an_","be_a_","be_"].each do |prefix|
+            handling_predicate!
+            if expected.starts_with?(prefix)
+              set_prefix(prefix)
+              expected = expected.to_s.sub(prefix,"")
+              [true, false, nil].each do |val|
+                return val if val.to_s == expected
+              end
+              return expected.to_sym
+            end
+          end
+        end
+        
+        def set_prefix(prefix)
+          @prefix = prefix
+        end
+        
+        def prefix
+          @prefix
+        end
+
+        def handling_predicate!
+          @handling_predicate = true
+        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
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+        
+        def parenthesize(string)
+          return "(#{string})"
+        end
+        
+        def inspected_args
+          @args.collect{|a| a.inspect}
+        end
+        
+        def comparison
+          @comparison_method.nil? ? " " : "be #{@comparison_method.to_s} "
+        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_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 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_true
+    #   target.should be_false
+    #   target.should be_nil
+    #   target.should_not be_nil
+    #
+    #   collection.should be_empty #passes if target.empty?
+    #   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
+
+    # passes if target.kind_of?(klass)
+    def be_a(klass)
+      be_a_kind_of(klass)
+    end
+    
+    alias_method :be_an, :be_a
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/be_close.rb

@@ -0,0 +1,21 @@
+module Spec
+  module Matchers
+
+    # :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)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message = "expected #{expected} +/- (< #{delta}), got #{actual}"
+        matcher.description = "be close to #{expected} (within +- #{delta})"
+        (actual - expected).abs < delta
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Spec
+  module Matchers
+  
+    # :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)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .eql?)", expected, actual
+        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .eql?)", expected, actual
+        matcher.description              = "eql #{expected.inspect}"
+        actual.eql?(expected)
+      end
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/equal.rb

@@ -0,0 +1,25 @@
+module Spec
+  module Matchers
+  
+    # :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)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .equal?)", expected, actual
+        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .equal?)", expected, actual
+        matcher.description              = "equal #{expected.inspect}"
+        actual.equal?(expected)
+      end
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/errors.rb

@@ -0,0 +1,5 @@
+module Spec
+  module Matchers
+    class MatcherError < StandardError; end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/exist.rb

@@ -0,0 +1,16 @@
+module Spec
+  module Matchers
+    # :call-seq:
+    #   should exist
+    #   should_not exist
+    #
+    # Passes if actual.exist?
+    def exist
+      simple_matcher do |actual, matcher|
+        matcher.failure_message = "expected #{actual.inspect} to exist, but it doesn't."
+        matcher.negative_failure_message = "expected #{actual.inspect} to not exist, but it does."
+        actual.exist?
+      end
+    end
+  end
+end

data/lib/gems/rspec-1.1.12/lib/spec/matchers/generated_descriptions.rb

@@ -0,0 +1,48 @@
+module Spec
+  module Matchers
+    def self.last_matcher
+      @last_matcher
+    end
+
+    def self.last_matcher=(last_matcher)
+      @last_matcher = last_matcher
+    end
+
+    def self.last_should
+      @last_should
+    end
+
+    def self.last_should=(last_should)
+      @last_should = last_should
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
+    end
+    
+    private
+    
+    def self.last_description
+      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
+When you call a matcher in an example without a String, like this:
+
+specify { object.should matcher }
+
+or this:
+
+it { should matcher }
+
+the runner expects the matcher to have a #describe method. You should either
+add a String to the example this matcher is being used in, or give it a
+description method. Then you won't have to suffer this lengthy warning again.
+MESSAGE
+    end
+  end
+end
+      

data/lib/gems/rspec-1.1.12/lib/spec/matchers/has.rb

@@ -0,0 +1,18 @@
+module Spec
+  module Matchers
+    def has(sym, *args) # :nodoc:
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false"
+        matcher.negative_failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return false, got true"
+        matcher.description              = "have key #{args[0].inspect}"
+        actual.__send__(predicate(sym), *args)
+      end
+    end
+    
+  private
+    def predicate(sym)
+      "#{sym.to_s.sub("have_","has_")}?".to_sym
+    end
+
+  end
+end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/matchers/include.rb

@@ -7,16 +7,19 @@ module Spec
         @expecteds = expecteds
       end
       
-      def matches?(given)
-        @given = given
+      def matches?(actual)
+        @actual = actual
         @expecteds.each do |expected|
-          case given
-          when Hash
-            expected.each_pair do |k,v|
-              return false unless given[k] == v
+          if actual.is_a?(Hash)
+            if expected.is_a?(Hash)
+              expected.each_pair do |k,v|
+                return false unless actual[k] == v
+              end
+            else
+              return false unless actual.has_key?(expected)
             end
           else
-            return false unless given.include?(expected)
+            return false unless actual.include?(expected)
           end
         end
         true
@@ -36,7 +39,7 @@ module Spec
       
       private
         def _message(maybe_not="")
-          "expected #{@given.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
+          "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
         end
         
         def _pretty_print(array)
@@ -58,7 +61,7 @@ module Spec
     #   should include(expected)
     #   should_not include(expected)
     #
-    # Passes if given includes expected. This works for
+    # 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.
     #

data/lib/gems/rspec-1.1.12/lib/spec/matchers/match.rb

@@ -0,0 +1,22 @@
+module Spec
+  module Matchers
+    
+    # :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)
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected #{actual.inspect} to match #{regexp.inspect}", regexp, actual
+        matcher.negative_failure_message = "expected #{actual.inspect} not to match #{regexp.inspect}", regexp, actual
+        matcher.description              = "match #{regexp.inspect}"
+        actual =~ regexp
+      end
+    end
+  end
+end