spicycode-micronaut 0.0.7 → 0.0.9

data/Rakefile

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

data/examples/lib/micronaut/{behaviour_group_example.rb → behaviour_example.rb}

@@ -1,33 +1,34 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
 
-describe Micronaut::BehaviourGroup do
+describe Micronaut::Behaviour do
 
   class Foo
 
   end  
 
   def empty_behaviour_group
-    Micronaut::BehaviourGroup.describe(Foo, 'Empty Behaviour Group') { }
+    group = Micronaut::Behaviour.describe(Foo, 'Empty Behaviour Group') { }
+    remove_last_describe_from_world
   end
 
   describe "describing behaviour with #describe" do
 
     it "should raise an ArgumentError if no name is given" do
-      lambda { Micronaut::BehaviourGroup.describe() {} }.should raise_error(ArgumentError)
+      lambda { Micronaut::Behaviour.describe() {} }.should raise_error(ArgumentError)
     end
 
     it "should raise an ArgumentError if no block is given" do
-      lambda { Micronaut::BehaviourGroup.describe('foo') }.should raise_error(ArgumentError)
+      lambda { Micronaut::Behaviour.describe('foo') }.should raise_error(ArgumentError)
     end
 
     describe '#name' do
 
       it "should expose the first parameter as name" do
-        Micronaut::BehaviourGroup.describe("my favorite pony") { }.name.should == 'my favorite pony'
+        Micronaut::Behaviour.describe("my favorite pony") { }.name.should == 'my favorite pony'
       end
 
       it "should call to_s on the first parameter in case it is a constant" do
-        Micronaut::BehaviourGroup.describe(Foo) { }.name.should == 'Foo'
+        Micronaut::Behaviour.describe(Foo) { }.name.should == 'Foo'
       end
 
     end
@@ -35,11 +36,11 @@ describe Micronaut::BehaviourGroup do
     describe '#described_type' do
 
       it "should be the first parameter when it is a constant" do
-        Micronaut::BehaviourGroup.describe(Foo) { }.described_type.should == Foo
+        Micronaut::Behaviour.describe(Foo) { }.described_type.should == Foo
       end
 
       it "should be nil when the first parameter is a string" do
-        Micronaut::BehaviourGroup.describe("i'm a computer") { }.described_type.should be_nil
+        Micronaut::Behaviour.describe("i'm a computer") { }.described_type.should be_nil
       end
 
     end
@@ -47,11 +48,11 @@ describe Micronaut::BehaviourGroup do
     describe '#description' do
 
       it "should expose the second parameter as description" do
-        Micronaut::BehaviourGroup.describe(Foo, "my desc") { }.description.should == 'my desc'
+        Micronaut::Behaviour.describe(Foo, "my desc") { }.description.should == 'my desc'
       end
 
       it "should allow the second parameter to be nil" do
-        Micronaut::BehaviourGroup.describe(Foo, nil) { }.description.size.should == 0
+        Micronaut::Behaviour.describe(Foo, nil) { }.description.size.should == 0
       end
 
     end
@@ -59,11 +60,11 @@ describe Micronaut::BehaviourGroup do
     describe '#options' do
 
       it "should expose the third parameter as options" do
-        Micronaut::BehaviourGroup.describe(Foo, nil, 'foo' => 'bar') { }.options.should == { "foo" => 'bar' }
+        Micronaut::Behaviour.describe(Foo, nil, 'foo' => 'bar') { }.options.should == { "foo" => 'bar' }
       end
 
       it "should be an empty hash if no options are supplied" do
-        Micronaut::BehaviourGroup.describe(Foo, nil) { }.options.should == {}
+        Micronaut::Behaviour.describe(Foo, nil) { }.options.should == {}
       end
 
     end
@@ -175,7 +176,8 @@ describe Micronaut::BehaviourGroup do
   describe "nested describes" do
 
     before { @wee += 5 }
-    # 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 it is not given)"
 
     it "should have all of the parent before blocks" do
       @wee.should == 6

data/examples/lib/micronaut/configuration_example.rb

@@ -5,12 +5,12 @@ describe Micronaut::Configuration do
   describe "#mock_with" do
     
     it "should include the mocha adapter when called with :mocha" do
-      Micronaut::BehaviourGroup.expects(:send).with(:include, Micronaut::Mocking::WithMocha)
+      Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithMocha)
       Micronaut::Configuration.new.mock_with :mocha
     end
   
     it "should include the do absolutely nothing mocking adapter for all other cases" do
-      Micronaut::BehaviourGroup.expects(:send).with(:include, Micronaut::Mocking::WithAbsolutelyNothing)
+      Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithAbsolutelyNothing)
       Micronaut::Configuration.new.mock_with
     end
     
@@ -26,7 +26,7 @@ describe Micronaut::Configuration do
     
     it "should include the given module into each behaviour group" do
       Micronaut.configuration.include(InstanceLevelMethods)
-      group = Micronaut::BehaviourGroup.describe(Object, 'does like, stuff and junk') { }
+      group = Micronaut::Behaviour.describe(Object, 'does like, stuff and junk') { }
       group.should_not respond_to(:you_call_this_a_blt?)
       remove_last_describe_from_world
 
@@ -47,7 +47,7 @@ describe Micronaut::Configuration do
     
     it "should extend the given module into each behaviour group" do
       Micronaut.configuration.extend(FocusedSupport)
-      group = Micronaut::BehaviourGroup.describe(FocusedSupport, 'the focused support ') { }
+      group = Micronaut::Behaviour.describe(FocusedSupport, 'the focused support ') { }
       group.should respond_to(:fit)
       remove_last_describe_from_world
     end

data/examples/lib/micronaut/example_example.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::Example do
+
+  before do
+    behaviour = stub('behaviour', :name => 'behaviour_name')
+    @example = Micronaut::Example.new(behaviour, 'description', {}, (lambda {}))
+  end
+  
+  describe "attr readers" do
+  
+    it "should have one for the parent behaviour" do
+      @example.should respond_to(:behaviour)
+    end
+  
+    it "should have one for it's description" do
+      @example.should respond_to(:description)
+    end
+  
+    it "should have one for it's options" do
+      @example.should respond_to(:options)
+    end
+  
+    it "should have one for it's block" do
+      @example.should respond_to(:example_block)
+    end
+
+  end
+  
+  describe '#inspect' do
+    
+    it "should return 'behaviour_name - description'" do
+      @example.inspect.should == 'behaviour_name - description'
+    end
+    
+  end
+  
+  describe '#to_s' do
+    
+    it "should return #inspect" do
+      @example.to_s.should == @example.inspect
+    end
+    
+  end
+  
+end

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

@@ -1,85 +1,72 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../../example_helper")
 
-describe Object, "#should" do
-  
-  before do
-    @target = "target"
-    @matcher = mock("matcher")
-    @matcher.stubs(:matches?).returns(true)
-    @matcher.stubs(:failure_message)
-  end
-  
-  it "should accept and interact with a matcher" do
-    @matcher.expects(:matches?).with(@target).returns(true)    
-    @target.should @matcher
-  end
-  
-  it "should ask for a failure_message when matches? returns false" do
-    @matcher.expects(:matches?).with(@target).returns(false)
-    @matcher.expects(:failure_message).returns("the failure message")
-    lambda {
+describe Object do
+
+  describe "#should" do
+
+    before do
+      @target = "target"
+      @matcher = mock("matcher")
+      @matcher.stubs(:matches?).returns(true)
+      @matcher.stubs(:failure_message)
+    end
+
+    it "should accept and interact with a matcher" do
+      @matcher.expects(:matches?).with(@target).returns(true)    
       @target.should @matcher
-    }.should fail_with("the failure message")
-  end
-  
-  it "should raise error if it receives false directly" do
-    lambda {
-      @target.should false
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
-  end
-  
-  it "should raise error if it receives false (evaluated)" do
-    lambda {
-      @target.should eql?("foo")
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
-  end
-  
-  it "should raise error if it receives true" do
-    lambda {
-      @target.should true
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
-  end
-  
-end
-
-describe Object, "#should_not" do
-  
-  before do
-    @target = "target"
-    @matcher = mock("matcher")
-  end
-  
-  it "should accept and interact with a matcher" do
-    @matcher.expects(:matches?).with(@target).returns(false)
-    @matcher.stubs(:negative_failure_message)
-    
-    @target.should_not @matcher
+    end
+
+    it "should ask for a failure_message when matches? returns false" do
+      @matcher.expects(:matches?).with(@target).returns(false)
+      @matcher.expects(:failure_message).returns("the failure message")
+      lambda { @target.should @matcher }.should fail_with("the failure message")
+    end
+
+    it "should raise error if it receives false directly" do
+      lambda { @target.should false }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
+
+    it "should raise error if it receives false (evaluated)" do
+      lambda { @target.should eql?("foo") }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
+
+    it "should raise error if it receives true" do
+      lambda { @target.should true }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
+
   end
-  
-  it "should ask for a negative_failure_message when matches? returns true" do
-    @matcher.expects(:matches?).with(@target).returns(true)
-    @matcher.expects(:negative_failure_message).returns("the negative failure message")
-    lambda {
+
+  describe "#should_not" do
+
+    before do
+      @target = "target"
+      @matcher = mock("matcher")
+    end
+
+    it "should accept and interact with a matcher" do
+      @matcher.expects(:matches?).with(@target).returns(false)
+      @matcher.stubs(:negative_failure_message)
       @target.should_not @matcher
-    }.should fail_with("the negative failure message")
-  end
+    end
+
+    it "should ask for a negative_failure_message when matches? returns true" do
+      @matcher.expects(:matches?).with(@target).returns(true)
+      @matcher.expects(:negative_failure_message).returns("the negative failure message")
+      lambda { @target.should_not @matcher }.should fail_with("the negative failure message")
+    end
+
+    it "should raise error if it receives false directly" do
+      lambda { @target.should_not false }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
+
+    it "should raise error if it receives false (evaluated)" do
+      lambda { @target.should_not eql?("foo") }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
+
+    it "should raise error if it receives true" do
+      lambda { @target.should_not true }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+    end
 
-  it "should raise error if it receives false directly" do
-    lambda {
-      @target.should_not false
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
-  end
-  
-  it "should raise error if it receives false (evaluated)" do
-    lambda {
-      @target.should_not eql?("foo")
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
-  end
-  
-  it "should raise error if it receives true" do
-    lambda {
-      @target.should_not true
-    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
   end
 
 end

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

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-module Micronaut
-  module Matchers
+describe Micronaut::Matchers do
+
     describe "wrap_expectation" do
       
       def stub_matcher
@@ -25,6 +25,7 @@ module Micronaut
           raise "error"
         end.should be_false
       end
+
     end
-  end
+    
 end

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

@@ -68,8 +68,8 @@ describe Micronaut::Formatters::BaseFormatter do
     @formatter.should have_interface_for(:start).with(1).argument
   end
 
-  it "should have add_example_group as an interface with one argument" do
-    @formatter.should have_interface_for(:add_example_group).with(1).argument
+  it "should have add_behaviour as an interface with one argument" do
+    @formatter.should have_interface_for(:add_behaviour).with(1).argument
   end
 
   it "should have example_started as an interface with one argument" do

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

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Formatters::DocumentationFormatter do
+  
+end

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

@@ -20,10 +20,11 @@ describe Micronaut::Formatters::ProgressFormatter do
   end
   
   it "should produce standard summary" do
-    example_group = Micronaut::BehaviourGroup.describe("example_group") do
+    behaviour = Micronaut::Behaviour.describe("behaviour") do
       it('example') {}
     end
-    example = example_group.examples.first
+    remove_last_describe_from_world
+    example = behaviour.examples.first
     @formatter.example_pending(example, "message")
     @io.rewind
     @formatter.dump_summary(3, 2, 1, 1)
@@ -31,21 +32,18 @@ describe Micronaut::Formatters::ProgressFormatter do
   end
 
   it "should push green dot for passing spec" do
-    @io.expects(:tty?).returns(true)
     @options.expects(:enable_color_in_output?).returns(true)
     @formatter.example_passed("spec")
     @io.string.should == "\e[32m.\e[0m"
   end
 
   it "should push red F for failure spec" do
-    @io.expects(:tty?).returns(true)
     @options.expects(:enable_color_in_output?).returns(true)
     @formatter.example_failed("spec", Micronaut::Expectations::ExpectationNotMetError.new)
     @io.string.should eql("\e[31mF\e[0m")
   end
 
   it "should push magenta F for error spec" do
-    @io.expects(:tty?).returns(true)
     @options.expects(:enable_color_in_output?).returns(true)
     @formatter.example_failed("spec", RuntimeError.new)
     @io.string.should eql("\e[35mF\e[0m")
@@ -59,36 +57,17 @@ describe Micronaut::Formatters::ProgressFormatter do
   it "should ensure two ':' in the first backtrace" 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:
+/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:
+/tmp/x.rb:2
+/tmp/x.rb:3
 EOE
   end
   
-  describe "outputting to custom out" do
-    before do
-      @out = mock("out")
-      @options = mock('options')
-      @out.stubs(:puts)
-      @formatter = Micronaut::Formatters::ProgressFormatter.new(@options, @out)
-      @formatter.class.__send__ :public, :output_to_tty?
-    end
-
-    after do
-      @formatter.class.__send__ :protected, :output_to_tty?
-    end
-
-    it "should not throw NoMethodError on output_to_tty?" do
-      @out.expects(:tty?).raises(NoMethodError)
-      @formatter.output_to_tty?.should be_false
-    end
-  end
-  
 end

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

@@ -1,42 +1,52 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-module Micronaut
-  module Matchers
-    describe "be_close" do
-      it "should match when value == target" do
-        be_close(5.0, 0.5).matches?(5.0).should be_true
-      end
-      it "should match when value < (target + delta)" do
-        be_close(5.0, 0.5).matches?(5.49).should be_true
-      end
-      it "should match when value > (target - delta)" do
-        be_close(5.0, 0.5).matches?(4.51).should be_true
-      end
-      it "should not match when value == (target - delta)" do
-        be_close(5.0, 0.5).matches?(4.5).should be_false
-      end
-      it "should not match when value < (target - delta)" do
-        be_close(5.0, 0.5).matches?(4.49).should be_false
-      end
-      it "should not match when value == (target + delta)" do
-        be_close(5.0, 0.5).matches?(5.5).should be_false
-      end
-      it "should not match when value > (target + delta)" do
-        be_close(5.0, 0.5).matches?(5.51).should be_false
-      end
-      it "should provide a useful failure message" do
-        #given
-          matcher = be_close(5.0, 0.5)
-        #when
-          matcher.matches?(5.51)
-        #then
-          matcher.failure_message.should == "expected 5.0 +/- (< 0.5), got 5.51"
-      end
-      it "should describe itself" do
-        matcher = be_close(5.0, 0.5)
-        matcher.matches?(5.1)
-        matcher.description.should == "be close to 5.0 (within +- 0.5)"
-      end
+describe Micronaut::Matchers do
+
+  describe "be_close" do
+
+    it "should match when value == target" do
+      be_close(5.0, 0.5).matches?(5.0).should be_true
+    end
+
+    it "should match when value < (target + delta)" do
+      be_close(5.0, 0.5).matches?(5.49).should be_true
+    end
+
+    it "should match when value > (target - delta)" do
+      be_close(5.0, 0.5).matches?(4.51).should be_true
+    end
+
+    it "should not match when value == (target - delta)" do
+      be_close(5.0, 0.5).matches?(4.5).should be_false
+    end
+
+    it "should not match when value < (target - delta)" do
+      be_close(5.0, 0.5).matches?(4.49).should be_false
     end
+
+    it "should not match when value == (target + delta)" do
+      be_close(5.0, 0.5).matches?(5.5).should be_false
+    end
+
+    it "should not match when value > (target + delta)" do
+      be_close(5.0, 0.5).matches?(5.51).should be_false
+    end
+
+    it "should provide a useful failure message" do
+      #given
+      matcher = be_close(5.0, 0.5)
+      #when
+      matcher.matches?(5.51)
+      #then
+      matcher.failure_message.should == "expected 5.0 +/- (< 0.5), got 5.51"
+    end
+
+    it "should describe itself" do
+      matcher = be_close(5.0, 0.5)
+      matcher.matches?(5.1)
+      matcher.description.should == "be close to 5.0 (within +- 0.5)"
+    end
+
   end
-end
+
+end