spicycode-micronaut 0.1.4.2 → 0.1.4.3

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 require 'rubygems/specification'
 
 GEM = "micronaut"
-GEM_VERSION = "0.1.4.2"
+GEM_VERSION = "0.1.4.3"
 AUTHOR = "Chad Humphries"
 EMAIL = "chad@spicycode.com"
 HOMEPAGE = "http://spicycode.com"

data/bin/micronaut

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 require 'micronaut'
-Micronaut::Runner.autorun
+Micronaut.configuration.autorun!

data/examples/example_helper.rb

@@ -2,6 +2,7 @@ lib_path = File.expand_path(File.dirname(__FILE__) + "/../lib")
 $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 
 require 'micronaut'
+require 'rubygems'
 gem :mocha
 require File.expand_path(File.dirname(__FILE__) + "/resources/example_classes")
 
@@ -27,11 +28,15 @@ def dummy_reporter
   DummyFormatter.new({}, StringIO.new)
 end
 
+def use_color?
+  !ENV.has_key?('TM_MODE')
+end
+
 Micronaut.configure do |config|
   config.mock_with :mocha
-  config.color_enabled = true
+  config.color_enabled = use_color?
   config.formatter = :progress
-  config.profile_examples = true
-  config.add_filter :options => { :focused => true }
+  config.profile_examples = false
+  config.filter_run :options => { :focused => true, :using_mocks => true }
   config.autorun!
 end

data/examples/lib/micronaut/behaviour_example.rb

@@ -2,12 +2,8 @@ require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
 
 describe Micronaut::Behaviour do
 
-  class Foo
-
-  end  
-
   def empty_behaviour_group
-    group = Micronaut::Behaviour.describe(Foo, 'Empty Behaviour Group') { }
+    group = Micronaut::Behaviour.describe(Object, 'Empty Behaviour Group') { }
     remove_last_describe_from_world
   end
 
@@ -28,7 +24,7 @@ describe Micronaut::Behaviour do
       end
 
       it "should call to_s on the first parameter in case it is a constant" do
-        Micronaut::Behaviour.describe(Foo) { }.name.should == 'Foo'
+        Micronaut::Behaviour.describe(Object) { }.name.should == 'Object'
       end
 
     end
@@ -36,7 +32,7 @@ describe Micronaut::Behaviour do
     describe '#described_type' do
 
       it "should be the first parameter when it is a constant" do
-        Micronaut::Behaviour.describe(Foo) { }.described_type.should == Foo
+        Micronaut::Behaviour.describe(Object) { }.described_type.should == Object
       end
 
       it "should be nil when the first parameter is a string" do
@@ -48,11 +44,11 @@ describe Micronaut::Behaviour do
     describe '#description' do
 
       it "should expose the second parameter as description" do
-        Micronaut::Behaviour.describe(Foo, "my desc") { }.description.should == 'my desc'
+        Micronaut::Behaviour.describe(Object, "my desc") { }.description.should == 'my desc'
       end
 
       it "should allow the second parameter to be nil" do
-        Micronaut::Behaviour.describe(Foo, nil) { }.description.size.should == 0
+        Micronaut::Behaviour.describe(Object, nil) { }.description.size.should == 0
       end
 
     end
@@ -60,11 +56,11 @@ describe Micronaut::Behaviour do
     describe '#options' do
 
       it "should expose the third parameter as options" do
-        Micronaut::Behaviour.describe(Foo, nil, 'foo' => 'bar') { }.options.should == { "foo" => 'bar' }
+        Micronaut::Behaviour.describe(Object, nil, 'foo' => 'bar') { }.options.should == { "foo" => 'bar' }
       end
 
       it "should be an empty hash if no options are supplied" do
-        Micronaut::Behaviour.describe(Foo, nil) { }.options.should == {}
+        Micronaut::Behaviour.describe(Object, nil) { }.options.should == {}
       end
 
     end
@@ -171,29 +167,20 @@ 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 Object, "describing nested behaviours" do 
 
-    describe "nested describes", :just_testing => 'yep' do
+    describe "A sample nested describe", :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
-      end
-      
-      it "should set the description to the first parameter if no described type is given" do
-        self.class.description.should == 'nested describes'
+      it "should set the described type to the constant Object" do
+        running_example.behaviour.described_type.should == Object
       end
       
-      it "should set the options to the last parameter if it is a hash" do
-        self.class.options.should include(:just_testing => 'yep')
+      it "should set the description to 'A sample nested describe'" do
+        running_example.behaviour.description.should == 'A sample nested describe'
       end
       
-      it "should have the caller in the options hash" do
-        self.class.options.should include(:caller)
+      it "should have :just_testing => 'yep' in the options" do
+        running_example.behaviour.options.should include(:just_testing => 'yep')
       end
 
     end

data/examples/lib/micronaut/configuration_example.rb

@@ -4,8 +4,9 @@ describe Micronaut::Configuration do
 
   describe "#mock_with" do
     
-    it "should include the mocha adapter when called with :mocha" do
-      Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithMocha)
+    it "should require and include the mocha adapter when called with :mocha" do
+      Micronaut.configuration.expects(:require).with('micronaut/mocking/with_mocha')
+      Micronaut::Behaviour.expects(:send)
       Micronaut.configuration.mock_with :mocha
     end
   

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

@@ -7,29 +7,23 @@ describe Micronaut::Formatters::ProgressFormatter do
     @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
-    @output.string.should eql("\n")
+    @output.string.should == "\n"
   end
 
   it "should produce standard summary without pending when pending has a 0 count" do
     @formatter.dump_summary(3, 2, 1, 0)
-    @output.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failures\n/i
+    @output.string.should =~ /Finished in 3 seconds\n2 examples, 1 failures/i
   end
   
   it "should produce standard summary" do
-    behaviour = Micronaut::Behaviour.describe("behaviour") do
-      it('example') {}
-    end
-    remove_last_describe_from_world
-    example = behaviour.examples.first
-    @formatter.example_pending(example, "message")
+    @formatter.example_pending(running_example, "message")
     @output.rewind
     @formatter.dump_summary(3, 2, 1, 1)
-    @output.string.should =~ /\nFinished in 3 seconds\n2 examples, 1 failures, 1 pending\n/i
+    @output.string.should =~ /Finished in 3 seconds\n2 examples, 1 failures, 1 pending/i
   end
   
   describe "when color is enabled" do
@@ -38,39 +32,34 @@ describe Micronaut::Formatters::ProgressFormatter do
       @formatter.stubs(:color_enabled?).returns(true)
     end
 
-    it "should push green dot for passing spec" do
-      @formatter.color_enabled?.should == true
+    it "should output a green dot for passing spec" do
       @formatter.example_passed("spec")
       @output.string.should == "\e[32m.\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")
+      @output.string.should == "\e[31mF\e[0m"
     end
 
     it "should push magenta F for error spec" do
       @formatter.example_failed("spec", RuntimeError.new)
-      @output.string.should eql("\e[35mF\e[0m")
+      @output.string.should == "\e[35mF\e[0m"
     end
     
   end
   
   it "should push nothing on start" do
     @formatter.start(4)
-    @output.string.should eql("")
+    @output.string.should == ""
   end
 
   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
-EOE
+    @formatter.format_backtrace(backtrace).should == "/tmp/x.rb:1"
 
     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
+    @formatter.format_backtrace(backtrace).should == "/tmp/x.rb:1: message"
   end
   
 end

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

@@ -15,12 +15,10 @@ describe Micronaut::Matchers do
     end
 
     it "should fail if target does not respond to #has_sym?" do
-      lambda {
-        Object.new.should have_key(:a)
-      }.should raise_error(NoMethodError)
+      lambda { Object.new.should have_key(:a) }.should raise_error(NoMethodError)
     end
   
-    it "should reraise an exception thrown in #has_sym?(*args)" do
+    it "should re-raise an exception thrown in #has_sym?(*args)" do
       o = Object.new
       def o.has_sym?(*args)
         raise "Funky exception"

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

@@ -1,96 +1,125 @@
 require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
 
-module Micronaut
-  module Matchers
-    describe ThrowSymbol do
-      describe "with no args" do
-        before { @matcher = ThrowSymbol.new }
-      
-        it "should match if any Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_true
-        end
-        it "should match if any Symbol is thrown with an arg" do
-          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
-        end
-        it "should not match if no Symbol is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
-        end
-        it "should provide a failure message" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
-        end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym})
-          @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
-        end
-      end
-          
-      describe "with a symbol" do
-        before { @matcher = ThrowSymbol.new(:sym) }
-      
-        it "should match if correct Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_true
-        end
-        it "should match if correct Symbol is thrown with an arg" do
-          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
-        end
-        it "should not match if no Symbol is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
-        end
-        it "should not match if correct Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym }).should be_false
-        end
-        it "should provide a failure message when no Symbol is thrown" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message.should == "expected :sym but nothing was thrown"
-        end
-        it "should provide a failure message when wrong Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message.should == "expected :sym, got :other_sym"
-        end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym })
-          @matcher.negative_failure_message.should == "expected :sym not to be thrown"
-        end
-        it "should only match NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
-        end
-      end
-
-      describe "with a symbol and an arg" do
-        before { @matcher = ThrowSymbol.new(:sym, "a") }
+describe Micronaut::Matchers::ThrowSymbol do
+
+  describe "with no args" do
+
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new
+    end
+
+    it "should match if any Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_true
+    end
+
+    it "should match if any Symbol is thrown with an arg" do
+      @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+    end
+
+    it "should not match if no Symbol is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should provide a failure message" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym})
+      @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
+    end
+
+  end
+
+  describe "with a symbol" do
+
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new(:sym) 
+    end
+
+    it "should match if correct Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_true
+    end
+
+    it "should match if correct Symbol is thrown with an arg" do
+      @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+    end
+
+    it "should not match if no Symbol is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should not match if correct Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym }).should be_false
+    end
+
+    it "should provide a failure message when no Symbol is thrown" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == "expected :sym but nothing was thrown"
+    end
+
+    it "should provide a failure message when wrong Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym })
+      @matcher.failure_message.should == "expected :sym, got :other_sym"
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym })
+      @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+    end
+
+    it "should only match NameErrors raised by uncaught throws" do
+      @matcher.matches?(lambda{ sym }).should be_false
+    end
+
+  end
+
+  describe "with a symbol and an arg" do
     
-        it "should match if correct Symbol and args are thrown" do
-          @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
-        end
-        it "should not match if nothing is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
-        end
-        it "should not match if other Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
-        end
-        it "should not match if no arg is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_false
-        end
-        it "should not match if wrong arg is thrown" do
-          @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
-        end
-        it "should provide a failure message when no Symbol is thrown" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown]
-        end
-        it "should provide a failure message when wrong Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym]
-        end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym })
-          @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown]
-        end
-        it "should only match NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
-        end
-      end
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new(:sym, "a") 
+    end
+
+    it "should match if correct Symbol and args are thrown" do
+      @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+    end
+
+    it "should not match if nothing is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should not match if other Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
     end
+
+    it "should not match if no arg is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_false
+    end
+
+    it "should not match if wrong arg is thrown" do
+      @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+    end
+
+    it "should provide a failure message when no Symbol is thrown" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown]
+    end
+
+    it "should provide a failure message when wrong Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym })
+      @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym]
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym })
+      @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown]
+    end
+
+    it "should only match NameErrors raised by uncaught throws" do
+      @matcher.matches?(lambda{ sym }).should be_false
+    end
+
   end
-end
+
+end

data/examples/lib/micronaut/world_example.rb

@@ -90,13 +90,6 @@ describe Micronaut::World do
   
   describe '#filter_behaviours' do
     
-    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/lib/autotest/micronaut.rb

@@ -38,12 +38,8 @@ class Autotest::Micronaut < Autotest
   end
 
   def make_test_cmd(files_to_test)
-    return '' if files_to_test.empty?
-    
-    examples = files_to_test.keys.flatten
-    
-
-    "#{ruby} #{examples.join(" ")}"
+    return '' if files_to_test.size == 0
+    "bin/micronaut #{files_to_test.keys.join(' ')}"
   end
   
 end

data/lib/micronaut/behaviour.rb

@@ -158,7 +158,7 @@ module Micronaut
     end
 
     def self.run(reporter)
-      return true if examples_to_run.empty?
+      return true if examples.size == 0
 
       reporter.add_behaviour(self)
       
@@ -166,7 +166,7 @@ module Micronaut
       eval_before_alls(group)
       success = true
 
-      examples_to_run.each do |ex|
+      examples.each do |ex|
         group.running_example = ex
         reporter.example_started(ex)
 

data/lib/micronaut/configuration.rb

@@ -11,8 +11,8 @@ module Micronaut
     # An array of arrays to store before and after blocks
     attr_reader :before_and_afters
 
-    # Filters allow you to exclude or include certain examples from running based on options you pass in 
-    attr_reader :filters
+    # Adding a filter allows you to exclude or include certain examples from running based on options you pass in 
+    attr_reader :filter
     
     # When this is true, if you have filters enabled and no examples match, 
     # all examples are added and run - defaults to true
@@ -26,7 +26,7 @@ module Micronaut
       @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/]
       @profile_examples = false
       @run_all_when_everything_filtered = true
-      @filters = []
+      @filter = nil
       @before_and_afters = []
     end
     
@@ -54,13 +54,13 @@ module Micronaut
     end
     
     def autorun!
-      Micronaut::Runner.autorun unless Micronaut::Runner.installed_at_exit?      
+      Micronaut::Runner.autorun
     end
     
     # Determines whether or not any output should include ANSI color codes,
     # defaults to true
     def color_enabled?
-      @color_enabled || true
+      @color_enabled
     end
     
     def color_enabled=(on_or_off)
@@ -114,8 +114,8 @@ module Micronaut
       end
     end
     
-    def add_filter(options={})
-      filters << options
+    def filter_run(options={})
+      @filter = options
     end
     
     def run_all_when_everything_filtered?

data/lib/micronaut/formatters/base_formatter.rb

@@ -31,6 +31,18 @@ module Micronaut
       def total_example_pending
         @total_example_pending
       end
+      
+      def example_profiling_info
+        @example_profiling_info ||= []
+      end
+      
+      def pending_examples
+        @pending_examples ||= []
+      end
+      
+      def failed_examples
+        @failed_examples ||= []
+      end
 
       # This method is invoked before any examples are run, right after
       # they have all been collected. This can be useful for special
@@ -95,6 +107,27 @@ module Micronaut
       # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
       def close
       end
+      
+      def format_backtrace(backtrace)
+        return "" if backtrace.nil?
+        cleansed = backtrace.map { |line| backtrace_line(line) }.compact
+        cleansed.empty? ? backtrace.join("\n") : cleansed.first
+      end
+      
+      protected
+
+      def backtrace_line(line)
+        return nil if configuration.cleaned_from_backtrace?(line)
+        line.sub!(/\A([^:]+:\d+)$/, '\\1')
+        return nil if line == '-e:1'
+        line
+      end
+      
+      def read_failed_line(file_path_with_line_number)
+        file_path, line_number = file_path_with_line_number.split(':')
+        open(file_path, 'r') { |f| f.readlines[line_number.to_i + 1].strip }
+      end
+      
     end
     
   end

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -3,18 +3,6 @@ module Micronaut
   module Formatters
 
     class BaseTextFormatter < BaseFormatter
-      
-      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
@@ -50,11 +38,6 @@ module Micronaut
           output.flush
         end
       end
-      
-      def read_failed_line(file_path_with_line_number)
-        file_path, line_number = file_path_with_line_number.split(':')
-        open(file_path, 'r') { |f| f.readlines[line_number.to_i + 1].strip }
-      end
 
       def colorise(s, failure)
         if failure.is_a?(Micronaut::Expectations::ExpectationNotMetError)
@@ -80,8 +63,9 @@ module Micronaut
           output.puts red(summary)
         end
         
-        if profile_examples?  
-          sorted_examples = example_profiling_info.sort_by { |desc, time| time }.last(5)
+        # Don't print out profiled info if there are failures, it just clutters the output
+        if profile_examples? && failure_count == 0
+          sorted_examples = example_profiling_info.sort_by { |desc, time| time }.last(10)
           output.puts "\nTop #{sorted_examples.size} slowest examples:\n"        
           sorted_examples.reverse.each do |desc, time|
             output.puts "  (#{sprintf("%.7f", time)} seconds) #{desc}"
@@ -115,21 +99,8 @@ module Micronaut
         end
       end
 
-      def format_backtrace(backtrace)
-        return "" if backtrace.nil?
-        cleansed = backtrace.map { |line| backtrace_line(line) }.compact
-        cleansed.empty? ? backtrace.join("\n") : cleansed.first
-      end
-
       protected
 
-      def backtrace_line(line)
-        return nil if Micronaut.configuration.cleaned_from_backtrace?(line)
-        line.sub!(/\A([^:]+:\d+)$/, '\\1')
-        return nil if line == '-e:1'
-        line
-      end
-
       def color(text, color_code)
         return text unless color_enabled?
         "#{color_code}#{text}\e[0m"

data/lib/micronaut/formatters/documentation_formatter.rb

@@ -5,7 +5,7 @@ module Micronaut
 
       attr_reader :previous_nested_behaviours
 
-      def initialize(options, output_to)
+      def initialize
         super
         @previous_nested_behaviours = []
       end
@@ -33,11 +33,12 @@ module Micronaut
           "#{current_indentation}#{example.description} (ERROR)"
         end
 
-        @output.puts(expectation_not_met ? red(message) : magenta(message))
-        @output.flush
+        output.puts(expectation_not_met ? red(message) : magenta(message))
+        output.flush
       end
 
       def example_passed(example)
+        super
         output.puts green("#{current_indentation}#{example.description}")
         output.flush
       end

data/lib/micronaut/runner.rb

@@ -18,31 +18,24 @@ module Micronaut
     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
+     
+    def require_all_behaviours(files_from_args=[])
+      files_from_args.each { |file| require file }
     end
     
     def run(args = [])
-      load_all_behaviours(args)
+      require_all_behaviours(args)
       
-      behaviours_to_run = Micronaut.world.behaviours_to_run
-
-      total_examples = behaviours_to_run.inject(0) { |sum, b| sum + b.examples_to_run.size }
+      total_examples_to_run = Micronaut.world.total_examples_to_run
 
       old_sync, formatter.output.sync = formatter.output.sync, true if formatter.output.respond_to?(:sync=)
 
-      formatter.start(total_examples)
+      formatter.start(total_examples_to_run)
 
       suite_success = true
 
       starts_at = Time.now
-      behaviours_to_run.each do |behaviour|
+      Micronaut.world.behaviours_to_run.each do |behaviour|
         suite_success &= behaviour.run(formatter)
       end
       duration = Time.now - starts_at
@@ -50,7 +43,7 @@ module Micronaut
       formatter.start_dump
       formatter.dump_failures
       # TODO: Stop passing in the last two items, the formatter knows this info
-      formatter.dump_summary(duration, total_examples, formatter.failed_examples.size, formatter.pending_examples.size)
+      formatter.dump_summary(duration, total_examples_to_run, formatter.failed_examples.size, formatter.pending_examples.size)
       formatter.dump_pending
 
       formatter.output.sync = old_sync if formatter.output.respond_to? :sync=

data/lib/micronaut/world.rb

@@ -1,47 +1,45 @@
 module Micronaut
 
   class World
-    
-    def behaviours
-      @behaviours ||= []
+
+    attr_reader :behaviours
+
+    def initialize
+      @behaviours = []
+    end
+
+    def filter
+      Micronaut.configuration.filter
     end
 
     def behaviours_to_run
-      filter_behaviours
-      number_of_behaviours_left = sum_behaviours
-      
-      if number_of_behaviours_left.zero?
-        if Micronaut.configuration.filters.empty?
-          add_all_examples
-        elsif Micronaut.configuration.run_all_when_everything_filtered?
-          puts "Filters produced no matches - running everything"
-          add_all_examples
-        else
-          puts "Filters matched no specs - your world is empty, desolate, and alone."
+      return @behaviours_to_run if @behaviours_to_run
+
+      if filter
+        @behaviours_to_run = filter_behaviours
+        puts "\nRun filtered using #{filter.inspect}"
+        if @behaviours_to_run.size == 0 && Micronaut.configuration.run_all_when_everything_filtered?
+          puts "No behaviours where matched, running all"
+          # reset the behaviour list to all behaviours, and add back all examples
+          @behaviours_to_run = @behaviours
+          @behaviours.each { |b| b.examples_to_run.replace(b.examples) }
         end
-      end
-      
-      behaviours
-    end
-    
-    def sum_behaviours
-      behaviours.inject(0) { |sum, b| sum += b.examples_to_run.size }
+      else
+        @behaviours_to_run = @behaviours
+      end      
+
+      @behaviours_to_run
     end
-    
-    def add_all_examples
-      behaviours.each do |behaviour|
-        behaviour.examples_to_run.concat(behaviour.examples)
-      end
+
+    def total_examples_to_run
+      @total_examples_to_run ||= behaviours_to_run.inject(0) { |sum, b| sum += b.examples_to_run.size }
     end
-    
+
     def filter_behaviours
-      return unless Micronaut.configuration.filters.any?
-      Micronaut.configuration.filters.each do |filter|
-        behaviours.each do |behaviour|
-          behaviour.examples_to_run.concat find(behaviour.examples, filter)
-        end
-      end
-      behaviours      
+      behaviours.inject([]) do |list, b|
+        b.examples_to_run.replace(find(b.examples, filter))
+        list << (b.examples_to_run.size == 0 ? nil : b)
+      end.compact
     end
 
     def find(collection, conditions={})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.1.4.2
+  version: 0.1.4.3
 platform: ruby
 authors: 
 - Chad Humphries
@@ -9,7 +9,7 @@ autorequire: micronaut
 bindir: bin
 cert_chain: []
 
-date: 2008-12-19 00:00:00 -08:00
+date: 2008-12-20 00:00:00 -08:00
 default_executable: micronaut
 dependencies: []