rsanheim-micronaut 0.1.3.2 → 0.1.4.1

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 require 'rubygems/specification'
 
 GEM = "micronaut"
-GEM_VERSION = "0.1.3.2"
+GEM_VERSION = "0.1.4.1"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://spicycode.com"
@@ -79,5 +79,4 @@ namespace :micronaut do
 end
 
 task :default => 'micronaut:coverage'
-task :clobber_package => 'micronaut:clean_coverage'
-
+task :clobber_package => 'micronaut:clean_coverage'

data/examples/example_helper.rb

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

data/examples/lib/micronaut/behaviour_example.rb

@@ -171,18 +171,24 @@ describe Micronaut::Behaviour do
 
   end
 
-  before { @wee = 1 }
+  describe Foo, "describing nested behaviours" do 
 
-  describe "nested describes" do
-
-    before { @wee += 5 }
+    describe "nested describes" do
     
-    it "should set the described type to the parent described type (if it is not given)"
+      it "should set the described type to the parent described type if no described type is given" do
+        self.class.described_type.should == Foo
+      end
+      
+      it "should set the description to the first parameter if no described type is given" do
+        self.class.description.should == 'nested describes'
+      end
+
+      it "should have access to all of it's ancestors before blocks" 
+      
+      it "should have access to all of it's ancestors after blocks"
 
-    it "should have all of the parent before blocks" do
-      @wee.should == 6
     end
 
   end
 
-end
+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
     
     it "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)
+      Micronaut.configuration.extend(ThatThingISentYou)
+      group = Micronaut::Behaviour.describe(ThatThingISentYou, 'the focused support ') { }
+      group.should respond_to(:that_thing)
       remove_last_describe_from_world
     end
     

data/examples/lib/micronaut/example_example.rb

@@ -43,4 +43,10 @@ describe Micronaut::Example do
     
   end
   
+  describe "accessing metadata within a running example" do
+    
+    it "should be able to get the current example object"
+    
+  end
+  
 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
+  def stub_matcher
+    @_stub_matcher ||= simple_matcher do
     end
+  end
 
-    it "should return true if there is no error" do
-      wrap_expectation stub_matcher do
-      end.should be_true
+  def failing_matcher
+    @_failing_matcher ||= simple_matcher do
+      1.should == 2
     end
+  end
 
-    it "should return false if there is an error" do
-      wrap_expectation failing_matcher do
-        raise "error"
-      end.should be_false
-    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

@@ -59,15 +59,11 @@ describe Micronaut::Formatters::ProgressFormatter do
     backtrace = ["/tmp/x.rb:1", "/tmp/x.rb:2", "/tmp/x.rb:3"]
     @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip)
 /tmp/x.rb:1
-/tmp/x.rb:2
-/tmp/x.rb:3
 EOE
 
     backtrace = ["/tmp/x.rb:1: message", "/tmp/x.rb:2", "/tmp/x.rb:3"]
     @formatter.format_backtrace(backtrace).should eql(<<-EOE.rstrip)
 /tmp/x.rb:1: message
-/tmp/x.rb:2
-/tmp/x.rb:3
 EOE
   end
   

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