spicycode-micronaut 0.1.4.1 → 0.1.4.2

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 require 'rubygems/specification'
 
 GEM = "micronaut"
-GEM_VERSION = "0.1.4.1"
+GEM_VERSION = "0.1.4.2"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://spicycode.com"
@@ -68,9 +68,18 @@ namespace :micronaut do
   desc "Run all examples using rcov"
   task :coverage do
     examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
-    system "rcov --exclude \"examples/*,gems/*,db/*,/Library/Ruby/*,config/*\" --text-report --sort coverage --no-validator-links #{examples.join(' ')}"
+    result = system "rcov --exclude \"examples/*,gems/*,db/*,/Library/Ruby/*,config/*\" --text-summary  --sort coverage --no-validator-links #{examples.join(' ')}"
+    fail_build unless result
   end
   
+  def fail_build
+    puts
+    puts "-" * 79
+    puts "Build Failed"
+    puts "-" * 79
+    abort
+  end
+    
   desc "Delete coverage artifacts" 
   task :clean_coverage do
     rm_rf Dir["coverage/**/*"]

data/examples/example_helper.rb

@@ -18,7 +18,7 @@ module Micronaut
 end
 
 def remove_last_describe_from_world
-  Micronaut::World.behaviours.pop
+  Micronaut.world.behaviours.pop
 end
 
 class DummyFormatter <  Micronaut::Formatters::BaseTextFormatter; end
@@ -29,8 +29,9 @@ end
 
 Micronaut.configure do |config|
   config.mock_with :mocha
-  config.options = Micronaut::RunnerOptions.new(:color => true, :formatter => :progress)
-  config.profile_examples = false
+  config.color_enabled = true
+  config.formatter = :progress
+  config.profile_examples = true
   config.add_filter :options => { :focused => true }
   config.autorun!
 end

data/examples/lib/micronaut/behaviour_example.rb

@@ -172,8 +172,13 @@ describe Micronaut::Behaviour do
   end
 
   describe Foo, "describing nested behaviours" do 
+    
+    before { "before_each_1" }
+    before(:all) { "before_all_1" }
+    after { "after_each_1" }
+    after(:all) { "after_all_1" }
 
-    describe "nested describes" do
+    describe "nested describes", :just_testing => 'yep' do
     
       it "should set the described type to the parent described type if no described type is given" do
         self.class.described_type.should == Foo
@@ -182,10 +187,14 @@ describe Micronaut::Behaviour do
       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 set the options to the last parameter if it is a hash" do
+        self.class.options.should include(:just_testing => 'yep')
+      end
+      
+      it "should have the caller in the options hash" do
+        self.class.options.should include(:caller)
+      end
 
     end
 

data/examples/lib/micronaut/configuration_example.rb

@@ -46,9 +46,9 @@ describe Micronaut::Configuration do
     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

@@ -44,9 +44,11 @@ describe Micronaut::Example do
   end
   
   describe "accessing metadata within a running example" do
-    
-    it "should be able to get the current example object"
-    
+
+    it "should have a reference to itself when running" do
+      running_example.description.should == "should have a reference to itself when running"
+    end
+  
   end
   
 end

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

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 describe Micronaut::Formatters::BaseFormatter do
   
   before(:all) do
-    @formatter = Micronaut::Formatters::BaseFormatter.new(nil, nil)    
+    @formatter = Micronaut::Formatters::BaseFormatter.new 
   end
 
   class HaveInterfaceMatcher

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

@@ -3,21 +3,21 @@ require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 describe Micronaut::Formatters::ProgressFormatter do
   
   before do
-    @io = StringIO.new
-    @options = mock('options')
-    @options.stubs(:enable_color_in_output?).returns(false)
-    @formatter = Micronaut::Formatters::ProgressFormatter.new(@options, @io)
+    @output = StringIO.new
+    @formatter = Micronaut::Formatters::ProgressFormatter.new
+    @formatter.stubs(:color_enabled?).returns(false)
+    @formatter.stubs(:output).returns(@output)
     @original_profile_setting = Micronaut.configuration.profile_examples
   end
 
   it "should produce line break on start dump" do
     @formatter.start_dump
-    @io.string.should eql("\n")
+    @output.string.should eql("\n")
   end
 
   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/
+    @output.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failures\n/i
   end
   
   it "should produce standard summary" do
@@ -27,32 +27,38 @@ describe Micronaut::Formatters::ProgressFormatter do
     remove_last_describe_from_world
     example = behaviour.examples.first
     @formatter.example_pending(example, "message")
-    @io.rewind
+    @output.rewind
     @formatter.dump_summary(3, 2, 1, 1)
-    @io.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failure, 1 pending\n/
+    @output.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failures, 1 pending\n/i
   end
+  
+  describe "when color is enabled" do
+    
+    before do
+      @formatter.stubs(:color_enabled?).returns(true)
+    end
 
-  it "should push green dot for passing spec" do
-    @options.expects(:enable_color_in_output?).returns(true)
-    @formatter.example_passed("spec")
-    @io.string.should == "\e[32m.\e[0m"
-  end
+    it "should push green dot for passing spec" do
+      @formatter.color_enabled?.should == true
+      @formatter.example_passed("spec")
+      @output.string.should == "\e[32m.\e[0m"
+    end
 
-  it "should push red F for failure spec" do
-    @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 red F for failure spec" do
+      @formatter.example_failed("spec", Micronaut::Expectations::ExpectationNotMetError.new)
+      @output.string.should eql("\e[31mF\e[0m")
+    end
 
-  it "should push magenta F for error spec" do
-    @options.expects(:enable_color_in_output?).returns(true)
-    @formatter.example_failed("spec", RuntimeError.new)
-    @io.string.should eql("\e[35mF\e[0m")
+    it "should push magenta F for error spec" do
+      @formatter.example_failed("spec", RuntimeError.new)
+      @output.string.should eql("\e[35mF\e[0m")
+    end
+    
   end
-
+  
   it "should push nothing on start" do
     @formatter.start(4)
-    @io.string.should eql("")
+    @output.string.should eql("")
   end
 
   it "should ensure two ':' in the first backtrace" do
@@ -64,7 +70,7 @@ 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
-EOE
+ EOE
   end
   
 end

data/examples/lib/micronaut/world_example.rb

@@ -4,13 +4,17 @@ class Bar; end
 class Foo; end
 
 describe Micronaut::World do
+  
+  before do
+    @world = Micronaut::World.new
+    Micronaut.stubs(:world).returns(@world)
+  end
 
   describe "behaviour groups" do
 
     it "should contain all defined behaviour groups" do
       behaviour_group = Micronaut::Behaviour.describe(Bar, 'Empty Behaviour Group') { }
-      Micronaut::World.behaviours.should include(behaviour_group)       
-      remove_last_describe_from_world
+      @world.behaviours.should include(behaviour_group)       
     end
 
   end
@@ -34,82 +38,65 @@ describe Micronaut::World do
       @behaviours = [@bg1, @bg2, @bg3, @bg4]
     end
 
-    after(:all) do
-      Micronaut::World.behaviours.delete(@bg1)
-      Micronaut::World.behaviours.delete(@bg2)
-      Micronaut::World.behaviours.delete(@bg3)
-      Micronaut::World.behaviours.delete(@bg4)
-    end
-    
     it "should find awesome examples" do
-      Micronaut::World.find(@bg4.examples, :options => {:awesome => true}).should == [@bg4.examples[1], @bg4.examples[2]]
+      @world.find(@bg4.examples, :options => {:awesome => true}).should == [@bg4.examples[1], @bg4.examples[2]]
     end
     
     it "should find no groups when given no search parameters" do
-      Micronaut::World.find([]).should == []
+      @world.find([]).should == []
     end
   
     it "should find three groups when searching for :described_type => Bar" do
-      Micronaut::World.find(@behaviours, :described_type => Bar).should == [@bg1, @bg2, @bg3]
+      @world.find(@behaviours, :described_type => Bar).should == [@bg1, @bg2, @bg3]
     end
     
     it "should find one group when searching for :description => 'find group-1'" do
-      Micronaut::World.find(@behaviours, :description => 'find group-1').should == [@bg1]
+      @world.find(@behaviours, :description => 'find group-1').should == [@bg1]
     end
     
     it "should find two groups when searching for :description => lambda { |v| v.include?('-1') || v.include?('-3') }" do
-      Micronaut::World.find(@behaviours, :description => lambda { |v| v.include?('-1') || v.include?('-3') }).should == [@bg1, @bg3]
+      @world.find(@behaviours, :description => lambda { |v| v.include?('-1') || v.include?('-3') }).should == [@bg1, @bg3]
     end
     
     it "should find three groups when searching for :description => /find group/" do
-      Micronaut::World.find(@behaviours, :description => /find group/).should == [@bg1, @bg2, @bg3]
+      @world.find(@behaviours, :description => /find group/).should == [@bg1, @bg2, @bg3]
     end
     
     it "should find one group when searching for :options => { :foo => 1 }" do
-      Micronaut::World.find(@behaviours, :options => { :foo => 1 }).should == [@bg1]
+      @world.find(@behaviours, :options => { :foo => 1 }).should == [@bg1]
     end
     
     it "should find one group when searching for :options => { :pending => true }" do
-      Micronaut::World.find(@behaviours, :options => { :pending => true }).should == [@bg2]
+      @world.find(@behaviours, :options => { :pending => true }).should == [@bg2]
     end
 
     it "should find one group when searching for :options => { :array => [1,2,3,4] }" do
-      Micronaut::World.find(@behaviours, :options => { :array => [1,2,3,4] }).should == [@bg3]
+      @world.find(@behaviours, :options => { :array => [1,2,3,4] }).should == [@bg3]
     end
 
     it "should find no group when searching for :options => { :array => [4,3,2,1] }" do
-      Micronaut::World.find(@behaviours, :options => { :array => [4,3,2,1] }).should be_empty
+      @world.find(@behaviours, :options => { :array => [4,3,2,1] }).should be_empty
     end    
 
     it "should find two groups when searching for :options => { :color => 'blue' }" do
-      Micronaut::World.find(@behaviours, :options => { :color => 'blue' }).should == [@bg1, @bg3]
+      @world.find(@behaviours, :options => { :color => 'blue' }).should == [@bg1, @bg3]
     end
 
     it "should find two groups when searching for :options => { :feature => 'reporting' }" do
-      Micronaut::World.find(@behaviours, :options => { :feature => 'reporting' }).should == [@bg1, @bg2]
-    end
-
-  end
-
-  describe "reset" do
-
-    it "should clear the list of behaviour groups" do
-      original_groups = Micronaut::World.behaviours
-
-      Micronaut::World.behaviours.should_not be_empty
-      Micronaut::World.reset
-      Micronaut::World.behaviours.should be_empty
-
-      Micronaut::World.behaviours.concat(original_groups)
+      @world.find(@behaviours, :options => { :feature => 'reporting' }).should == [@bg1, @bg2]
     end
 
   end
   
-  describe "filter_behaviours_to_run" do
+  describe '#filter_behaviours' do
     
-    it "does nothing if there are no filters"
-      # how do you spec this kind of behavior?  It feels like we need to be able to create new instances of Micronaut to properly spec 
-      # this kind of thing, so we can mock/stub or interrogate state without affecting the actual running instance.
+    it "should return immediately if there are no filters" do
+      filters = stub('filters', :any? => false)
+      filters.expects(:each).never
+      Micronaut.configuration.stubs(:filters).returns(filters)
+      Micronaut.world.filter_behaviours
+    end
+
   end
 
 end

data/examples/lib/micronaut_example.rb

@@ -20,4 +20,20 @@ describe Micronaut do
     
   end
   
+  describe "world" do
+    
+    it "should return the Micronaut::World instance the current run is using" do
+      Micronaut.world.should be_instance_of(Micronaut::World)
+    end
+    
+  end
+  
+  describe "InstallDirectory" do
+    
+    it "should be the expanded version of the install directory" do
+      Micronaut::InstallDirectory.should == File.expand_path(File.dirname(__FILE__) + "/../../lib")
+    end
+    
+  end
+  
 end

data/lib/autotest/micronaut.rb

@@ -7,9 +7,11 @@ Autotest.add_hook :initialize do |at|
   at.add_mapping(%r%^examples/.*_example.rb$%) { |filename, _| 
     filename 
   }
+  
   at.add_mapping(%r%^lib/(.*)\.rb$%) { |filename, m| 
     ["examples/lib/#{m[1]}_example.rb"]
   }
+  
   at.add_mapping(%r%^examples/(example_helper|shared/.*)\.rb$%) { 
     at.files_matching %r%^examples/.*_example\.rb$%
   }

data/lib/micronaut.rb

@@ -4,7 +4,6 @@ require 'micronaut/expectations'
 require 'micronaut/world'
 require 'micronaut/configuration'
 require 'micronaut/runner'
-require 'micronaut/runner_options'
 require 'micronaut/example'
 require 'micronaut/behaviour'
 require 'micronaut/kernel_extensions'
@@ -34,4 +33,8 @@ module Micronaut
     yield configuration
   end
   
+  def self.world
+    @world ||= Micronaut::World.new
+  end
+  
 end

data/lib/micronaut/behaviour.rb

@@ -1,10 +1,12 @@
 module Micronaut
   class Behaviour
     include Micronaut::Matchers 
-
+    
+    attr_accessor :running_example
+    
     def self.inherited(klass)
       super
-      Micronaut::World.behaviours << klass
+      Micronaut.world.behaviours << klass
     end
     
     def self.extended_modules #:nodoc:
@@ -165,6 +167,7 @@ module Micronaut
       success = true
 
       examples_to_run.each do |ex|
+        group.running_example = ex
         reporter.example_started(ex)
 
         execution_error = nil
@@ -190,6 +193,7 @@ module Micronaut
         success &= execution_error.nil?
       end
       eval_after_alls(group)
+      group.running_example = nil
       success
     end
 

data/lib/micronaut/configuration.rb

@@ -1,7 +1,7 @@
 module Micronaut
 
   class Configuration
-    # Destired mocking framework - expects the symbol name of the framework
+    # Desired mocking framework - expects the symbol name of the framework
     # Currently supported: :mocha, :rr, or nothing (the default if this is not set at all)
     attr_reader :mock_framework
     
@@ -14,12 +14,14 @@ module Micronaut
     # Filters allow you to exclude or include certain examples from running based on options you pass in 
     attr_reader :filters
     
-    # When this is true, if you have filters enabled and no examples match, all examples are added and run - defaults to true
+    # When this is true, if you have filters enabled and no examples match, 
+    # all examples are added and run - defaults to true
     attr_accessor :run_all_when_everything_filtered
 
     # Enable profiling of the top 10 slowest examples - defaults to false
     attr_accessor :profile_examples
     
+    
     def initialize
       @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/]
       @profile_examples = false
@@ -55,16 +57,34 @@ module Micronaut
       Micronaut::Runner.autorun unless Micronaut::Runner.installed_at_exit?      
     end
     
-    def options=(new_options)
-      raise ArguementError unless new_options.is_a?(Micronaut::RunnerOptions)
-      @options = new_options
+    # Determines whether or not any output should include ANSI color codes,
+    # defaults to true
+    def color_enabled?
+      @color_enabled || true
+    end
+    
+    def color_enabled=(on_or_off)
+      @color_enabled = on_or_off
     end
     
-    def options
-      # Do we need this?
-      @options ||= Micronaut::RunnerOptions.new(:color => true, :formatter => :documentation)
+    # The formatter to use.  Defaults to the documentation formatter
+    def formatter=(formatter_to_use)
+      @formatter_to_use = formatter_to_use.to_s
     end
     
+    def formatter
+      @formatter ||= case @formatter_to_use
+                     when 'documentation'
+                       Micronaut::Formatters::DocumentationFormatter.new
+                     else
+                       Micronaut::Formatters::ProgressFormatter.new
+                     end
+    end
+    
+    def output
+      $stdout
+    end
+        
     def extra_modules
       @extra_modules ||= []
     end

data/lib/micronaut/formatters/base_formatter.rb

@@ -1,17 +1,36 @@
 module Micronaut
   module Formatters
-    # Baseclass for formatters that implements all required methods as no-ops. 
+
     class BaseFormatter
-      attr_accessor :behaviour, :options, :output, :total_example_failed, :total_example_pending
+      attr_accessor :behaviour
+      
+      def initialize
+        @total_example_failed, @total_example_pending, @behaviour = 0, 0, nil
+      end
       
-      def initialize(options, output_to)
-        @options, @output = options, output_to
-        @total_example_failed, @total_example_pending = 0, 0
+      def configuration
+        Micronaut.configuration
+      end
+      
+      def output
+        Micronaut.configuration.output
       end
       
       def profile_examples?
         Micronaut.configuration.profile_examples
       end
+      
+      def color_enabled?
+        configuration.color_enabled?
+      end
+      
+      def total_example_failed
+        @total_example_failed
+      end
+      
+      def total_example_pending
+        @total_example_pending
+      end
 
       # This method is invoked before any examples are run, right after
       # they have all been collected. This can be useful for special

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -3,20 +3,24 @@ module Micronaut
   module Formatters
 
     class BaseTextFormatter < BaseFormatter
-      attr_reader :pending_examples, :failed_examples
-
-      def initialize(options, output_to)
-        super
-        @pending_examples = []
-        @failed_examples = []
-        @example_profiling_info = []
+      
+      def example_profiling_info
+        @example_profiling_info ||= []
+      end
+      
+      def pending_examples
+        @pending_examples ||= []
+      end
+      
+      def failed_examples
+        @failed_examples ||= []
       end
             
       def example_passed(example)
         super
         # Why && @start_time
         if profile_examples? && @start_time
-          @example_profiling_info << [example, Time.now - @start_time] 
+          example_profiling_info << [example, Time.now - @start_time] 
         end
       end
       
@@ -25,25 +29,25 @@ module Micronaut
       end
 
       def example_pending(example, message)
-        @pending_examples << [example, message]
+        pending_examples << [example, message]
       end
 
       def example_failed(example, exception)
         super
-        @failed_examples << [example, exception]
+        failed_examples << [example, exception]
       end
 
       def dump_failures
-        @output.puts
-        @failed_examples.each_with_index do |examples_with_exception, index|
+        output.puts
+        failed_examples.each_with_index do |examples_with_exception, index|
           example, exception = examples_with_exception.first, examples_with_exception.last
           padding = '    '
-          @output.puts "#{index.next}) #{example}"
-          # @output.puts "#{padding}failing statement:  #{read_failed_line(example.options[:caller])}\n"
-          @output.puts "#{padding}#{colorise(exception.message, exception).strip}"
-          @output.puts grey("#{padding}# #{format_backtrace(exception.backtrace)}")
-          @output.puts 
-          @output.flush
+          output.puts "#{index.next}) #{example}"
+          # output.puts "#{padding}failing statement:  #{read_failed_line(example.options[:caller])}\n"
+          output.puts "#{padding}#{colorise(exception.message, exception).strip}"
+          output.puts grey("#{padding}# #{format_backtrace(exception.backtrace)}")
+          output.puts 
+          output.flush
         end
       end
       
@@ -61,48 +65,53 @@ module Micronaut
       end
 
       def dump_summary(duration, example_count, failure_count, pending_count)
-        @output.puts "\nFinished in #{duration} seconds\n"
+        output.puts "\nFinished in #{duration} seconds\n"
 
-        summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
+        summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failures"
         summary << ", #{pending_count} pending" if pending_count > 0  
 
         if failure_count == 0
           if pending_count > 0
-            @output.puts yellow(summary)
+            output.puts yellow(summary)
           else
-            @output.puts green(summary)
+            output.puts green(summary)
           end
         else
-          @output.puts red(summary)
+          output.puts red(summary)
         end
         
         if profile_examples?  
-          sorted_examples = @example_profiling_info.sort_by { |desc, time| time }
-          @output.puts "\nTop 10 slowest examples:\n"        
-          sorted_examples.last(10).reverse.each do |desc, time|
-            @output.puts "  (#{sprintf("%.7f", time)} seconds) #{desc}"
-            @output.puts grey("   # #{desc.options[:caller]}")
+          sorted_examples = example_profiling_info.sort_by { |desc, time| time }.last(5)
+          output.puts "\nTop #{sorted_examples.size} slowest examples:\n"        
+          sorted_examples.reverse.each do |desc, time|
+            output.puts "  (#{sprintf("%.7f", time)} seconds) #{desc}"
+            output.puts grey("   # #{desc.options[:caller]}")
           end
         end
         
-        @output.flush
+        output.flush
       end
+      
+      # def textmate_link_backtrace(path)
+      #   file, line = path.split(':')
+      #   "txmt://open/?url=file://#{File.expand_path(file)}&line=#{line}"
+      # end
 
       def dump_pending
-        unless @pending_examples.empty?
-          @output.puts
-          @output.puts "Pending:"
-          @pending_examples.each do |pending_example, message|
-            @output.puts "\n  #{pending_example.behaviour}\n  - #{pending_example.description}"
-            @output.puts grey("    # #{pending_example.options[:caller]}")
+        unless pending_examples.empty?
+          output.puts
+          output.puts "Pending:"
+          pending_examples.each do |pending_example, message|
+            output.puts "\n  #{pending_example.behaviour}\n  - #{pending_example.description}"
+            output.puts grey("    # #{pending_example.options[:caller]}")
           end
         end
-        @output.flush
+        output.flush
       end
 
       def close
-        if IO === @output && @output != $stdout
-          @output.close 
+        if IO === output && output != $stdout
+          output.close 
         end
       end
 
@@ -114,10 +123,6 @@ module Micronaut
 
       protected
 
-      def enable_color_in_output?
-        @options.enable_color_in_output?
-      end
-
       def backtrace_line(line)
         return nil if Micronaut.configuration.cleaned_from_backtrace?(line)
         line.sub!(/\A([^:]+:\d+)$/, '\\1')
@@ -126,7 +131,7 @@ module Micronaut
       end
 
       def color(text, color_code)
-        return text unless enable_color_in_output?
+        return text unless color_enabled?
         "#{color_code}#{text}\e[0m"
       end
 

data/lib/micronaut/formatters/progress_formatter.rb

@@ -5,25 +5,25 @@ module Micronaut
       
       def example_failed(example, exception)
         super
-        @output.print colorise('F', exception)
-        @output.flush
+        output.print colorise('F', exception)
+        output.flush
       end
 
       def example_passed(example)
         super
-        @output.print green('.')
-        @output.flush
+        output.print green('.')
+        output.flush
       end
 
       def example_pending(example, message)
         super
-        @output.print yellow('*')
-        @output.flush
+        output.print yellow('*')
+        output.flush
       end
 
       def start_dump
-        @output.puts
-        @output.flush
+        output.puts
+        output.flush
       end
 
       def method_missing(sym, *args)

data/lib/micronaut/runner.rb

@@ -10,12 +10,19 @@ module Micronaut
       at_exit { Micronaut::Runner.new.run(ARGV) ? exit(0) : exit(1) } unless installed_at_exit?
       @installed_at_exit = true
     end
-
-    def options
-      Micronaut.configuration.options
+    
+    def configuration
+      Micronaut.configuration
     end
-
+    
+    def formatter
+      Micronaut.configuration.formatter
+    end
+    
+    # This method takes command line args like examples/**/*_example.rb and
+    # uses globbing to grab all the files specified and load them
     def load_all_behaviours(files_from_args=[])
+      # TODO: Make this horrid looking line more readable by at least some humans
       files_from_args.inject([]) { |files, arg| files.concat(Dir[arg].map { |g| Dir.glob(g) }.flatten) }.each do |file|
         load file
       end
@@ -24,29 +31,29 @@ module Micronaut
     def run(args = [])
       load_all_behaviours(args)
       
-      behaviours_to_run = Micronaut::World.behaviours_to_run
+      behaviours_to_run = Micronaut.world.behaviours_to_run
 
       total_examples = behaviours_to_run.inject(0) { |sum, b| sum + b.examples_to_run.size }
 
-      old_sync, options.formatter.output.sync = options.formatter.output.sync, true if options.formatter.output.respond_to?(:sync=)
+      old_sync, formatter.output.sync = formatter.output.sync, true if formatter.output.respond_to?(:sync=)
 
-      options.formatter.start(total_examples)
+      formatter.start(total_examples)
 
       suite_success = true
 
       starts_at = Time.now
       behaviours_to_run.each do |behaviour|
-        suite_success &= behaviour.run(options.formatter)
+        suite_success &= behaviour.run(formatter)
       end
       duration = Time.now - starts_at
 
-      options.formatter.start_dump
-      options.formatter.dump_failures
+      formatter.start_dump
+      formatter.dump_failures
       # TODO: Stop passing in the last two items, the formatter knows this info
-      options.formatter.dump_summary(duration, total_examples, options.formatter.failed_examples.size, options.formatter.pending_examples.size)
-      options.formatter.dump_pending
+      formatter.dump_summary(duration, total_examples, formatter.failed_examples.size, formatter.pending_examples.size)
+      formatter.dump_pending
 
-      options.formatter.output.sync = old_sync if options.formatter.output.respond_to? :sync=
+      formatter.output.sync = old_sync if formatter.output.respond_to? :sync=
 
       suite_success
     end

data/lib/micronaut/world.rb

@@ -1,18 +1,12 @@
 module Micronaut
 
   class World
-
-    def self.reset
-      @behaviours = []
-    end
-
-    reset
-
-    def self.behaviours
-      @behaviours
+    
+    def behaviours
+      @behaviours ||= []
     end
 
-    def self.behaviours_to_run
+    def behaviours_to_run
       filter_behaviours
       number_of_behaviours_left = sum_behaviours
       
@@ -20,30 +14,29 @@ module Micronaut
         if Micronaut.configuration.filters.empty?
           add_all_examples
         elsif Micronaut.configuration.run_all_when_everything_filtered?
-          puts "  Filter(s) produced no matches - running everything"
+          puts "Filters produced no matches - running everything"
           add_all_examples
         else
-          puts "  Filter(s) matched no specs - your world is empty, desolate, and alone."
+          puts "Filters matched no specs - your world is empty, desolate, and alone."
         end
       end
       
       behaviours
     end
     
-    def self.sum_behaviours
+    def sum_behaviours
       behaviours.inject(0) { |sum, b| sum += b.examples_to_run.size }
     end
     
-    def self.add_all_examples
+    def add_all_examples
       behaviours.each do |behaviour|
         behaviour.examples_to_run.concat(behaviour.examples)
       end
     end
     
-    def self.filter_behaviours
+    def filter_behaviours
       return unless Micronaut.configuration.filters.any?
       Micronaut.configuration.filters.each do |filter|
-        puts "  Run filtered using: #{filter.inspect}"
         behaviours.each do |behaviour|
           behaviour.examples_to_run.concat find(behaviour.examples, filter)
         end
@@ -51,7 +44,7 @@ module Micronaut
       behaviours      
     end
 
-    def self.find(collection, conditions={})
+    def find(collection, conditions={})
       return [] if conditions.empty?
 
       collection.select do |item|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.1.4.1
+  version: 0.1.4.2
 platform: ruby
 authors: 
 - Chad Humphries
@@ -9,7 +9,7 @@ autorequire: micronaut
 bindir: bin
 cert_chain: []
 
-date: 2008-12-18 00:00:00 -08:00
+date: 2008-12-19 00:00:00 -08:00
 default_executable: micronaut
 dependencies: []
 
@@ -74,7 +74,6 @@ files:
 - lib/micronaut/mocking/with_rr.rb
 - lib/micronaut/mocking.rb
 - lib/micronaut/runner.rb
-- lib/micronaut/runner_options.rb
 - lib/micronaut/world.rb
 - lib/micronaut.rb
 - examples/example_helper.rb
@@ -113,7 +112,6 @@ files:
 - examples/lib/micronaut/matchers/simple_matcher_example.rb
 - examples/lib/micronaut/matchers/throw_symbol_example.rb
 - examples/lib/micronaut/runner_example.rb
-- examples/lib/micronaut/runner_options_example.rb
 - examples/lib/micronaut/world_example.rb
 - examples/lib/micronaut_example.rb
 - examples/resources

data/examples/lib/micronaut/runner_options_example.rb

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

data/lib/micronaut/runner_options.rb

@@ -1,33 +0,0 @@
-module Micronaut
-  class RunnerOptions
-    
-    attr_accessor :color, :formatter
-    
-    def initialize(options={})
-      @color = options.delete(:color)
-      @formatter = options.delete(:formatter)
-    end
-    
-    def enable_color_in_output?
-      !textmate? && @color
-    end
-    
-    def textmate?
-      ENV.has_key?('TM_RUBY')
-    end
-    
-    def output
-      $stdout
-    end
-    
-    def formatter
-      @formatter_instance ||= case @formatter.to_s
-                              when 'documentation'
-                                Micronaut::Formatters::DocumentationFormatter.new(self, output)
-                              else
-                                Micronaut::Formatters::ProgressFormatter.new(self, output)
-                              end
-    end
-
-  end
-end