spicycode-micronaut 0.2.1.5 → 0.2.1.6

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems/specification'
 require 'lib/micronaut/rake_task'
 
 GEM = "micronaut"
-GEM_VERSION = "0.2.1.5"
+GEM_VERSION = "0.2.1.6"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://github.com/spicycode/micronaut"

data/examples/lib/micronaut/behaviour_example.rb

@@ -60,7 +60,7 @@ describe Micronaut::Behaviour do
       end
       
       it "should add the caller to metadata" do
-        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:caller].should include("#{__FILE__}:#{__LINE__}")
+        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:caller][4].should =~ /#{__FILE__}:#{__LINE__}/
       end
       
       it "should add the the file_path to metadata" do

data/examples/lib/micronaut/expectations/extensions/object_example.rb

@@ -68,5 +68,79 @@ describe Object do
     end
 
   end
+  
+  module ExampleExpectations
+
+    class ArbitraryMatcher
+      def initialize(*args, &block)
+        if args.last.is_a? Hash
+          @expected = args.last[:expected]
+        end
+        if block_given?
+          @expected = block.call
+        end
+        @block = block
+      end
+
+      def matches?(target)
+        @target = target
+        return @expected == target
+      end
+
+      def with(new_value)
+        @expected = new_value
+        self
+      end
+
+      def failure_message
+        "expected #{@expected}, got #{@target}"
+      end
+
+      def negative_failure_message
+        "expected not #{@expected}, got #{@target}"
+      end
+    end
+
+    class PositiveOnlyMatcher < ArbitraryMatcher
+      undef negative_failure_message rescue nil
+    end
+
+    def arbitrary_matcher(*args, &block)
+      ArbitraryMatcher.new(*args, &block)
+    end
+
+    def positive_only_matcher(*args, &block)
+      PositiveOnlyMatcher.new(*args, &block)
+    end
+
+  end
+
+  describe "should and should not matcher handling" do
+    include ExampleExpectations
+
+    it "should handle submitted args" do
+      5.should arbitrary_matcher(:expected => 5)
+      5.should arbitrary_matcher(:expected => "wrong").with(5)
+      lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+      lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+      5.should_not arbitrary_matcher(:expected => 4)
+      5.should_not arbitrary_matcher(:expected => 5).with(4)
+      lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+      lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+    end
+
+    it "should handle the submitted block" do
+      5.should arbitrary_matcher { 5 }
+      5.should arbitrary_matcher(:expected => 4) { 5 }
+      5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+    end
+
+    it "should explain when matcher does not support should_not" do
+      lambda {
+        5.should_not positive_only_matcher(:expected => 5)
+      }.should fail_with(/Matcher does not support should_not.\n/)
+    end
+
+  end
 
 end

data/examples/lib/micronaut/matchers/be_example.rb

@@ -42,11 +42,11 @@ describe Micronaut::Matchers do
         actual.should be_foo
       end.should raise_error(/aaaah/)
     end
-    
+
   end
 
   describe "should_not be_predicate" do
-    
+
     it "should pass when actual returns false for :sym?" do
       actual = stub("actual", :happy? => false)
       actual.should_not be_happy
@@ -64,11 +64,11 @@ describe Micronaut::Matchers do
         Object.new.should_not be_happy
       end.should raise_error(NameError)
     end
-    
+
   end
 
   describe "should be_predicate(*args)" do
-    
+
     it "should pass when actual returns true for :predicate?(*args)" do
       actual = mock("actual")
       actual.expects(:older_than?).with(3).returns(true)
@@ -88,11 +88,11 @@ describe Micronaut::Matchers do
         Object.new.should be_older_than(3)
       end.should raise_error(NameError)
     end
-    
+
   end
 
   describe "should_not be_predicate(*args)" do
-    
+
     it "should pass when actual returns false for :predicate?(*args)" do
       actual = mock("actual")
       actual.expects(:older_than?).with(3).returns(false)
@@ -112,11 +112,11 @@ describe Micronaut::Matchers do
         Object.new.should_not be_older_than(3)
       end.should raise_error(NameError)
     end
-    
+
   end
 
   describe "should be_true" do
-    
+
     it "should pass when actual equal(true)" do
       true.should be_true
     end
@@ -126,11 +126,11 @@ describe Micronaut::Matchers do
         false.should be_true
       end.should fail_with("expected true, got false")
     end
-    
+
   end
 
   describe "should be_false" do
-    
+
     it "should pass when actual equal(false)" do
       false.should be_false
     end
@@ -140,11 +140,11 @@ describe Micronaut::Matchers do
         true.should be_false
       end.should fail_with("expected false, got true")
     end
-    
+
   end
 
   describe "should be_nil" do
-    
+
     it "should pass when actual is nil" do
       nil.should be_nil
     end
@@ -154,11 +154,11 @@ describe Micronaut::Matchers do
         :not_nil.should be_nil
       end.should fail_with("expected nil? to return true, got false")
     end
-    
+
   end
 
   describe "should_not be_nil" do
-    
+
     it "should pass when actual is not nil" do
       :not_nil.should_not be_nil
     end
@@ -168,11 +168,11 @@ describe Micronaut::Matchers do
         nil.should_not be_nil
       end.should fail_with("expected nil? to return false, got true")
     end
-    
+
   end
 
   describe "should be <" do
-    
+
     it "should pass when < operator returns true" do
       3.should be < 4
     end
@@ -180,11 +180,11 @@ describe Micronaut::Matchers do
     it "should fail when < operator returns false" do
       lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3")
     end
-    
+
   end
 
   describe "should be <=" do
-    
+
     it "should pass when <= operator returns true" do
       3.should be <= 4
       4.should be <= 4
@@ -193,11 +193,11 @@ describe Micronaut::Matchers do
     it "should fail when <= operator returns false" do
       lambda { 3.should be <= 2 }.should fail_with("expected <= 2, got 3")
     end
-    
+
   end
 
   describe "should be >=" do
-    
+
     it "should pass when >= operator returns true" do
       4.should be >= 4
       5.should be >= 4
@@ -206,11 +206,11 @@ describe Micronaut::Matchers do
     it "should fail when >= operator returns false" do
       lambda { 3.should be >= 4 }.should fail_with("expected >= 4, got 3")
     end
-    
+
   end
 
   describe "should be >" do
-    
+
     it "should pass when > operator returns true" do
       5.should be > 4
     end
@@ -218,11 +218,11 @@ describe Micronaut::Matchers do
     it "should fail when > operator returns false" do
       lambda { 3.should be > 4 }.should fail_with("expected > 4, got 3")
     end
-    
+
   end
 
   describe "should be ==" do
-    
+
     it "should pass when == operator returns true" do
       5.should be == 5
     end
@@ -230,11 +230,11 @@ describe Micronaut::Matchers do
     it "should fail when == operator returns false" do
       lambda { 3.should be == 4 }.should fail_with("expected == 4, got 3")
     end
-    
+
   end
 
   describe "should be ===" do
-    
+
     it "should pass when === operator returns true" do
       Hash.should be === Hash.new
     end
@@ -242,21 +242,21 @@ describe Micronaut::Matchers do
     it "should fail when === operator returns false" do
       lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === not a hash, got Hash])
     end
-    
+
   end
 
   describe "should_not with operators" do
-    
+
     it "should coach user to stop using operators with should_not" do
       lambda do
         5.should_not be < 6
       end.should raise_error(/not only FAILED,\nit reads really poorly./m)
     end
-    
+
   end
 
   describe "should be" do
-    
+
     it "should pass if actual is true or a set value" do
       true.should be
       1.should be
@@ -269,30 +269,30 @@ describe Micronaut::Matchers do
     it "should fail if actual is nil" do
       lambda {nil.should be}.should fail_with("expected true, got nil")
     end
-    
+
   end
 
   describe "should be(value)" do
-    
+
     it "should pass if actual.equal?(value)" do
       5.should be(5)
     end
-    
+
     it "should fail if !actual.equal?(value)" do
       lambda { 5.should be(6) }.should fail_with("expected 6, got 5")
     end
-    
+
   end
 
   describe "'should be' with operator" do
-    
+
     it "should include 'be' in the description" do
       (be > 6).description.should =~ /be > 6/
       (be >= 6).description.should =~ /be >= 6/
       (be <= 6).description.should =~ /be <= 6/
       (be < 6).description.should =~ /be < 6/
     end
-    
+
   end
 
 end

data/examples/lib/micronaut/matchers/have_example.rb

@@ -3,9 +3,9 @@ require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 describe Micronaut::Matchers, "have" do
 
   before do
-    unless defined?(ActiveSupport::Inflector)
+    unless defined?(::ActiveSupport::Inflector)
       @active_support_was_not_defined
-      module ActiveSupport
+      module ::ActiveSupport
         class Inflector
           def self.pluralize(string)
             string.to_s + 's'
@@ -76,9 +76,9 @@ describe Micronaut::Matchers, "have" do
   describe 'should have(1).item when Inflector is defined' do
     
     before do
-      unless defined?(Inflector)
+      unless defined?(::Inflector)
         @inflector_was_not_defined
-        class Inflector
+        class ::Inflector
           def self.pluralize(string)
             string.to_s + 's'
           end

data/lib/micronaut/behaviour.rb

@@ -220,6 +220,6 @@ module Micronaut
     def self.to_s
       self == Micronaut::Behaviour ? 'Micronaut::Behaviour' : name
     end
-    
+   
   end
-end
+end

data/lib/micronaut/example.rb

@@ -20,21 +20,20 @@ module Micronaut
     end
 
     def run_before_each
-      @behaviour_instance._setup_mocks
+      @behaviour_instance._setup_mocks if @behaviour_instance.respond_to?(:_setup_mocks)
       @behaviour.eval_before_eachs(@behaviour_instance)
     end
 
     def run_after_each
       @behaviour.eval_after_eachs(@behaviour_instance)
-      @behaviour_instance._verify_mocks
+      @behaviour_instance._verify_mocks if @behaviour_instance.respond_to?(:_verify_mocks)
     ensure
-      @behaviour_instance._teardown_mocks
+      @behaviour_instance._teardown_mocks if @behaviour_instance.respond_to?(:_teardown_mocks)
     end
 
     def run_example
       if example_block
         @behaviour_instance.instance_eval(&example_block)
-        @behaviour_instance._verify_mocks
         @reporter.example_passed(self)
       else
         @reporter.example_pending(self, 'Not yet implemented')

data/lib/micronaut/expectations.rb

@@ -1,6 +1,5 @@
 require 'micronaut/matchers'
 require 'micronaut/expectations/extensions/object'
-require 'micronaut/expectations/extensions/string_and_symbol'
 require 'micronaut/expectations/handler'
 require 'micronaut/expectations/wrap_expectation'
 

data/lib/micronaut/expectations/extensions/object.rb

@@ -1,6 +1,7 @@
 module Micronaut
   module Expectations
-    # We add #should and #should_not to every Object (and, implicitly, every Class).
+    class InvalidMatcherError < ArgumentError; end        
+    
     module ObjectExpectations
       # :call-seq:
       #   should(matcher)
@@ -23,11 +24,21 @@ module Micronaut
       # See Micronaut::Matchers for more information about matchers
       #
       # == Warning
-      #
       # NOTE that this does NOT support receiver.should != expected.
       # Instead, use receiver.should_not == expected
       def should(matcher=nil, &block)
-        ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+        ::Micronaut::Matchers.last_should = "should"
+        return ::Micronaut::Matchers::PositiveOperatorMatcher.new(self) if matcher.nil?
+
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+        end
+
+        match_found = matcher.matches?(self, &block)
+        ::Micronaut::Matchers.last_matcher = matcher
+        
+        ::Micronaut::Expectations.fail_with(matcher.failure_message) unless match_found
+        match_found
       end
 
       # :call-seq:
@@ -50,7 +61,26 @@ module Micronaut
       #
       # See Micronaut::Matchers for more information about matchers
       def should_not(matcher=nil, &block)
-        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+        ::Micronaut::Matchers.last_should = "should not"
+        return ::Micronaut::Matchers::NegativeOperatorMatcher.new(self) if matcher.nil?
+
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+        end
+
+        unless matcher.respond_to?(:negative_failure_message)
+          ::Micronaut::Expectations.fail_with(
+          <<-EOF
+          Matcher does not support should_not.
+          See Micronaut::Matchers for more information about matchers.
+          EOF
+          )
+        end
+        match_found = matcher.matches?(self, &block)
+        ::Micronaut::Matchers.last_matcher = matcher
+        
+        ::Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match_found
+        match_found
       end
 
     end
@@ -59,4 +89,4 @@ end
 
 class Object
   include Micronaut::Expectations::ObjectExpectations
-end
+end

data/lib/micronaut/expectations/handler.rb

@@ -1,52 +1,51 @@
 module Micronaut
   module Expectations
-    class InvalidMatcherError < ArgumentError; end        
     
-    class ExpectationMatcherHandler        
 
-        def self.handle_matcher(actual, matcher, &block)
-          ::Micronaut::Matchers.last_should = "should"
-          return Micronaut::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-          unless matcher.respond_to?(:matches?)
-            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-          end
-          
-          match = matcher.matches?(actual, &block)
-          ::Micronaut::Matchers.last_matcher = matcher
-          Micronaut::Expectations.fail_with(matcher.failure_message) unless match
-          match
-        end
-
-    end
-
-    class NegativeExpectationMatcherHandler
-
-        def self.handle_matcher(actual, matcher, &block)
-          ::Micronaut::Matchers.last_should = "should not"
-          return Micronaut::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
-          
-          unless matcher.respond_to?(:matches?)
-            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-          end
-
-          unless matcher.respond_to?(:negative_failure_message)
-            Micronaut::Expectations.fail_with(
-<<-EOF
-Matcher does not support should_not.
-See Micronaut::Matchers for more information
-about matchers.
-EOF
-)
-          end
-          match = matcher.matches?(actual, &block)
-          ::Micronaut::Matchers.last_matcher = matcher
-          Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match
-          match
-        end
-        
-    end
+    # class ExpectationMatcherHandler        
+    # 
+    #      def self.handle_matcher(actual, matcher, &block)
+    #        ::Micronaut::Matchers.last_should = "should"
+    #        return Micronaut::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+    # 
+    #        unless matcher.respond_to?(:matches?)
+    #          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+    #        end
+    # 
+    #        match = matcher.matches?(actual, &block)
+    #        ::Micronaut::Matchers.last_matcher = matcher
+    #        Micronaut::Expectations.fail_with(matcher.failure_message) unless match
+    #        match
+    #      end
+    # 
+    #    end
+
+    # class NegativeExpectationMatcherHandler
+    # 
+    #      def self.handle_matcher(actual, matcher, &block)
+    #        ::Micronaut::Matchers.last_should = "should not"
+    #        return Micronaut::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+    # 
+    #        unless matcher.respond_to?(:matches?)
+    #          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+    #        end
+    # 
+    #        unless matcher.respond_to?(:negative_failure_message)
+    #          Micronaut::Expectations.fail_with(
+    #          <<-EOF
+    #          Matcher does not support should_not.
+    #          See Micronaut::Matchers for more information
+    #          about matchers.
+    #          EOF
+    #          )
+    #        end
+    #        match = matcher.matches?(actual, &block)
+    #        ::Micronaut::Matchers.last_matcher = matcher
+    #        Micronaut::Expectations.fail_with(matcher.negative_failure_message) if match
+    #        match
+    #      end
+   
+    # end
 
   end
-end
-
+end

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -117,6 +117,14 @@ module Micronaut
         return text unless color_enabled?
         "#{color_code}#{text}\e[0m"
       end
+      
+      def bold(text)
+        color(text, "\e[1m")
+      end
+      
+      def white(text)
+        color(text, "\e[37m")
+      end
 
       def green(text)
         color(text, "\e[32m")

data/lib/micronaut/matchers.rb

@@ -124,22 +124,15 @@ module Micronaut
   #     include CustomGameMatchers
   #     ...
   #   end
-  #
-  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
-  # from your spec file(s):
-  #
-  #   Micronaut::Runner.configure do |config|
-  #     config.include(CustomGameMatchers)
-  #   end
-  #
+
   module Matchers
     
     class MatcherError < StandardError; end
     
     private
     def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
-      return has(sym, *args) if sym.starts_with?("have_")
+      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return has(sym, *args) if sym.to_s =~ /^have_/
       super
     end
       

data/lib/micronaut/matchers/be.rb

@@ -87,7 +87,7 @@ it reads really poorly.
         def parse_expected(expected)
           ["be_an_","be_a_","be_"].each do |prefix|
             handling_predicate!
-            if expected.starts_with?(prefix)
+            if expected.to_s =~ /^#{prefix}/
               set_prefix(prefix)
               expected = expected.to_s.sub(prefix,"")
               [true, false, nil].each do |val|

data/lib/micronaut/matchers/be_close.rb

@@ -1,5 +1,24 @@
 module Micronaut
   module Matchers
+    
+    class BeClose
+      def initialize(expected, delta)
+        @expected, @delta = expected, 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)
@@ -11,12 +30,8 @@ module Micronaut
     #
     #   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
+      BeClose.new(expected, delta)
     end
-
+    
   end
-end
+end

data/lib/micronaut/matchers/method_missing.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.2.1.5
+  version: 0.2.1.6
 platform: ruby
 authors: 
 - Chad Humphries
@@ -9,7 +9,7 @@ autorequire: micronaut
 bindir: bin
 cert_chain: []
 
-date: 2009-01-20 00:00:00 -08:00
+date: 2009-01-30 00:00:00 -08:00
 default_executable: micronaut
 dependencies: []
 
@@ -35,7 +35,6 @@ files:
 - lib/micronaut/expectations
 - lib/micronaut/expectations/extensions
 - lib/micronaut/expectations/extensions/object.rb
-- lib/micronaut/expectations/extensions/string_and_symbol.rb
 - lib/micronaut/expectations/handler.rb
 - lib/micronaut/expectations/wrap_expectation.rb
 - lib/micronaut/expectations.rb
@@ -96,7 +95,6 @@ files:
 - examples/lib/micronaut/matchers/description_generation_example.rb
 - examples/lib/micronaut/matchers/eql_example.rb
 - examples/lib/micronaut/matchers/equal_example.rb
-- examples/lib/micronaut/matchers/handler_example.rb
 - examples/lib/micronaut/matchers/has_example.rb
 - examples/lib/micronaut/matchers/have_example.rb
 - examples/lib/micronaut/matchers/include_example.rb

data/examples/lib/micronaut/matchers/handler_example.rb

@@ -1,153 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
-
-module ExampleExpectations
-  
-  class ArbitraryMatcher
-    def initialize(*args, &block)
-      if args.last.is_a? Hash
-        @expected = args.last[:expected]
-      end
-      if block_given?
-        @expected = block.call
-      end
-      @block = block
-    end
-    
-    def matches?(target)
-      @target = target
-      return @expected == target
-    end
-    
-    def with(new_value)
-      @expected = new_value
-      self
-    end
-    
-    def failure_message
-      "expected #{@expected}, got #{@target}"
-    end
-    
-    def negative_failure_message
-      "expected not #{@expected}, got #{@target}"
-    end
-  end
-  
-  class PositiveOnlyMatcher < ArbitraryMatcher
-    undef negative_failure_message rescue nil
-  end
-  
-  def arbitrary_matcher(*args, &block)
-    ArbitraryMatcher.new(*args, &block)
-  end
-  
-  def positive_only_matcher(*args, &block)
-    PositiveOnlyMatcher.new(*args, &block)
-  end
-  
-end
-
-describe Micronaut::Expectations::ExpectationMatcherHandler do
-  
-  describe "#handle_matcher" do
-    
-    it "should ask the matcher if it matches" do
-      matcher = mock("matcher")
-      actual = Object.new
-      matcher.expects(:matches?).with(actual).returns(true)
-      Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher)
-    end
-  
-    it "should explain when the matcher parameter is not a matcher" do
-      begin
-        nonmatcher = mock("nonmatcher")
-        actual = Object.new
-        Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
-      rescue Micronaut::Expectations::InvalidMatcherError => e
-      end
-
-      e.message.should =~ /^Expected a matcher, got /
-    end
-    
-    it "should return the match value" do
-      matcher = mock("matcher")
-      actual = Object.new
-      matcher.expects(:matches?).with(actual).returns(:this_value)
-      Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher).should == :this_value
-    end
-    
-  end
-  
-end
-
-describe Micronaut::Expectations::NegativeExpectationMatcherHandler do
-  
-  describe "#handle_matcher" do
-    
-    it "should explain when matcher does not support should_not" do
-      matcher = mock("matcher")
-      matcher.stubs(:matches?)
-      actual = Object.new
-      lambda {
-        Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
-      }.should fail_with(/Matcher does not support should_not.\n/)
-    end      
-  
-    it "should ask the matcher if it matches" do
-      matcher = mock("matcher")
-      actual = Object.new
-      matcher.stubs(:negative_failure_message)
-      matcher.expects(:matches?).with(actual).returns(false)
-      Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
-    end
-  
-    it "should explain when the matcher parameter is not a matcher" do
-      begin
-        nonmatcher = mock("nonmatcher")
-        actual = Object.new
-        Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
-      rescue Micronaut::Expectations::InvalidMatcherError => e
-      end
-
-      e.message.should =~ /^Expected a matcher, got /
-    end
-
-    
-    it "should return the match value" do
-      matcher = mock("matcher")
-      actual = Object.new
-      matcher.expects(:matches?).with(actual).returns(false)
-      matcher.stubs(:negative_failure_message).returns("ignore")
-      Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher).should be_false
-    end
-    
-  end
-  
-end
-
-describe Micronaut::Expectations::ExpectationMatcherHandler do
-  include ExampleExpectations
-  
-  it "should handle submitted args" do
-    5.should arbitrary_matcher(:expected => 5)
-    5.should arbitrary_matcher(:expected => "wrong").with(5)
-    lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
-    lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
-    5.should_not arbitrary_matcher(:expected => 4)
-    5.should_not arbitrary_matcher(:expected => 5).with(4)
-    lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
-    lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
-  end
-
-  it "should handle the submitted block" do
-    5.should arbitrary_matcher { 5 }
-    5.should arbitrary_matcher(:expected => 4) { 5 }
-    5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
-  end
-
-  it "should explain when matcher does not support should_not" do
-    lambda {
-      5.should_not positive_only_matcher(:expected => 5)
-    }.should fail_with(/Matcher does not support should_not.\n/)
-  end
-
-end

data/lib/micronaut/expectations/extensions/string_and_symbol.rb

@@ -1,19 +0,0 @@
-module Micronaut
-  module Expectations
-    module StringHelpers
-
-      def starts_with?(prefix)
-        to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
-      end
-
-    end
-  end
-end
-
-class String
-  include Micronaut::Expectations::StringHelpers
-end
-
-class Symbol
-  include Micronaut::Expectations::StringHelpers
-end