spicycode-micronaut 0.1.3 → 0.1.4

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems/specification'
 require 'date'
 
 GEM = "micronaut"
-GEM_VERSION = "0.1.3"
+GEM_VERSION = "0.1.4"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://spicycode.com"

data/examples/example_helper.rb

@@ -29,7 +29,8 @@ end
 
 Micronaut.configure do |config|
   config.mock_with :mocha
-  config.options = Micronaut::RunnerOptions.new(:color => true, :formatter => :documentation)
+  config.options = Micronaut::RunnerOptions.new(:color => true, :formatter => :progress)
+  config.profile_examples = true
   # config.add_filter :options => { :focused => true }
   config.autorun!
 end

data/examples/lib/micronaut/configuration_example.rb

@@ -6,12 +6,12 @@ describe Micronaut::Configuration do
     
     it "should include the mocha adapter when called with :mocha" do
       Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithMocha)
-      Micronaut::Configuration.new.mock_with :mocha
+      Micronaut.configuration.mock_with :mocha
     end
   
     it "should include the do absolutely nothing mocking adapter for all other cases" do
       Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithAbsolutelyNothing)
-      Micronaut::Configuration.new.mock_with
+      Micronaut.configuration.mock_with
     end
     
   end
@@ -37,18 +37,18 @@ describe Micronaut::Configuration do
 
   describe "#extend" do
     
-    module FocusedSupport
+    module ThatThingISentYou
       
-      def fit(desc, options={}, &block)
-        it(desc, options.update(:focused => true), &block)
+      def that_thing(desc, options={}, &block)
+        it(desc, options.update(:that_thing => true), &block)
       end
       
     end
     
-    focused "should extend the given module into each behaviour group" do
-      Micronaut.configuration.extend(FocusedSupport)
-      group = Micronaut::Behaviour.describe(FocusedSupport, 'the focused support ') { }
-      group.should respond_to(:fit)
+    focused "should extend the given module into each behaviour" do
+      Micronaut.configuration.extend(ThatThingISentYou)
+      group = Micronaut::Behaviour.describe(ThatThingISentYou, 'that thing i sent you') { }
+      group.should respond_to(:that_thing)
       remove_last_describe_from_world
     end
     

data/examples/lib/micronaut/expectations/wrap_expectation_example.rb

@@ -1,31 +1,27 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-describe Micronaut::Matchers do
+describe Micronaut::Matchers, '#wrap_expectation' do
 
-    describe "wrap_expectation" do
-      
-      def stub_matcher
-        @_stub_matcher ||= simple_matcher do
-        end
-      end
-      
-      def failing_matcher
-        @_failing_matcher ||= simple_matcher do
-          1.should == 2
-        end
-      end
-      
-      it "should return true if there is no error" do
-        wrap_expectation stub_matcher do
-        end.should be_true
-      end
-      
-      it "should return false if there is an error" do
-        wrap_expectation failing_matcher do
-          raise "error"
-        end.should be_false
-      end
+  def stub_matcher
+    @_stub_matcher ||= simple_matcher do
+    end
+  end
 
+  def failing_matcher
+    @_failing_matcher ||= simple_matcher do
+      1.should == 2
     end
-    
+  end
+
+  it "should return true if there is no error" do
+    wrap_expectation stub_matcher do
+    end.should be_true
+  end
+
+  it "should return false if there is an error" do
+    wrap_expectation failing_matcher do
+      raise "error"
+    end.should be_false
+  end
+
 end

data/examples/lib/micronaut/formatters/progress_formatter_example.rb

@@ -7,6 +7,7 @@ describe Micronaut::Formatters::ProgressFormatter do
     @options = mock('options')
     @options.stubs(:enable_color_in_output?).returns(false)
     @formatter = Micronaut::Formatters::ProgressFormatter.new(@options, @io)
+    @original_profile_setting = Micronaut.configuration.profile_examples
   end
 
   it "should produce line break on start dump" do
@@ -16,7 +17,7 @@ describe Micronaut::Formatters::ProgressFormatter do
 
   it "should produce standard summary without pending when pending has a 0 count" do
     @formatter.dump_summary(3, 2, 1, 0)
-    @io.string.should == "\nFinished in 3 seconds\n2 examples, 1 failure\n"
+    @io.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failure\n/
   end
   
   it "should produce standard summary" do
@@ -28,7 +29,7 @@ describe Micronaut::Formatters::ProgressFormatter do
     @formatter.example_pending(example, "message")
     @io.rewind
     @formatter.dump_summary(3, 2, 1, 1)
-    @io.string.should == "\nFinished in 3 seconds\n2 examples, 1 failure, 1 pending\n"
+    @io.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failure, 1 pending\n/
   end
 
   it "should push green dot for passing spec" do

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

@@ -1,66 +1,78 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-module Micronaut
-  module Matchers
-    describe %Q{The Micronaut::Matchers module gets included in the execution context of every spec.
-This module should provide the following methods, each of which returns a Matcher object.} do
-      it "be_true" do
-        be_true.should be_an_instance_of(Be)
-      end
-      it "be_false" do
-        be_false.should be_an_instance_of(Be)
-      end
-      it "be_nil" do
-        be_nil.should be_an_instance_of(Be)
-      end
-      it "be_arbitrary_predicate" do
-        be_arbitrary_predicate.should be_an_instance_of(Be)
-      end
-      it "change" do
-        change("target", :message).should be_an_instance_of(Change)
-      end
-      it "have" do
-        have(0).should be_an_instance_of(Have)
-      end
-      it "have_exactly" do
-        have_exactly(0).should be_an_instance_of(Have)
-      end
-      it "have_at_least" do
-        have_at_least(0).should be_an_instance_of(Have)
-      end
-      it "have_at_most" do
-        have_at_most(0).should be_an_instance_of(Have)
-      end
-      it "include" do
-        include(:value).should be_an_instance_of(Include)
-      end
-      it "raise_error" do
-        raise_error.should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError).should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
-      end
-      it "satisfy" do
-        satisfy{}.should be_an_instance_of(Satisfy)
-      end
-      it "throw_symbol" do
-        throw_symbol.should be_an_instance_of(ThrowSymbol)
-        throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
-      end
-      it "respond_to" do
-        respond_to(:sym).should be_an_instance_of(RespondTo)
-      end
+describe Micronaut::Matchers, "provides the following matchers to examples" do
+
+  it "be_true" do
+    be_true.should be_an_instance_of(Micronaut::Matchers::Be)
+  end
+
+  it "be_false" do
+    be_false.should be_an_instance_of(Micronaut::Matchers::Be)
+  end
+
+  it "be_nil" do
+    be_nil.should be_an_instance_of(Micronaut::Matchers::Be)
+  end
+
+  it "be_arbitrary_predicate" do
+    be_arbitrary_predicate.should be_an_instance_of(Micronaut::Matchers::Be)
+  end
+
+  it "change" do
+    change("target", :message).should be_an_instance_of(Micronaut::Matchers::Change)
+  end
+
+  it "have" do
+    have(0).should be_an_instance_of(Micronaut::Matchers::Have)
+  end
+
+  it "have_exactly" do
+    have_exactly(0).should be_an_instance_of(Micronaut::Matchers::Have)
+  end
+
+  it "have_at_least" do
+    have_at_least(0).should be_an_instance_of(Micronaut::Matchers::Have)
+  end
+
+  it "have_at_most" do
+    have_at_most(0).should be_an_instance_of(Micronaut::Matchers::Have)
+  end
+
+  it "include" do
+    include(:value).should be_an_instance_of(Micronaut::Matchers::Include)
+  end
+
+  it "raise_error" do
+    raise_error.should be_an_instance_of(Micronaut::Matchers::RaiseError)
+    raise_error(NoMethodError).should be_an_instance_of(Micronaut::Matchers::RaiseError)
+    raise_error(NoMethodError, "message").should be_an_instance_of(Micronaut::Matchers::RaiseError)
+  end
+
+  it "satisfy" do
+    satisfy{}.should be_an_instance_of(Micronaut::Matchers::Satisfy)
+  end
+
+  it "throw_symbol" do
+    throw_symbol.should be_an_instance_of(Micronaut::Matchers::ThrowSymbol)
+    throw_symbol(:sym).should be_an_instance_of(Micronaut::Matchers::ThrowSymbol)
+  end
+
+  it "respond_to" do
+    respond_to(:sym).should be_an_instance_of(Micronaut::Matchers::RespondTo)
+  end
+  
+  describe "#method_missing" do
+
+    it "should convert be_xyz to Be(:be_xyz)" do
+      Micronaut::Matchers::Be.expects(:new).with(:be_whatever)
+      be_whatever
     end
-    
-    describe "Micronaut::Matchers#method_missing" do
-      it "should convert be_xyz to Be(:be_xyz)" do
-        Be.expects(:new).with(:be_whatever)
-        be_whatever
-      end
-
-      it "should convert have_xyz to Has(:have_xyz)" do
-        self.expects(:has).with(:have_whatever)
-        have_whatever
-      end
+
+    it "should convert have_xyz to Has(:have_xyz)" do
+      self.expects(:has).with(:have_whatever)
+      have_whatever
     end
+
   end
-end
+
+end

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

@@ -1,189 +1,193 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-describe "should ==" do
+describe "Operator Matchers" do 
   
-  it "should delegate message to target" do
-    subject = "apple"
-    subject.expects(:==).with("apple").returns(true)
-    subject.should == "apple"
-  end
-  
-  it "should return true on success" do
-    subject = "apple"
-    (subject.should == "apple").should be_true
-  end
+  describe "should ==" do
   
-  it "should fail when target.==(actual) returns false" do
-    subject = "apple"
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ==)], "orange", "apple")
-    subject.should == "orange"
-  end
+    it "should delegate message to target" do
+      subject = "apple"
+      subject.expects(:==).with("apple").returns(true)
+      subject.should == "apple"
+    end
   
-end
-
-describe "should_not ==" do
+    it "should return true on success" do
+      subject = "apple"
+      (subject.should == "apple").should be_true
+    end
   
-  it "should delegate message to target" do
-    subject = "orange"
-    subject.expects(:==).with("apple").returns(false)
-    subject.should_not == "apple"
-  end
+    it "should fail when target.==(actual) returns false" do
+      subject = "apple"
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ==)], "orange", "apple")
+      subject.should == "orange"
+    end
   
-  it "should return true on success" do
-    subject = "apple"
-    (subject.should_not == "orange").should be_true
   end
 
-  it "should fail when target.==(actual) returns false" do
-    subject = "apple"
-    Micronaut::Expectations.expects(:fail_with).with(%[expected not: == "apple",\n         got:    "apple"], "apple", "apple")
-    subject.should_not == "apple"
-  end
+  describe "should_not ==" do
+  
+    it "should delegate message to target" do
+      subject = "orange"
+      subject.expects(:==).with("apple").returns(false)
+      subject.should_not == "apple"
+    end
   
-end
+    it "should return true on success" do
+      subject = "apple"
+      (subject.should_not == "orange").should be_true
+    end
 
-describe "should ===" do
+    it "should fail when target.==(actual) returns false" do
+      subject = "apple"
+      Micronaut::Expectations.expects(:fail_with).with(%[expected not: == "apple",\n         got:    "apple"], "apple", "apple")
+      subject.should_not == "apple"
+    end
   
-  it "should delegate message to target" do
-    subject = "apple"
-    subject.expects(:===).with("apple").returns(true)
-    subject.should === "apple"
   end
+
+  describe "should ===" do
   
-  it "should fail when target.===(actual) returns false" do
-    subject = "apple"
-    subject.expects(:===).with("orange").returns(false)
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ===)], "orange", "apple")
-    subject.should === "orange"
-  end
+    it "should delegate message to target" do
+      subject = "apple"
+      subject.expects(:===).with("apple").returns(true)
+      subject.should === "apple"
+    end
   
-end
-
-describe "should_not ===" do
+    it "should fail when target.===(actual) returns false" do
+      subject = "apple"
+      subject.expects(:===).with("orange").returns(false)
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: "orange",\n     got: "apple" (using ===)], "orange", "apple")
+      subject.should === "orange"
+    end
   
-  it "should delegate message to target" do
-    subject = "orange"
-    subject.expects(:===).with("apple").returns(false)
-    subject.should_not === "apple"
   end
+
+  describe "should_not ===" do
   
-  it "should fail when target.===(actual) returns false" do
-    subject = "apple"
-    subject.expects(:===).with("apple").returns(true)
-    Micronaut::Expectations.expects(:fail_with).with(%[expected not: === "apple",\n         got:     "apple"], "apple", "apple")
-    subject.should_not === "apple"
-  end
+    it "should delegate message to target" do
+      subject = "orange"
+      subject.expects(:===).with("apple").returns(false)
+      subject.should_not === "apple"
+    end
+  
+    it "should fail when target.===(actual) returns false" do
+      subject = "apple"
+      subject.expects(:===).with("apple").returns(true)
+      Micronaut::Expectations.expects(:fail_with).with(%[expected not: === "apple",\n         got:     "apple"], "apple", "apple")
+      subject.should_not === "apple"
+    end
 
-end
+  end
 
-describe "should =~" do
+  describe "should =~" do
   
-  it "should delegate message to target" do
-    subject = "foo"
-    subject.expects(:=~).with(/oo/).returns(true)
-    subject.should =~ /oo/
-  end
+    it "should delegate message to target" do
+      subject = "foo"
+      subject.expects(:=~).with(/oo/).returns(true)
+      subject.should =~ /oo/
+    end
   
-  it "should fail when target.=~(actual) returns false" do
-    subject = "fu"
-    subject.expects(:=~).with(/oo/).returns(false)
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: /oo/,\n     got: "fu" (using =~)], /oo/, "fu")
-    subject.should =~ /oo/
-  end
+    it "should fail when target.=~(actual) returns false" do
+      subject = "fu"
+      subject.expects(:=~).with(/oo/).returns(false)
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: /oo/,\n     got: "fu" (using =~)], /oo/, "fu")
+      subject.should =~ /oo/
+    end
 
-end
+  end
 
-describe "should_not =~" do
+  describe "should_not =~" do
   
-  it "should delegate message to target" do
-    subject = "fu"
-    subject.expects(:=~).with(/oo/).returns(false)
-    subject.should_not =~ /oo/
-  end
+    it "should delegate message to target" do
+      subject = "fu"
+      subject.expects(:=~).with(/oo/).returns(false)
+      subject.should_not =~ /oo/
+    end
   
-  it "should fail when target.=~(actual) returns false" do
-    subject = "foo"
-    subject.expects(:=~).with(/oo/).returns(true)
-    Micronaut::Expectations.expects(:fail_with).with(%[expected not: =~ /oo/,\n         got:    "foo"], /oo/, "foo")
-    subject.should_not =~ /oo/
-  end
+    it "should fail when target.=~(actual) returns false" do
+      subject = "foo"
+      subject.expects(:=~).with(/oo/).returns(true)
+      Micronaut::Expectations.expects(:fail_with).with(%[expected not: =~ /oo/,\n         got:    "foo"], /oo/, "foo")
+      subject.should_not =~ /oo/
+    end
 
-end
+  end
 
-describe "should >" do
+  describe "should >" do
   
-  it "should pass if > passes" do
-    4.should > 3
-  end
+    it "should pass if > passes" do
+      4.should > 3
+    end
 
-  it "should fail if > fails" do
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: > 5,\n     got:   4], 5, 4)
-    4.should > 5
-  end
+    it "should fail if > fails" do
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: > 5,\n     got:   4], 5, 4)
+      4.should > 5
+    end
 
-end
+  end
 
-describe "should >=" do
+  describe "should >=" do
   
-  it "should pass if >= passes" do
-    4.should > 3
-    4.should >= 4
-  end
+    it "should pass if >= passes" do
+      4.should > 3
+      4.should >= 4
+    end
 
-  it "should fail if > fails" do
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: >= 5,\n     got:    4], 5, 4)
-    4.should >= 5
-  end
+    it "should fail if > fails" do
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: >= 5,\n     got:    4], 5, 4)
+      4.should >= 5
+    end
 
-end
+  end
 
-describe "should <" do
+  describe "should <" do
   
-  it "should pass if < passes" do
-    4.should < 5
-  end
+    it "should pass if < passes" do
+      4.should < 5
+    end
 
-  it "should fail if > fails" do
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: < 3,\n     got:   4], 3, 4)
-    4.should < 3
-  end
+    it "should fail if > fails" do
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: < 3,\n     got:   4], 3, 4)
+      4.should < 3
+    end
 
-end
+  end
 
-describe "should <=" do
+  describe "should <=" do
   
-  it "should pass if <= passes" do
-    4.should <= 5
-    4.should <= 4
-  end
+    it "should pass if <= passes" do
+      4.should <= 5
+      4.should <= 4
+    end
+
+    it "should fail if > fails" do
+      Micronaut::Expectations.expects(:fail_with).with(%[expected: <= 3,\n     got:    4], 3, 4)
+      4.should <= 3
+    end
 
-  it "should fail if > fails" do
-    Micronaut::Expectations.expects(:fail_with).with(%[expected: <= 3,\n     got:    4], 3, 4)
-    4.should <= 3
   end
 
-end
+  describe Micronaut::Matchers::PositiveOperatorMatcher do
 
-describe Micronaut::Matchers::PositiveOperatorMatcher do
+    it "should work when the target has implemented #send" do
+      o = Object.new
+      def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+      lambda {
+        o.should == o
+      }.should_not raise_error
+    end
 
-  it "should work when the target has implemented #send" do
-    o = Object.new
-    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-    lambda {
-      o.should == o
-    }.should_not raise_error
   end
 
-end
+  describe Micronaut::Matchers::NegativeOperatorMatcher do
 
-describe Micronaut::Matchers::NegativeOperatorMatcher do
+    it "should work when the target has implemented #send" do
+      o = Object.new
+      def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+      lambda {
+        o.should_not == :foo
+      }.should_not raise_error
+    end
 
-  it "should work when the target has implemented #send" do
-    o = Object.new
-    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-    lambda {
-      o.should_not == :foo
-    }.should_not raise_error
   end
 
-end
+end