spicycode-micronaut 0.0.5 → 0.0.6

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems/specification'
 require 'date'
 
 GEM = "micronaut"
-GEM_VERSION = "0.0.5"
+GEM_VERSION = "0.0.6"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://spicycode.com"
@@ -15,7 +15,7 @@ spec = Gem::Specification.new do |s|
   s.version = GEM_VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.extra_rdoc_files = ["README", "LICENSE", "RSPEC-LICENSE"]
   s.summary = SUMMARY
   s.description = s.summary
   s.author = AUTHOR
@@ -56,6 +56,19 @@ namespace :micronaut do
     ruby command
   end
   
+  desc "List files that don't have examples"
+  task :untested do
+    code = Dir["lib/**/*.rb"].map { |g| Dir.glob(g) }.flatten
+    examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
+    examples.map! { |f| f =~ /examples\/(.*)_example/; "#{$1}.rb" }
+    missing_examples = (code - examples)
+    puts
+    puts "The following files seem to be missing their examples:"
+    missing_examples.each do |missing|
+      puts "  #{missing}"
+    end
+  end
+  
   desc "Run all examples using rcov"
   task :coverage do
     examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten

data/examples/example_helper.rb

@@ -26,4 +26,18 @@ def dummy_reporter
   DummyFormatter.new({}, StringIO.new)
 end
 
-Micronaut::Runner.autorun
+Micronaut.configure do |config|
+  
+  config.mock_with :mocha
+  
+  config.before(:each, :pending => true) do 
+    raise "the roof"
+  end
+  
+  config.after(:each, :focused => true) do
+    puts 'was the focus worth it?'
+  end
+  
+end
+
+Micronaut::Runner.autorun

data/examples/lib/micronaut/behaviour_group_example.rb

@@ -11,176 +11,176 @@ describe Micronaut::BehaviourGroup do
   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)
-     end
-     
-     it "should raise an ArgumentError if no block is given" do
-       lambda { Micronaut::BehaviourGroup.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'
-       end
-  
-       it "should call to_s on the first parameter in case it is a constant" do
-         Micronaut::BehaviourGroup.describe(Foo) { }.name.should == 'Foo'
-       end
-     
-     end
-  
-     describe '#described_type' do
-       
-       it "should be the first parameter when it is a constant" do
-         Micronaut::BehaviourGroup.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
-       end
-       
-     end
-     
-     describe '#description' do
-       
-       it "should expose the second parameter as description" do
-         Micronaut::BehaviourGroup.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
-       end
-       
-     end
-  
-     describe '#options' do
-     
-       it "should expose the third parameter as options" do
-         Micronaut::BehaviourGroup.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 == {}
-       end
-     
-     end
-     
-     describe "adding before and after hooks" do
-       
-       it "should expose the before each blocks at before_eachs" do
-         group = empty_behaviour_group
-         group.before(:each) { 'foo' }
-         group.should have(1).before_eachs
-       end
-  
-       it "should maintain the before each block order" do
-         group = empty_behaviour_group 
-         group.before(:each) { 15 }
-         group.before(:each) { 'A' }
-         group.before(:each) { 33.5 }
-  
-         group.before_eachs[0].call.should == 15
-         group.before_eachs[1].call.should == 'A'
-         group.before_eachs[2].call.should == 33.5
-       end
-  
-       it "should expose the before all blocks at before_alls" do
-         group = empty_behaviour_group
-         group.before(:all) { 'foo' }
-         group.should have(1).before_alls
-       end
-  
-       it "should maintain the before all block order" do
-         group = empty_behaviour_group 
-         group.before(:all) { 15 }
-         group.before(:all) { 'A' }
-         group.before(:all) { 33.5 }
-  
-         group.before_alls[0].call.should == 15
-         group.before_alls[1].call.should == 'A'
-         group.before_alls[2].call.should == 33.5
-       end
-  
-       it "should expose the after each blocks at after_eachs" do
-         group = empty_behaviour_group
-         group.after(:each) { 'foo' }
-         group.should have(1).after_eachs
-       end
-  
-       it "should maintain the after each block order" do
-         group = empty_behaviour_group 
-         group.after(:each) { 15 }
-         group.after(:each) { 'A' }
-         group.after(:each) { 33.5 }
-  
-         group.after_eachs[0].call.should == 15
-         group.after_eachs[1].call.should == 'A'
-         group.after_eachs[2].call.should == 33.5
-       end
-  
-       it "should expose the after all blocks at after_alls" do
-         group = empty_behaviour_group
-         group.after(:all) { 'foo' }
-         group.should have(1).after_alls
-       end
-  
-       it "should maintain the after each block order" do
-         group = empty_behaviour_group 
-         group.after(:all) { 15 }
-         group.after(:all) { 'A' }
-         group.after(:all) { 33.5 }
-  
-         group.after_alls[0].call.should == 15
-         group.after_alls[1].call.should == 'A'
-         group.after_alls[2].call.should == 33.5
-       end
-  
-     end
-  
-     describe "adding examples" do
-  
-       it "should allow adding an example using 'it'" do
-         group = empty_behaviour_group
-         group.it("should do something") { }
-         group.examples.size.should == 1
-       end
-  
-       it "should expose all examples at examples" do
-         group = empty_behaviour_group
-         group.it("should do something 1") { }
-         group.it("should do something 2") { }
-         group.it("should do something 3") { }
-         group.examples.size.should == 3
-       end
-  
-       it "should maintain the example order" do
-         group = empty_behaviour_group
-         group.it("should 1") { }
-         group.it("should 2") { }
-         group.it("should 3") { }
-         group.examples[0].first.should == 'should 1'
-         group.examples[1].first.should == 'should 2'
-         group.examples[2].first.should == 'should 3'
-       end
-  
-     end
-     
-   end
-  
+
+    it "should raise an ArgumentError if no name is given" do
+      lambda { Micronaut::BehaviourGroup.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)
+    end
+
+    describe '#name' do
+
+      it "should expose the first parameter as name" do
+        Micronaut::BehaviourGroup.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'
+      end
+
+    end
+
+    describe '#described_type' do
+
+      it "should be the first parameter when it is a constant" do
+        Micronaut::BehaviourGroup.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
+      end
+
+    end
+
+    describe '#description' do
+
+      it "should expose the second parameter as description" do
+        Micronaut::BehaviourGroup.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
+      end
+
+    end
+
+    describe '#options' do
+
+      it "should expose the third parameter as options" do
+        Micronaut::BehaviourGroup.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 == {}
+      end
+
+    end
+
+    describe "adding before and after hooks" do
+
+      it "should expose the before each blocks at before_eachs" do
+        group = empty_behaviour_group
+        group.before(:each) { 'foo' }
+        group.should have(1).before_eachs
+      end
+
+      it "should maintain the before each block order" do
+        group = empty_behaviour_group 
+        group.before(:each) { 15 }
+        group.before(:each) { 'A' }
+        group.before(:each) { 33.5 }
+
+        group.before_eachs[0].last.call.should == 15
+        group.before_eachs[1].last.call.should == 'A'
+        group.before_eachs[2].last.call.should == 33.5
+      end
+
+      it "should expose the before all blocks at before_alls" do
+        group = empty_behaviour_group
+        group.before(:all) { 'foo' }
+        group.should have(1).before_alls
+      end
+
+      it "should maintain the before all block order" do
+        group = empty_behaviour_group 
+        group.before(:all) { 15 }
+        group.before(:all) { 'A' }
+        group.before(:all) { 33.5 }
+
+        group.before_alls[0].last.call.should == 15
+        group.before_alls[1].last.call.should == 'A'
+        group.before_alls[2].last.call.should == 33.5
+      end
+
+      it "should expose the after each blocks at after_eachs" do
+        group = empty_behaviour_group
+        group.after(:each) { 'foo' }
+        group.should have(1).after_eachs
+      end
+
+      it "should maintain the after each block order" do
+        group = empty_behaviour_group 
+        group.after(:each) { 15 }
+        group.after(:each) { 'A' }
+        group.after(:each) { 33.5 }
+
+        group.after_eachs[0].last.call.should == 15
+        group.after_eachs[1].last.call.should == 'A'
+        group.after_eachs[2].last.call.should == 33.5
+      end
+
+      it "should expose the after all blocks at after_alls" do
+        group = empty_behaviour_group
+        group.after(:all) { 'foo' }
+        group.should have(1).after_alls
+      end
+
+      it "should maintain the after each block order" do
+        group = empty_behaviour_group 
+        group.after(:all) { 15 }
+        group.after(:all) { 'A' }
+        group.after(:all) { 33.5 }
+
+        group.after_alls[0].last.call.should == 15
+        group.after_alls[1].last.call.should == 'A'
+        group.after_alls[2].last.call.should == 33.5
+      end
+
+    end
+
+    describe "adding examples" do
+
+      it "should allow adding an example using 'it'" do
+        group = empty_behaviour_group
+        group.it("should do something") { }
+        group.examples.size.should == 1
+      end
+
+      it "should expose all examples at examples" do
+        group = empty_behaviour_group
+        group.it("should do something 1") { }
+        group.it("should do something 2") { }
+        group.it("should do something 3") { }
+        group.examples.size.should == 3
+      end
+
+      it "should maintain the example order" do
+        group = empty_behaviour_group
+        group.it("should 1") { }
+        group.it("should 2") { }
+        group.it("should 3") { }
+        group.examples[0].description.should == 'should 1'
+        group.examples[1].description.should == 'should 2'
+        group.examples[2].description.should == 'should 3'
+      end
+
+    end
+
+  end
+
   before { @wee = 1 }
-  
-   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 have all of the parent before blocks" do
-       @wee.should == 6
-     end
-     
-   end
-  
+
+  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 have all of the parent before blocks" do
+      @wee.should == 6
+    end
+
+  end
+
 end

data/examples/lib/micronaut/configuration_example.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+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::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::Configuration.new.mock_with
+    end
+    
+  end
+  
+  describe "#include" do
+    
+    module InstanceLevelMethods
+      def you_call_this_a_blt?
+        "egad man, where's the mayo?!?!?"
+      end
+    end
+    
+    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.should_not respond_to(:you_call_this_a_blt?)
+      remove_last_describe_from_world
+
+      group.new.you_call_this_a_blt?.should == "egad man, where's the mayo?!?!?"
+    end
+    
+  end
+
+  describe "#extend" do
+    
+    module FocusedSupport
+      
+      def fit(desc, options={}, &block)
+        it(desc, options.merge(:focused => true), &block)
+      end
+      
+    end
+    
+    it "should extend the given module into each behaviour group" do
+      Micronaut.configuration.extend(FocusedSupport)
+      group = Micronaut::BehaviourGroup.describe(FocusedSupport, 'the focused support ') { }
+      group.should respond_to(:fit)
+      remove_last_describe_from_world
+    end
+    
+  end
+  
+end

data/examples/lib/micronaut/kernel_extensions_example.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::KernelExtensions do
+  
+  it "should be included in Object" do
+    Object.included_modules.should include(Micronaut::KernelExtensions)
+  end
+  
+  it "should add a describe method to Object" do
+    Object.methods.should include("describe")
+  end
+
+end

data/examples/lib/micronaut_example.rb

@@ -1,6 +1,23 @@
 require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
 
 describe Micronaut do
+
+  describe "configuration" do
+    
+    it "should return an instance of Micronaut::Configuration" do
+      Micronaut.configuration.should be_an_instance_of(Micronaut::Configuration)
+    end
+    
+  end
   
+  describe "configure" do
+    
+    it "should yield the current configuration" do
+      Micronaut.configure do |config|
+        config.should == Micronaut.configuration
+      end
+    end
+    
+  end
   
 end

data/lib/micronaut.rb

@@ -1,12 +1,13 @@
-require 'micronaut/mocking/with_mocha'
+require 'micronaut/mocking'
 require 'micronaut/matchers'
 require 'micronaut/expectations'
 require 'micronaut/world'
+require 'micronaut/configuration'
 require 'micronaut/runner'
 require 'micronaut/runner_options'
-require 'micronaut/behaviour_group_class_methods'
+require 'micronaut/example'
 require 'micronaut/behaviour_group'
-require 'micronaut/extensions/kernel'
+require 'micronaut/kernel_extensions'
 require 'micronaut/formatters'
 
 module Micronaut
@@ -25,4 +26,12 @@ module Micronaut
   # './lib' in project dir, or '/usr/local/blahblah' if installed
   MICRONAUT_DIR = File.expand_path(File.dirname(File.dirname(file)))
   
+  def self.configuration
+    @configuration ||= Micronaut::Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+  
 end

data/lib/micronaut/behaviour_group.rb

@@ -1,65 +1,190 @@
 module Micronaut
+  
   class BehaviourGroup
-    extend Micronaut::BehaviourGroupClassMethods
-    include Micronaut::Matchers
-    include Micronaut::Mocking::WithMocha
+    include Micronaut::Matchers 
 
-    def eval_before_alls
-      self.class.each_ancestor do |ancestor| 
-        ancestor.before_alls.each { |blk| instance_eval(&blk) }
+    def self.inherited(klass)
+      super
+      Micronaut::World.behaviour_groups << klass
+    end
+
+    def self.befores
+      @_befores ||= { :all => [], :each => [] }
+    end
+
+    def self.before_eachs
+      befores[:each]
+    end
+
+    def self.before_alls
+      befores[:all]
+    end
+
+    def self.before(type=:each, options={}, &block)
+      befores[type] << [options, block]
+    end
+
+    def self.afters
+      @_afters ||= { :all => [], :each => [] }
+    end
+
+    def self.after_eachs
+      afters[:each]
+    end
+
+    def self.after_alls
+      afters[:all]
+    end
+
+    def self.after(type=:each, options={}, &block)
+      afters[type] << [options, block]
+    end
+
+    def self.it(desc=nil, options={}, &block)
+      examples << Micronaut::Example.new(self, desc, options, block)
+    end
+
+    def self.examples
+      @_examples ||= []
+    end
+
+    def self.set_it_up(*args)
+      metadata[:options] = args.last.is_a?(Hash) ? args.pop : {}
+      metadata[:described_type] = args.first.is_a?(String) ? self.superclass.described_type : args.shift
+      metadata[:description] = args.shift || ''
+      metadata[:name] = "#{metadata[:described_type]} #{metadata[:description]}".strip
+      
+      Micronaut.configuration.extra_modules[:extend].each do |mod, options|
+        send(:extend, mod) if options.empty?
+      end
+      
+      Micronaut.configuration.extra_modules[:include].each do |mod, options|
+        send(:include, mod) if options.empty?
+      end
+    end
+
+    def self.metadata
+      @_metadata ||= {}
+    end
+
+    def self.name
+      metadata[:name]
+    end
+
+    def self.described_type
+      metadata[:described_type]
+    end
+
+    def self.description
+      metadata[:description]
+    end
+
+    def self.options
+      metadata[:options]
+    end
+
+    def self.describe(*args, &describe_block)
+      raise ArgumentError if args.empty? || describe_block.nil?
+      subclass('NestedLevel') do
+        set_it_up(*args)
+        module_eval(&describe_block)
       end
     end
 
-    def eval_after_alls
-      self.class.each_ancestor(:superclass_first) do |ancestor| 
-        ancestor.after_alls.each { |blk| instance_eval(&blk) }
+    def self.ancestors(superclass_last=false)
+      classes = []
+      current_class = self
+
+      while current_class < Micronaut::BehaviourGroup
+        superclass_last ? classes << current_class : classes.unshift(current_class)
+        current_class = current_class.superclass
+      end
+      
+      classes
+    end
+    
+    def self.before_ancestors
+      @_before_ancestors ||= ancestors 
+    end
+    
+    def self.after_ancestors
+      @_after_ancestors ||= ancestors(true)
+    end
+
+    def self.eval_before_alls(example)
+      before_ancestors.each do |ancestor| 
+        ancestor.before_alls.each { |opts, blk| example.instance_eval(&blk) }
+      end
+    end
+        
+    def self.eval_before_eachs(example)
+      before_ancestors.each do |ancestor| 
+        ancestor.before_eachs.each { |opts, blk| example.instance_eval(&blk) }
       end
     end
 
-    def eval_before_eachs
-      self.class.each_ancestor do |ancestor| 
-        ancestor.before_eachs.each { |blk| instance_eval(&blk) }
+    def self.eval_after_alls(example)
+      after_ancestors.each do |ancestor| 
+        ancestor.after_alls.each { |opts, blk| example.instance_eval(&blk) }
       end
     end
 
-    def eval_after_eachs
-      self.class.each_ancestor(:superclass_first) do |ancestor|
-        ancestor.after_eachs.each { |blk| instance_eval(&blk) }
+    def self.eval_after_eachs(example)
+      after_ancestors.each do |ancestor|
+        ancestor.after_eachs.each { |opts, blk| example.instance_eval(&blk) }
       end
     end
 
-    def execute(reporter)
-      return true if self.class.examples.empty?
-      eval_before_alls
+    def self.run(reporter)
+      return true if examples.empty?
+      
+      group = new
+      
+      eval_before_alls(group)
       success = true
 
-      self.class.examples.each do |desc, opts, block|
-        reporter.example_started(self)
+      examples.each do |ex|
+        reporter.example_started(ex)
 
         execution_error = nil
         begin
-          setup_mocks
-          eval_before_eachs
-          if block
-            instance_eval(&block)
-            verify_mocks
-            reporter.example_passed(self)
+          group._setup_mocks
+          eval_before_eachs(group)
+
+          if ex.example_block
+            group.instance_eval(&ex.example_block)
+            group._verify_mocks
+            reporter.example_passed(ex)
           else
-            reporter.example_pending([desc, self], 'Not yet implemented')
+            reporter.example_pending(ex, 'Not yet implemented')
           end
-          eval_after_eachs
+          eval_after_eachs(group)
         rescue Exception => e
-          reporter.example_failed(self, e)
+          reporter.example_failed(ex, e)
           execution_error ||= e
         ensure
-          teardown_mocks
+          group._teardown_mocks
         end
 
         success &= execution_error.nil?
       end
-      eval_after_alls
+      eval_after_alls(group)
       success
     end
 
+    def self.subclass(base_name, &body) # :nodoc:
+      @_sub_class_count ||= 0
+      @_sub_class_count += 1
+      klass = Class.new(self)
+      class_name = "#{base_name}_#{@_sub_class_count}"
+      const_set(class_name, klass)
+      klass.instance_eval(&body)
+      klass
+    end
+
+    def self.to_s
+      self == Micronaut::BehaviourGroup ? 'Micronaut::BehaviourGroup' : name
+    end
+    
   end
-end
+end

data/lib/micronaut/configuration.rb

@@ -0,0 +1,47 @@
+module Micronaut
+
+  class Configuration
+    attr_reader :mock_framework
+    
+    def mock_with(make_a_mockery_with=nil)
+      @mock_framework = case make_a_mockery_with
+                        when :mocha
+                          Micronaut::Mocking::WithMocha
+                        else
+                          Micronaut::Mocking::WithAbsolutelyNothing
+                        end 
+
+      Micronaut::BehaviourGroup.send(:include, @mock_framework)
+    end
+    
+    def befores
+      @befores ||= { :each => [], :all => {} }
+    end
+    
+    def afters
+      @afters ||= { :each => [], :all => {} }
+    end
+    
+    def extra_modules
+      @extra_modules ||= { :include => [], :extend => [] }
+    end
+    
+    def include(module_to_include, options={})
+      extra_modules[:include] << [module_to_include, options]
+    end
+    
+    def extend(module_to_extend, options={})
+      extra_modules[:extend] << [module_to_extend, options]
+    end
+    
+    def before(type=:each, options={}, &block)
+      befores[type] << [options, block]
+    end
+    
+    def after(type=:each, options={}, &block)
+      afters[type] << [options, block]
+    end
+    
+  end
+  
+end

data/lib/micronaut/example.rb

@@ -0,0 +1,17 @@
+module Micronaut
+
+  class Example
+  
+    attr_reader :behaviour, :description, :options, :example_block
+  
+    def initialize(behaviour, desc, options, example_block=nil)
+      @behaviour, @description, @options, @example_block = behaviour, desc, options, example_block
+    end
+    
+    def inspect
+      "#{behaviour.name} - #{desc}"
+    end
+  
+  end
+  
+end

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -64,7 +64,7 @@ module Micronaut
           @output.puts
           @output.puts "Pending:"
           @pending_examples.each do |pending_example, message|
-            @output.puts "\n  #{pending_example.last.class.name} #{pending_example.first}"
+            @output.puts "\n  #{pending_example.behaviour}\n  - #{pending_example.description}"
           end
         end
         @output.flush

data/lib/micronaut/kernel_extensions.rb

@@ -0,0 +1,11 @@
+module Micronaut
+  module KernelExtensions
+
+    def describe(*args, &describe_block)
+      Micronaut::BehaviourGroup.describe(*args, &describe_block)
+    end
+
+  end
+end
+
+include Micronaut::KernelExtensions

data/lib/micronaut/matchers.rb

@@ -1,12 +1,10 @@
 require 'micronaut/matchers/generated_descriptions'
-require 'micronaut/matchers/errors'
 require 'micronaut/matchers/simple_matcher'
 require 'micronaut/matchers/be'
 require 'micronaut/matchers/be_close'
 require 'micronaut/matchers/change'
 require 'micronaut/matchers/eql'
 require 'micronaut/matchers/equal'
-require 'micronaut/matchers/exist'
 require 'micronaut/matchers/has'
 require 'micronaut/matchers/have'
 require 'micronaut/matchers/include'
@@ -136,6 +134,8 @@ module Micronaut
   #
   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_")

data/lib/micronaut/matchers/has.rb

@@ -1,5 +1,6 @@
 module Micronaut
   module Matchers
+
     def has(sym, *args) # :nodoc:
       simple_matcher do |actual, matcher|
         matcher.failure_message          = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false"
@@ -8,11 +9,11 @@ module Micronaut
         actual.__send__(predicate(sym), *args)
       end
     end
-    
-  private
+
+    private
     def predicate(sym)
       "#{sym.to_s.sub("have_","has_")}?".to_sym
     end
 
   end
-end
+end

data/lib/micronaut/matchers/have.rb

@@ -1,6 +1,8 @@
 module Micronaut
   module Matchers
+    
     class Have #:nodoc:
+      
       def initialize(expected, relativity=:exactly)
         @expected = (expected == :no ? 0 : expected)
         @relativity = relativity
@@ -146,5 +148,6 @@ EOF
     def have_at_most(n)
       Matchers::Have.new(n, :at_most)
     end
+    
   end
-end
+end

data/lib/micronaut/mocking.rb

@@ -0,0 +1,6 @@
+module Micronaut
+  module Mocking   
+    autoload :WithMocha, 'micronaut/mocking/with_mocha'
+    autoload :WithAbsolutelyNothing, 'micronaut/mocking/with_absolutely_nothing'
+  end
+end

data/lib/micronaut/mocking/with_absolutely_nothing.rb

@@ -0,0 +1,11 @@
+module Micronaut
+  module Mocking
+    module WithAbsolutelyNothing
+      
+      def _setup_mocks; end
+      def _verify_mocks; end
+      def _teardown_mocks; end
+      
+    end
+  end
+end

data/lib/micronaut/mocking/with_mocha.rb

@@ -5,18 +5,9 @@ module Micronaut
   module Mocking
     module WithMocha
       include Mocha::Standalone
-      def setup_mocks
-        mocha_setup
-      end
-    
-      def verify_mocks
-        mocha_verify
-      end
-    
-      def teardown_mocks
-        mocha_teardown
-      end
-      
+      alias :_setup_mocks :mocha_setup
+      alias :_verify_mocks :mocha_verify
+      alias :_teardown_mocks :mocha_teardown      
     end
   end
 end

data/lib/micronaut/runner.rb

@@ -22,14 +22,6 @@ module Micronaut
     def run(args = [])
       @verbose = args.delete('-v')
 
-      filter = if args.first =~ /^(-n|--name)$/ then
-                 args.shift
-                 arg = args.shift
-                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
-               else
-                 /./ # anything - ^example_ already filtered by #examples
-               end
-
        total_examples = Micronaut::World.behaviour_groups.inject(0) { |sum, eg| sum + eg.examples.size }
        
        old_sync, options.formatter.output.sync = options.formatter.output.sync, true if options.formatter.output.respond_to?(:sync=)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Chad Humphries
@@ -9,7 +9,7 @@ autorequire: micronaut
 bindir: bin
 cert_chain: []
 
-date: 2008-12-02 00:00:00 -08:00
+date: 2008-12-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,6 +30,7 @@ extensions: []
 extra_rdoc_files: 
 - README
 - LICENSE
+- RSPEC-LICENSE
 files: 
 - LICENSE
 - README
@@ -40,7 +41,8 @@ files:
 - lib/autotest/micronaut.rb
 - lib/micronaut
 - lib/micronaut/behaviour_group.rb
-- lib/micronaut/behaviour_group_class_methods.rb
+- lib/micronaut/configuration.rb
+- lib/micronaut/example.rb
 - lib/micronaut/expectations
 - lib/micronaut/expectations/errors.rb
 - lib/micronaut/expectations/extensions
@@ -50,20 +52,18 @@ files:
 - lib/micronaut/expectations/handler.rb
 - lib/micronaut/expectations/wrap_expectation.rb
 - lib/micronaut/expectations.rb
-- lib/micronaut/extensions
-- lib/micronaut/extensions/kernel.rb
 - lib/micronaut/formatters
 - lib/micronaut/formatters/base_formatter.rb
 - lib/micronaut/formatters/base_text_formatter.rb
 - lib/micronaut/formatters/progress_formatter.rb
 - lib/micronaut/formatters.rb
+- lib/micronaut/kernel_extensions.rb
 - lib/micronaut/matchers
 - lib/micronaut/matchers/be.rb
 - lib/micronaut/matchers/be_close.rb
 - lib/micronaut/matchers/change.rb
 - lib/micronaut/matchers/eql.rb
 - lib/micronaut/matchers/equal.rb
-- lib/micronaut/matchers/errors.rb
 - lib/micronaut/matchers/generated_descriptions.rb
 - lib/micronaut/matchers/has.rb
 - lib/micronaut/matchers/have.rb
@@ -78,7 +78,9 @@ files:
 - lib/micronaut/matchers/throw_symbol.rb
 - lib/micronaut/matchers.rb
 - lib/micronaut/mocking
+- lib/micronaut/mocking/with_absolutely_nothing.rb
 - lib/micronaut/mocking/with_mocha.rb
+- lib/micronaut/mocking.rb
 - lib/micronaut/runner.rb
 - lib/micronaut/runner_options.rb
 - lib/micronaut/world.rb
@@ -87,6 +89,7 @@ files:
 - examples/lib
 - examples/lib/micronaut
 - examples/lib/micronaut/behaviour_group_example.rb
+- examples/lib/micronaut/configuration_example.rb
 - examples/lib/micronaut/expectations
 - examples/lib/micronaut/expectations/extensions
 - examples/lib/micronaut/expectations/extensions/object_example.rb
@@ -95,6 +98,7 @@ files:
 - examples/lib/micronaut/formatters
 - examples/lib/micronaut/formatters/base_formatter_example.rb
 - examples/lib/micronaut/formatters/progress_formatter_example.rb
+- examples/lib/micronaut/kernel_extensions_example.rb
 - examples/lib/micronaut/matchers
 - examples/lib/micronaut/matchers/be_close_example.rb
 - examples/lib/micronaut/matchers/be_example.rb

data/lib/micronaut/behaviour_group_class_methods.rb

@@ -1,119 +0,0 @@
-module Micronaut
-  module BehaviourGroupClassMethods
-    
-    def inherited(klass)
-      super
-      Micronaut::World.behaviour_groups << klass
-    end
-    
-    def befores
-      @_befores ||= { :all => [], :each => [] }
-    end
-    
-    def before_eachs
-      befores[:each]
-    end
-    
-    def before_alls
-      befores[:all]
-    end
-    
-    def before(type=:each, &block)
-      befores[type] << block
-    end
-    
-    def afters
-      @_afters ||= { :all => [], :each => [] }
-    end
-    
-    def after_eachs
-      afters[:each]
-    end
-    
-    def after_alls
-      afters[:all]
-    end
-    
-    def after(type=:each, &block)
-      afters[type] << block
-    end
-    
-    def it(desc=nil, options={}, &block)
-      examples << [desc, options, block]
-    end
-    
-    def examples
-      @_examples ||= []
-    end
-    
-    def set_it_up(*args)
-      metadata[:options] = args.last.is_a?(Hash) ? args.pop : {}
-      metadata[:described_type] = args.first.is_a?(String) ? self.superclass.described_type : args.shift
-      metadata[:description] = args.shift || ''
-      metadata[:name] = "#{metadata[:described_type]} #{metadata[:description]}".strip
-    end
-    
-    def metadata
-      @_metadata ||= {}
-    end
-    
-    def name
-      metadata[:name]
-    end
-    
-    def described_type
-      metadata[:described_type]
-    end
-    
-    def description
-      metadata[:description]
-    end
-    
-    def options
-      metadata[:options]
-    end
-    
-    def describe(*args, &describe_block)
-      raise ArgumentError if args.empty? || describe_block.nil?
-      
-      args << {} unless Hash === args.last
-     # args.last[:spec_path] ||= File.expand_path(caller(0)[2])
-      
-      subclass('NestedLevel') do
-        set_it_up(*args)
-        module_eval(&describe_block)
-      end
-    end
-    
-    def each_ancestor(superclass_last=false)
-      classes = []
-      current_class = self
-
-      while current_class < Micronaut::BehaviourGroup
-        superclass_last ? classes << current_class : classes.unshift(current_class)
-        current_class = current_class.superclass
-      end
-      
-      classes.each { |example_group| yield example_group }
-    end
-  
-    def run(runner)
-      new.execute(runner)
-    end
-    
-    def subclass(base_name, &body) # :nodoc:
-      @_sub_class_count ||= 0
-      @_sub_class_count += 1
-      klass = Class.new(self)
-      class_name = "#{base_name}_#{@_sub_class_count}"
-      const_set(class_name, klass)
-      klass.instance_eval(&body)
-      klass
-    end
-    
-    def to_s
-      name
-    end
-    
-  end
-end

data/lib/micronaut/extensions/kernel.rb

@@ -1,13 +0,0 @@
-module Micronaut
-  module Extensions
-    module Kernel
-
-      def describe(*args, &describe_block)
-        Micronaut::BehaviourGroup.describe(*args, &describe_block)
-      end
-
-    end
-  end
-end
-
-include Micronaut::Extensions::Kernel

data/lib/micronaut/matchers/errors.rb

@@ -1,5 +0,0 @@
-module Micronaut
-  module Matchers
-    class MatcherError < StandardError; end
-  end
-end