spicycode-micronaut 0.1.7 → 0.1.7.1

data/Rakefile

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

data/examples/example_helper.rb

@@ -23,21 +23,8 @@ def remove_last_describe_from_world
   Micronaut.world.behaviours.pop
 end
 
-class DummyFormatter <  Micronaut::Formatters::BaseTextFormatter; end
-
-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 = use_color?
-  config.formatter = :documentation
-  config.profile_examples = false
-  config.filter_run :focused => true
-  config.autorun!
-end
+Micronaut.configure do |c|
+  c.mock_with :mocha
+  c.color_enabled = !ENV.has_key?('TM_MODE')
+  c.filter_run :focused => true
+end

data/examples/lib/micronaut/behaviour_example.rb

@@ -9,7 +9,7 @@ describe Micronaut::Behaviour do
 
   describe "describing behaviour with #describe" do
 
-    example "an ArgumentError is raised if no name is given" do
+    example "an ArgumentError is raised if no type or description is given" do
       lambda { Micronaut::Behaviour.describe() {} }.should raise_error(ArgumentError, "No arguments given.  You must a least supply a type or description")
     end
 
@@ -59,29 +59,27 @@ describe Micronaut::Behaviour do
         Micronaut::Behaviour.describe(Object, nil, 'foo' => 'bar') { }.metadata.should include({ "foo" => 'bar' })
       end
       
-      it "should add the file_path_with_line_number of the current behaviour to metadata" do
-        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:file_path_with_line_number].should == "#{__FILE__}:#{__LINE__}"
+      it "should add the caller to metadata" do
+        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:caller].should == "#{__FILE__}:#{__LINE__}"
       end
       
-      it "should add the the file_path of the current behaviour to metadata" do
-        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:file_path].should == "#{__FILE__}"
+      it "should add the the file_path to metadata" do
+        Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:file_path].should == __FILE__
       end
       
-      it "should add a reader for file_path to the behaviour for easy access" do
-        Micronaut::Behaviour.describe(Object) { }.file_path.should == "#{__FILE__}"
+      it "should have a reader for file_path" do
+        Micronaut::Behaviour.describe(Object) { }.file_path.should == __FILE__
       end
       
-      it "should add the line_number of the current behavior to metadata" do
+      it "should add the line_number to metadata" do
         Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:line_number].should == __LINE__
       end
       
       it "should add file path and line number metadata for arbitrarily nested describes" do
         Micronaut::Behaviour.describe(Object) do
           Micronaut::Behaviour.describe("foo") do
-
-            Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:file_path_with_line_number].should == "#{__FILE__}:#{__LINE__}"
+            Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:caller].should == "#{__FILE__}:#{__LINE__}"
             Micronaut::Behaviour.describe(Object) { }.metadata[:behaviour][:line_number].should == __LINE__
-            
           end
         end
       end
@@ -211,10 +209,10 @@ describe Micronaut::Behaviour do
   end
   
   describe "#run" do
+    
+    pending "should run after(:each) when the example fails"
 
-    pending "should run after(:each) even if the example fails" 
-
-    pending "should run after(:each) even if the example raises an Exception" 
+    pending "should run after(:each) when the example raises an Exception" 
     
   end
 

data/examples/lib/micronaut/configuration_example.rb

@@ -25,9 +25,9 @@ describe Micronaut::Configuration do
       end
     end
 
-    it "should include the given module into each behaviour group" do
-      Micronaut.configuration.include(InstanceLevelMethods)
-      group = Micronaut::Behaviour.describe(Object, 'does like, stuff and junk') { }
+    it "should include the given module into each matching behaviour" do
+      Micronaut.configuration.include(InstanceLevelMethods, :magic_key => :include)
+      group = Micronaut::Behaviour.describe(Object, 'does like, stuff and junk', :magic_key => :include) { }
       group.should_not respond_to(:you_call_this_a_blt?)
       remove_last_describe_from_world
 
@@ -45,9 +45,10 @@ describe Micronaut::Configuration do
 
     end
 
-    it "should extend the given module into each behaviour group" do
-      Micronaut.configuration.extend(ThatThingISentYou)
-      group = Micronaut::Behaviour.describe(ThatThingISentYou) { }
+    it "should extend the given module into each matching behaviour" do
+      Micronaut.configuration.extend(ThatThingISentYou, :magic_key => :extend)      
+      group = Micronaut::Behaviour.describe(ThatThingISentYou, :magic_key => :extend) { }
+      
       group.should respond_to(:that_thing)
       remove_last_describe_from_world
     end

data/examples/lib/micronaut/example_example.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
 describe Micronaut::Example do
 
   before do
-    behaviour = stub('behaviour', :name => 'behaviour_name', :metadata => {})
+    behaviour = stub('behaviour', :metadata => { :behaviour => { :name => 'behaviour_name' }})
     @example = Micronaut::Example.new(behaviour, 'description', {}, (lambda {}))
   end
   

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

@@ -104,20 +104,20 @@ describe Micronaut::Formatters::BaseFormatter do
     @formatter.should have_interface_for(:close).with(0).arguments
   end
   
-  describe 'dealing with backtrace' do
+  describe '#format_backtrace' do
     
-    it "should allow displaying the full backtrace with an option", :pending => true do
-      backtrace = ["/tmp/x.rb:1", "foo/vendor/rails/x.rb:1"]
-      result = @formatter.format_backtrace(backtrace, running_example)
-      result.should == backtrace
+    before do
+      @full_backtrace = ["examples/lib/micronaut/formatters/base_formatter_example.rb:118", "vendor/rails/x.rb:1", "/bin/micronaut"]
+    end
+
+    it "should display the full backtrace when the example is given the :full_backtrace => true option", :full_backtrace => true do
+      running_example.metadata[:full_backtrace].should be_true
+      @formatter.format_backtrace(@full_backtrace, running_example).should ==  @full_backtrace
     end
-    
-    it "should ensure ':' in the first backtrace" do
-      backtrace = ["/tmp/x.rb:1", "/tmp/x.rb:2", "/tmp/x.rb:3"]
-      @formatter.format_backtrace(backtrace, running_example).should == backtrace
 
-      backtrace = ["/tmp/x.rb:1: message", "/tmp/x.rb:2", "/tmp/x.rb:3"]
-      @formatter.format_backtrace(backtrace, running_example).first.should == "/tmp/x.rb:1: message"
+    it "should clean the backtrace when the full_backtrace option is not given" do
+      running_example.metadata[:full_backtrace].should be_nil
+      @formatter.format_backtrace(@full_backtrace, running_example).should ==  ["examples/lib/micronaut/formatters/base_formatter_example.rb:118"]
     end
     
   end

data/lib/micronaut/behaviour.rb

@@ -75,36 +75,28 @@ module Micronaut
       @_examples_to_run ||= []
     end
 
-    # This method is friggin' gigantic, and must be stopped
-    # 
     def self.set_it_up(*args)
-      @metadata = {:behaviour => {}}
+      @metadata = { :behaviour => {} }
       extra_metadata = args.last.is_a?(Hash) ? args.pop : {}
-      if args.first.is_a?(String)
-        @metadata[:behaviour][:describes] = self.superclass.metadata && self.superclass.metadata[:behaviour][:describes]
-      else
-        @metadata[:behaviour][:describes] = args.shift
-      end
+      extra_metadata.delete(:behaviour) # Remove it when present to prevent it clobbering the one we setup
+      
+      @metadata[:behaviour][:describes] = args.shift unless args.first.is_a?(String)
+      @metadata[:behaviour][:describes] ||= self.superclass.metadata && self.superclass.metadata[:behaviour][:describes]
       @metadata[:behaviour][:description] = args.shift || ''
       @metadata[:behaviour][:name] = "#{describes} #{description}".strip
       @metadata[:behaviour][:block] = extra_metadata.delete(:behaviour_block)
-      file_path_with_line_num = eval("caller(0)[0]", @metadata[:behaviour][:block].binding)
-      @metadata[:behaviour][:file_path_with_line_number] = file_path_with_line_num
-      @metadata[:behaviour][:file_path] = file_path_with_line_num.split(":")[0].strip
-      @metadata[:behaviour][:line_number] = file_path_with_line_num.split(":")[1].to_i
+      @metadata[:behaviour][:caller] = eval("caller(0)[0]", @metadata[:behaviour][:block].binding)
+      @metadata[:behaviour][:file_path] = @metadata[:behaviour][:caller].split(":")[0].strip
+      @metadata[:behaviour][:line_number] = @metadata[:behaviour][:caller].split(":")[1].to_i
       
-      extra_metadata.delete(:behaviour) # Remove it if it is present
       @metadata.update(extra_metadata)
-
-      # should this be here?  I think it should be in the runner, the only possible 
-      # point of contention is whether or not inserted/extended modules should be 
-      # allowed to participate in adding metadata.  If they can, then earlier is better
-      Micronaut.configuration.find_modules(self).each do |include_or_extend, mod, opts|
-        if include_or_extend == :extend
-          send(:extend, mod) unless extended_modules.include?(mod)
-        else
-          send(:include, mod) unless included_modules.include?(mod)
-        end
+      
+      Micronaut.configuration.find_modules(self).each do |include_or_extend, mod, opts|                                                                                                                                                                               
+        if include_or_extend == :extend                                                                                                                                                                                                                               
+          send(:extend, mod) unless extended_modules.include?(mod)                                                                                                                                                                                                    
+        else                                                                                                                                                                                                                                                          
+          send(:include, mod) unless included_modules.include?(mod)                                                                                                                                                                                                   
+        end                                                                                                                                                                                                                                                           
       end
     end
 
@@ -245,7 +237,7 @@ module Micronaut
     end
 
     def self.to_s
-      self == Micronaut::Behaviour ? 'Micronaut::Behaviour' : name
+      self == Micronaut::Behaviour ? 'Micronaut::Behaviour' : @metadata[:behaviour][:name]
     end
     
   end

data/lib/micronaut/configuration.rb

@@ -1,48 +1,46 @@
 module Micronaut
 
   class Configuration
-    # 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
-    
-    # Array of regular expressions to scrub from backtrace
+    # Regex patterns to scrub backtrace with
     attr_reader :backtrace_clean_patterns
     
-    # An array of arrays to store before and after blocks
+    # All of the defined before/after blocks setup in the configuration
     attr_reader :before_and_afters
-
-    # 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
+    # Allows you to control what examples are ran by filtering 
+    attr_reader :filter_run
+    
+    # Modules that will be included or extended based on given filters
+    attr_reader :include_or_extend_modules
+    
+    # Run all examples if the run is filtered, and no examples were found - defaults to true
     attr_accessor :run_all_when_everything_filtered
 
-    # Enable profiling of the top 10 slowest examples - defaults to false
+    # Enable profiling of example run - defaults to false
     attr_accessor :profile_examples
-      
+    
     def initialize
-      @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/, /bin\/micronaut/]
+      @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/, /bin\/micronaut/, /#{::Micronaut::InstallDirectory}/]
       @profile_examples = false
       @run_all_when_everything_filtered = true
-      @filter = nil
-      @before_and_afters = []
+      @color_enabled = false
+      @before_and_afters = { :before => { :each => [], :all => [] }, :after => { :each => [], :all => [] } }
+      @include_or_extend_modules = []
+      @formatter_to_use = Micronaut::Formatters::ProgressFormatter
     end
     
+    # E.g. alias_example_to :crazy_slow, :speed => 'crazy_slow' defines
+    # crazy_slow as an example variant that has the crazy_slow speed option
     def alias_example_to(new_name, extra_options={})
       Micronaut::Behaviour.alias_example_to(new_name, extra_options)
     end
         
     def cleaned_from_backtrace?(line)
-      return true if line =~ /#{::Micronaut::InstallDirectory}/
-      
-      @backtrace_clean_patterns.any? do |pattern|
-        line =~ pattern
-      end
+      @backtrace_clean_patterns.any? { |regex| line =~ regex }
     end
     
     def mock_with(make_a_mockery_with=nil)
-      @mock_framework = case make_a_mockery_with
+      mock_framework = case make_a_mockery_with
                         when :mocha
                           require 'micronaut/mocking/with_mocha'
                           Micronaut::Mocking::WithMocha
@@ -50,88 +48,89 @@ module Micronaut
                           require 'micronaut/mocking/with_rr'
                           Micronaut::Mocking::WithRR
                         else
+                          require 'micronaut/mocking/with_absolutely_nothing'
                           Micronaut::Mocking::WithAbsolutelyNothing
                         end 
 
-      Micronaut::Behaviour.send(:include, @mock_framework)
+      Micronaut::Behaviour.send(:include, mock_framework)
     end
     
     def autorun!
       Micronaut::Runner.autorun
     end
+       
+    def color_enabled=(on_or_off)
+      @color_enabled = on_or_off
+    end
     
-    # Determines whether or not any output should include ANSI color codes,
-    # defaults to true
+    # Output with ANSI color enabled? Defaults to false
     def color_enabled?
       @color_enabled
     end
     
-    def color_enabled=(on_or_off)
-      @color_enabled = on_or_off
+    def filter_run(options={})
+      @filter_run = options
+    end
+    
+    def run_all_when_everything_filtered?
+      @run_all_when_everything_filtered
     end
     
-    # The formatter to use.  Defaults to the documentation formatter
     def formatter=(formatter_to_use)
-      @formatter_to_use = formatter_to_use.to_s
+      @formatter_to_use = case formatter_to_use.to_s
+                          when 'documentation' then Micronaut::Formatters::DocumentationFormatter
+                          when 'progress' then Micronaut::Formatters::ProgressFormatter
+                          end
     end
     
+    # The formatter all output should use.  Defaults to the progress formatter
     def formatter
-      @formatter ||= case @formatter_to_use
-                     when 'documentation'
-                       Micronaut::Formatters::DocumentationFormatter.new
-                     else
-                       Micronaut::Formatters::ProgressFormatter.new
-                     end
+      @formatter ||= @formatter_to_use.new
     end
     
+    # Where does output go? For now $stdout
     def output
       $stdout
     end
-        
-    def extra_modules
-      @extra_modules ||= []
-    end
-        
-    def include(module_to_include, options={})
-      extra_modules << [:include, module_to_include, options]
+
+    def include(mod, options={})
+      if options.empty?
+        Micronaut::Behaviour.send(:include, mod)
+      else
+        include_or_extend_modules << [:include, mod, options]
+      end
     end
     
-    def extend(module_to_extend, options={})
-      extra_modules << [:extend, module_to_extend, options]
+    def extend(mod, options={})
+      if options.empty?
+        Micronaut::Behaviour.send(:extend, mod)
+      else
+        include_or_extend_modules << [:extend, mod, options]
+      end
     end
     
     def find_modules(group)
-      extra_modules.select do |include_or_extend, mod, options|
+      include_or_extend_modules.select do |include_or_extend, mod, options|
         options.all? do |filter_on, filter|
           Micronaut.world.apply_condition(filter_on, filter, group.metadata)
         end
       end
     end
-      
-    def filter_run(options={})
-      @filter = options
-    end
-    
-    def run_all_when_everything_filtered?
-      @run_all_when_everything_filtered
-    end
           
-    def before(type=:each, options={}, &block)
-      before_and_afters << [:before, :each, options, block]
+    def before(each_or_all=:each, options={}, &block)
+      before_and_afters[:before][each_or_all] << [options, block]
     end
     
-    def after(type=:each, options={}, &block)
-      before_and_afters << [:after, :each, options, block]
+    def after(each_or_all=:each, options={}, &block)
+      before_and_afters[:after][each_or_all] << [options, block]
     end
     
     def find_before_or_after(desired_type, desired_each_or_all, group)
-      before_and_afters.select do |type, each_or_all, options, block|
-        type == desired_type && 
-        each_or_all == desired_each_or_all &&
+      before_and_afters[desired_type][desired_each_or_all].select do |options, block|
         options.all? do |filter_on, filter|
           Micronaut.world.apply_condition(filter_on, filter, group.metadata)
         end
-      end.map { |type, each_or_all, options, block| block }
+      end.map { |options, block| block }
     end
     
   end

data/lib/micronaut/example.rb

@@ -12,7 +12,7 @@ module Micronaut
     end
 
     def inspect
-      "#{behaviour.name} - #{description}"
+      "#{@metadata[:behaviour][:name]} - #{@metadata[:description]}"
     end
     
     def to_s

data/lib/micronaut/formatters/base_formatter.rb

@@ -105,13 +105,10 @@ module Micronaut
       end
       
       def format_backtrace(backtrace, example)
-        return "" if backtrace.nil?
-        cleansed = backtrace.map { |line| backtrace_line(line) }.compact
-        
-        cleansed = cleansed.select do |line|
-          line.split(':').first.downcase == example.behaviour.file_path.downcase
-        end
+        return "" unless backtrace
+        return backtrace if example.metadata[:full_backtrace] == true
 
+        cleansed = backtrace.select { |line| backtrace_line(line) }
         cleansed.empty? ? backtrace : cleansed
       end
       
@@ -126,10 +123,10 @@ module Micronaut
       
       def read_failed_line(exception, example)
         original_file = example.behaviour.file_path.downcase
-        matching_line = exception.backtrace.find do |line|
-          line.split(':').first.downcase == original_file.downcase
-        end
+        matching_line = exception.backtrace.detect { |line| line.split(':').first.downcase == original_file.downcase }
+
         return "Unable to find matching line from backtrace" if matching_line.nil?
+        
         file_path, line_number = matching_line.split(':')
         if File.exist?(file_path)
           open(file_path, 'r') { |f| f.readlines[line_number.to_i - 1] }

data/lib/micronaut/formatters/base_text_formatter.rb

@@ -93,8 +93,8 @@ module Micronaut
           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.metadata[:caller]}")
+            output.puts "  #{pending_example}"
+            output.puts grey("   # #{pending_example.metadata[:caller]}")
           end
         end
         output.flush

data/lib/micronaut/runner.rb

@@ -7,8 +7,9 @@ module Micronaut
     end
 
     def self.autorun
-      at_exit { Micronaut::Runner.new.run(ARGV) ? exit(0) : exit(1) } unless installed_at_exit?
+      return if installed_at_exit?
       @installed_at_exit = true
+      at_exit { Micronaut::Runner.new.run(ARGV) ? exit(0) : exit(1) } 
     end
 
     def configuration
@@ -54,4 +55,4 @@ module Micronaut
 
   end
 
-end
+end

data/lib/micronaut/world.rb

@@ -8,16 +8,12 @@ module Micronaut
       @behaviours = []
     end
 
-    def filter
-      Micronaut.configuration.filter
-    end
-
     def behaviours_to_run
       return @behaviours_to_run if @behaviours_to_run
 
-      if filter
+      if Micronaut.configuration.filter_run
         @behaviours_to_run = filter_behaviours
-        puts "\nRun filtered using #{filter.inspect}"
+        puts "\nRun filtered using #{Micronaut.configuration.filter_run.inspect}"
         if @behaviours_to_run.size == 0 && Micronaut.configuration.run_all_when_everything_filtered?
           puts "No behaviours were matched, running all"
           # reset the behaviour list to all behaviours, and add back all examples
@@ -37,8 +33,8 @@ module Micronaut
 
     def filter_behaviours
       behaviours.inject([]) do |list, b|
-        b.examples_to_run.replace(find(b.examples, filter).uniq)
-        # Don't add behaviours with no examples to run onto the suite run
+        b.examples_to_run.replace(find(b.examples, Micronaut.configuration.filter_run).uniq)
+        # Do not add behaviours with 0 examples to run
         list << (b.examples_to_run.size == 0 ? nil : b)
       end.compact
     end
@@ -48,6 +44,10 @@ module Micronaut
         conditions.all? { |filter_on, filter| apply_condition(filter_on, filter, item.metadata) }
       end
     end
+    
+    def find_behaviours(conditions={})
+      find(behaviours, conditions)
+    end
 
     def apply_condition(filter_on, filter, metadata)
       return false if metadata.nil?
@@ -66,4 +66,4 @@ module Micronaut
 
   end
 
-end
+end

data/lib/micronaut.rb

@@ -1,4 +1,4 @@
-require 'micronaut/mocking'
+require 'micronaut/mocking/with_absolutely_nothing'
 require 'micronaut/matchers'
 require 'micronaut/expectations'
 require 'micronaut/world'
@@ -31,6 +31,7 @@ module Micronaut
 
   def self.configure
     yield configuration
+    configuration.autorun!
   end
   
   def self.world

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spicycode-micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.7.1
 platform: ruby
 authors: 
 - Chad Humphries
@@ -72,7 +72,6 @@ files:
 - lib/micronaut/mocking/with_absolutely_nothing.rb
 - lib/micronaut/mocking/with_mocha.rb
 - lib/micronaut/mocking/with_rr.rb
-- lib/micronaut/mocking.rb
 - lib/micronaut/runner.rb
 - lib/micronaut/world.rb
 - lib/micronaut.rb

data/lib/micronaut/mocking.rb

@@ -1,7 +0,0 @@
-require 'micronaut/mocking/with_absolutely_nothing'
-
-module Micronaut
-  module Mocking   
-
-  end
-end