micronaut 0.2.9

data/lib/micronaut/matchers/include.rb

@@ -0,0 +1,80 @@
+module Micronaut
+  module Matchers
+
+    class Include #:nodoc:
+      
+      def initialize(*expecteds)
+        @expecteds = expecteds
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @expecteds.each do |expected|
+          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 actual.include?(expected)
+          end
+        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/lib/micronaut/matchers/match.rb

@@ -0,0 +1,22 @@
+module Micronaut
+  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

data/lib/micronaut/matchers/method_missing.rb

@@ -0,0 +1,9 @@
+module Micronaut
+  module Matchers
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return has(sym, *args) if sym.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/lib/micronaut/matchers/operator_matcher.rb

@@ -0,0 +1,50 @@
+module Micronaut
+  module Matchers
+    class OperatorMatcher
+
+      def initialize(actual)
+        @actual = actual
+      end
+      
+      ['==','===','<','<=','>=','>','=~'].each do |operator|
+        define_method operator do |expected|
+          ::Micronaut::Matchers.last_matcher = self
+          @operator, @expected = operator, expected
+          __delegate_operator(@actual, operator, expected)
+        end
+      end
+
+      def fail_with_message(message)
+        Micronaut::Expectations.fail_with(message, @expected, @actual)
+      end
+      
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+
+    end
+
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+
+      def __delegate_operator(actual, operator, expected)
+        return true if actual.__send__(operator, expected)
+        if ['==','===', '=~'].include?(operator)
+          fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
+        else
+          fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+
+    end
+
+    class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+
+      def __delegate_operator(actual, operator, expected)
+        return true unless actual.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/micronaut/matchers/raise_error.rb

@@ -0,0 +1,128 @@
+module Micronaut
+  module Matchers
+    class RaiseError #:nodoc:
+      def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        case expected_error_or_message
+        when String, Regexp
+          @expected_error, @expected_message = Exception, expected_error_or_message
+        else
+          @expected_error, @expected_message = expected_error_or_message, expected_message
+        end
+      end
+
+      def matches?(given_proc)
+        @raised_expected_error = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue @expected_error => @given_error
+          @raised_expected_error = true
+          @with_expected_message = verify_message
+        rescue Exception => @given_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
+
+        unless negative_expectation?
+          eval_block if @raised_expected_error && @with_expected_message && @block
+        end
+      ensure
+        return (@raised_expected_error && @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+      
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@given_error]
+          @eval_block_passed = true
+        rescue Exception => err
+          @given_error = err
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when nil
+          true
+        when Regexp
+          @expected_message =~ @given_error.message
+        else
+          @expected_message == @given_error.message
+        end
+      end
+      
+      def failure_message
+        @eval_block ? @given_error.message : "expected #{expected_error}#{given_error}"
+      end
+
+      def negative_failure_message
+        "expected no #{expected_error}#{given_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 given_error
+          @given_error.nil? ? " but nothing was raised" : ", got #{@given_error.inspect}"
+        end
+        
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+    end
+    
+    # :call-seq:
+    #   should raise_error()
+    #   should raise_error(NamedError)
+    #   should raise_error(NamedError, String)
+    #   should raise_error(NamedError, Regexp)
+    #   should raise_error() { |error| ... }
+    #   should raise_error(NamedError) { |error| ... }
+    #   should raise_error(NamedError, String) { |error| ... }
+    #   should raise_error(NamedError, Regexp) { |error| ... }
+    #   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.
+    # Pass an optional block to perform extra verifications on the exception matched
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should raise_error
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
+    #   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, &block)
+      Matchers::RaiseError.new(error, message, &block)
+    end
+  end
+end

data/lib/micronaut/matchers/respond_to.rb

@@ -0,0 +1,50 @@
+module Micronaut
+  module Matchers
+    
+    class RespondTo #:nodoc:
+
+      def initialize(*names)
+        @names = names
+        @names_not_responded_to = []
+      end
+      
+      def matches?(given)
+        @given = given
+        @names.each do |name|
+          unless given.respond_to?(name)
+            @names_not_responded_to << name
+          end
+        end
+        @names_not_responded_to.empty?
+      end
+      
+      def failure_message
+        "expected #{@given.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def negative_failure_message
+        "expected #{@given.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def description
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+        "respond to #{@names.inspect}"
+      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/lib/micronaut/matchers/satisfy.rb

@@ -0,0 +1,50 @@
+module Micronaut
+  module Matchers
+    
+    class Satisfy #:nodoc:
+
+      def initialize(&block)
+        @block = block
+      end
+      
+      def matches?(given, &block)
+        @block = block if block
+        @given = given
+        @block.call(given)
+      end
+      
+      def failure_message
+        "expected #{@given} to satisfy block"
+      end
+
+      def negative_failure_message
+        "expected #{@given} 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/lib/micronaut/matchers/simple_matcher.rb

@@ -0,0 +1,135 @@
+module Micronaut
+  module Matchers
+    class SimpleMatcher
+
+      attr_writer :failure_message, :negative_failure_message, :description
+      
+      def initialize(description, &match_block)
+        @description = description
+        @match_block = match_block
+      end
+
+      def matches?(given)
+        @given = given
+        case @match_block.arity
+        when 2
+          @match_block.call(@given, self)
+        else
+          @match_block.call(@given)
+        end
+      end
+      
+      def description
+        @description || explanation
+      end
+
+      def failure_message
+        @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}])
+      end
+
+      def negative_failure_message
+        @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}])
+      end
+
+      def explanation
+        "No description provided. See RDoc for simple_matcher()"
+      end
+      
+    end
+  
+    # simple_matcher makes it easy for you to create your own custom matchers
+    # in just a few lines of code when you don't need all the power of a
+    # completely custom matcher object.
+    #
+    # The <tt>description</tt> argument will appear as part of any failure
+    # message, and is also the source for auto-generated descriptions.
+    #
+    # The <tt>match_block</tt> can have an arity of 1 or 2. The first block
+    # argument will be the given value. The second, if the block accepts it
+    # will be the matcher itself, giving you access to set custom failure
+    # messages in favor of the defaults.
+    #
+    # The <tt>match_block</tt> should return a boolean: <tt>true</tt>
+    # indicates a match, which will pass if you use <tt>should</tt> and fail
+    # if you use <tt>should_not</tt>. false (or nil) indicates no match,
+    # which will do the reverse: fail if you use <tt>should</tt> and pass if
+    # you use <tt>should_not</tt>.
+    #
+    # An error in the <tt>match_block</tt> will bubble up, resulting in a
+    # failure.
+    #
+    # == Example with default messages
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| given % 2 == 0 }
+    #   end
+    #                    
+    #   describe 2 do
+    #     it "should be even" do
+    #       2.should be_even
+    #     end
+    #   end
+    #
+    # Given an odd number, this example would produce an error message stating:
+    # expected "an even number", got 3.
+    #
+    # Unfortunately, if you're a fan of auto-generated descriptions, this will
+    # produce "should an even number." Not the most desirable result. You can
+    # control that using custom messages:
+    #
+    # == Example with custom messages
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher("rhyme with #{expected.inspect}") do |given, matcher|
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   # OR
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher do |given, matcher|
+    #       matcher.description = "rhyme with #{expected.inspect}"
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   describe "pecan" do
+    #     it "should rhyme with 'be gone'" do
+    #       nut = "pecan"
+    #       nut.extend Rhymer
+    #       nut.should rhyme_with("be gone")
+    #     end
+    #   end
+    #
+    # The resulting messages would be:
+    #   description:              rhyme with "be gone"
+    #   failure_message:          expected "pecan" to rhyme with "be gone"
+    #   negative failure_message: expected "pecan" not to rhyme with "be gone"
+    #
+    # == Wrapped Expectations
+    #
+    # Because errors will bubble up, it is possible to wrap other expectations
+    # in a SimpleMatcher.
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| (given % 2).should == 0 }
+    #   end
+    #
+    # BE VERY CAREFUL when you do this. Only use wrapped expectations for
+    # matchers that will always be used in only the positive
+    # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both.
+    # The reason is that is you wrap a <tt>should</tt> and call the wrapper
+    # with <tt>should_not</tt>, the correct result (the <tt>should</tt>
+    # failing), will fail when you want it to pass.
+    #
+    def simple_matcher(description=nil, &match_block)
+      SimpleMatcher.new(description, &match_block)
+    end
+    
+  end
+end