spicycode-micronaut 0.0.2

data/lib/micronaut/matchers/have.rb

@@ -0,0 +1,150 @@
+module Micronaut
+  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 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
+        @given = collection.size if collection.respond_to?(:size)
+        @given = collection.length if collection.respond_to?(:length)
+        raise not_a_collection if @given.nil?
+        return @given >= @expected if @relativity == :at_least
+        return @given <= @expected if @relativity == :at_most
+        return @given == @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 #{@given}"
+      end
+
+      def negative_failure_message
+        if @relativity == :exactly
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@given}"
+        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
+      
+      def respond_to?(sym)
+        @expected.respond_to?(sym) || super
+      end
+    
+      private
+      
+      def method_missing(sym, *args, &block)
+        @collection_name = sym
+        if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(sym.to_s)
+        end
+        @args = args
+        @block = block
+        self
+      end
+      
+      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

data/lib/micronaut/matchers/include.rb

@@ -0,0 +1,77 @@
+module Micronaut
+  module Matchers
+
+    class Include #:nodoc:
+      
+      def initialize(*expecteds)
+        @expecteds = expecteds
+      end
+      
+      def matches?(given)
+        @given = given
+        @expecteds.each do |expected|
+          case given
+          when Hash
+            expected.each_pair do |k,v|
+              return false unless given[k] == v
+            end
+          else
+            return false unless given.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 #{@given.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 given 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,41 @@
+module Micronaut
+  module Matchers
+    
+    class Match #:nodoc:
+      def initialize(regexp)
+        @regexp = regexp
+      end
+      
+      def matches?(given)
+        @given = given
+        return true if given =~ @regexp
+        return false
+      end
+      
+      def failure_message
+        return "expected #{@given.inspect} to match #{@regexp.inspect}", @regexp, @given
+      end
+      
+      def negative_failure_message
+        return "expected #{@given.inspect} not to match #{@regexp.inspect}", @regexp, @given
+      end
+      
+      def description
+        "match #{@regexp.inspect}"
+      end
+    end
+    
+    # :call-seq:
+    #   should match(regexp)
+    #   should_not match(regexp)
+    #
+    # Given a Regexp, passes if given =~ regexp
+    #
+    # == Examples
+    #
+    #   email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    def match(regexp)
+      Matchers::Match.new(regexp)
+    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.starts_with?("be_")
+      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+  end
+end

data/lib/micronaut/matchers/operator_matcher.rb

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

data/lib/micronaut/matchers/raise_error.rb

@@ -0,0 +1,132 @@
+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
+          return true
+        when Regexp
+          return @expected_message =~ @given_error.message
+        else
+          return @expected_message == @given_error.message
+        end
+      end
+      
+      def failure_message
+        if @eval_block
+          return @given_error.message
+        else
+          return "expected #{expected_error}#{given_error}"
+        end
+      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,46 @@
+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
+        return @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
+        "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/lib/micronaut/matchers/satisfy.rb

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