micronaut 0.2.9 → 0.3.0

data/Rakefile

@@ -23,24 +23,8 @@ end
 begin
   require 'rake/contrib/sshpublisher'
   namespace :rubyforge do
-
     desc "Release gem and RDoc documentation to RubyForge"
-    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
-
-    namespace :release do
-      desc "Publish RDoc to RubyForge."
-      task :docs => [:rdoc] do
-        config = YAML.load(
-            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-        )
-
-        host = "#{config['username']}@rubyforge.org"
-        remote_dir = "/var/www/gforge-projects/the-perfect-gem/"
-        local_dir = 'rdoc'
-
-        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-      end
-    end
+    task :release => ["rubyforge:release:gem"]
   end
 rescue LoadError
   puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
@@ -58,7 +42,7 @@ task :untested do
   end
 end
 
-puts "Running in Ruby #{RUBY_VERSION}"
+puts "Running in Ruby #{RUBY_PLATFORM} #{RUBY_VERSION}"
 desc "Run all micronaut examples"
 Micronaut::RakeTask.new :examples do |t|
   t.pattern = "examples/**/*_example.rb"

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 9
+:minor: 3
+:patch: 0
 :major: 0
-:minor: 2

data/examples/lib/micronaut/configuration_example.rb

@@ -130,4 +130,14 @@ describe Micronaut::Configuration do
     
   end
 
+  describe "filters" do
+    
+    it "tells you filter is deprecated"
+    
+    it "responds to exclusion_filter"
+    
+    it "responds to inclusion_filter"
+    
+    
+  end
 end

data/examples/lib/micronaut/world_example.rb

@@ -11,16 +11,16 @@ describe Micronaut::World do
   end
 
   describe "behaviour groups" do
-
+  
     it "should contain all defined behaviour groups" do
       behaviour_group = Micronaut::Behaviour.describe(Bar, 'Empty Behaviour Group') { }
       @world.behaviours.should include(behaviour_group)       
     end
-
+  
   end
-
-  describe "find" do
-
+  
+  describe "applying inclusion filters" do
+  
     before(:all) do
       options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
       options_2 = { :pending => true, :feature => 'reporting'  }
@@ -44,55 +44,124 @@ describe Micronaut::World do
       Micronaut.world.behaviours.delete(@bg3)
       Micronaut.world.behaviours.delete(@bg4)
     end
-
+  
     it "should find awesome examples" do
-      @world.find(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
+      @world.apply_inclusion_filters(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
     end
     
     it "should find no groups when given no search parameters" do
-      @world.find([]).should == []
+      @world.apply_inclusion_filters([]).should == []
     end
   
     it "should find three groups when searching for :behaviour_describes => Bar" do
-      @world.find(@behaviours, :behaviour => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
+      @world.apply_inclusion_filters(@behaviours, :behaviour => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
     end
     
     it "should find one group when searching for :description => 'find group-1'" do
-      @world.find(@behaviours, :behaviour => { :description => 'find group-1' }).should == [@bg1]
+      @world.apply_inclusion_filters(@behaviours, :behaviour => { :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
-      @world.find(@behaviours, :behaviour => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3]
+      @world.apply_inclusion_filters(@behaviours, :behaviour => { :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
-      @world.find(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
+      @world.apply_inclusion_filters(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
     end
     
     it "should find one group when searching for :foo => 1" do
-      @world.find(@behaviours, :foo => 1 ).should == [@bg1]
+      @world.apply_inclusion_filters(@behaviours, :foo => 1 ).should == [@bg1]
     end
     
     it "should find one group when searching for :pending => true" do
-      @world.find(@behaviours, :pending => true ).should == [@bg2]
+      @world.apply_inclusion_filters(@behaviours, :pending => true ).should == [@bg2]
     end
-
+  
     it "should find one group when searching for :array => [1,2,3,4]" do
-      @world.find(@behaviours, :array => [1,2,3,4]).should == [@bg3]
+      @world.apply_inclusion_filters(@behaviours, :array => [1,2,3,4]).should == [@bg3]
     end
-
+  
     it "should find no group when searching for :array => [4,3,2,1]" do
-      @world.find(@behaviours, :array => [4,3,2,1]).should be_empty
+      @world.apply_inclusion_filters(@behaviours, :array => [4,3,2,1]).should be_empty
     end    
-
+  
     it "should find two groups when searching for :color => 'blue'" do
-      @world.find(@behaviours, :color => 'blue').should == [@bg1, @bg3]
+      @world.apply_inclusion_filters(@behaviours, :color => 'blue').should == [@bg1, @bg3]
     end
-
+  
     it "should find two groups when searching for :feature => 'reporting' }" do
-      @world.find(@behaviours, :feature => 'reporting').should == [@bg1, @bg2]
+      @world.apply_inclusion_filters(@behaviours, :feature => 'reporting').should == [@bg1, @bg2]
+    end
+  
+  end
+  
+  describe "applying exclusion filters" do
+    
+    it "should find nothing if all describes match the exclusion filter" do
+      options = { :network_access => true }      
+      
+      isolate_behaviour do
+        group1 = Micronaut::Behaviour.describe(Bar, "find group-1", options) do
+          it("foo") {}
+          it("bar") {}
+        end
+        
+        @world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+      end
+      
+      isolate_behaviour do
+        group2 = Micronaut::Behaviour.describe(Bar, "find group-1") do
+          it("foo", :network_access => true) {}
+          it("bar") {}
+        end
+        
+        @world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
+      end
+  
+    end
+    
+    it "should find nothing if a regexp matches the exclusion filter" do
+      isolate_behaviour do
+        group = Micronaut::Behaviour.describe(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
+          it("foo") {}
+          it("bar") {}
+        end
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :behaviour => {
+          :describes => lambda { |b| b == Bar } } ).should == []
+        
+        @world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == group.examples
+        @world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == group.examples
+      end
+    end
+    
+  end
+  
+  describe "filtering behaviours" do
+    
+    before(:all) do
+      @group1 = Micronaut::Behaviour.describe(Bar, "find these examples") do
+        it('I have no options',       :color => :red, :awesome => true) {}
+        it("I also have no options",  :color => :red, :awesome => true) {}
+        it("not so awesome",          :color => :red, :awesome => false) {}
+      end
+    end
+    
+    after(:all) do
+      Micronaut.world.behaviours.delete(@group1)
     end
 
+    it "should run matches" do
+      Micronaut.world.stubs(:exclusion_filter).returns({ :awesome => false })
+      Micronaut.world.stubs(:filter).returns({ :color => :red })
+      Micronaut.world.stubs(:behaviours).returns([@group1])
+      filtered_behaviours = @world.filter_behaviours
+      filtered_behaviours.should == [@group1]
+      @group1.examples_to_run.should == @group1.examples[0..1]      
+    end
+    
   end
 
 end

data/lib/micronaut/configuration.rb

@@ -10,6 +10,8 @@ module Micronaut
     # Allows you to control what examples are ran by filtering 
     attr_reader :filter
     
+    attr_reader :exclusion_filter
+    
     # Modules that will be included or extended based on given filters
     attr_reader :include_or_extend_modules
     
@@ -34,7 +36,7 @@ module Micronaut
       @before_and_afters = { :before => { :each => [], :all => [] }, :after => { :each => [], :all => [] } }
       @include_or_extend_modules = []
       @formatter_to_use = Micronaut::Formatters::ProgressFormatter
-      @filter = nil
+      @filter, @exclusion_filter = nil, nil
       mock_with nil unless @mock_framework_established
     end
     

data/lib/micronaut/formatters/base_formatter.rb

@@ -37,11 +37,11 @@ module Micronaut
       end
       
       def pending_examples
-        @pending_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'pending' })
+        @pending_examples ||= ::Micronaut.world.find(examples, :positive, :execution_result => { :status => 'pending' })
       end
       
       def failed_examples
-        @failed_examples ||= ::Micronaut.world.find(examples, :execution_result => { :status => 'failed' })
+        @failed_examples ||= ::Micronaut.world.find(examples, :positive, :execution_result => { :status => 'failed' })
       end
 
       # This method is invoked before any examples are run, right after

data/lib/micronaut/mocking/with_mocha.rb

@@ -4,7 +4,12 @@ require 'mocha/object'
 module Micronaut
   module Mocking
     module WithMocha
-      include Mocha::Standalone
+      # Mocha::Standalone was deprecated as of Mocha 0.9.7.  
+      begin
+        include Mocha::API
+      rescue NameError
+        include Mocha::Standalone
+      end
 
       alias :_setup_mocks :mocha_setup
       alias :_verify_mocks :mocha_verify

data/lib/micronaut/world.rb

@@ -11,11 +11,15 @@ module Micronaut
     def filter
       Micronaut.configuration.filter
     end
+    
+    def exclusion_filter
+      Micronaut.configuration.exclusion_filter
+    end
 
     def behaviours_to_run
       return @behaviours_to_run if @behaviours_to_run
       
-      if filter
+      if filter || exclusion_filter
         @behaviours_to_run = filter_behaviours
         if @behaviours_to_run.size == 0 && Micronaut.configuration.run_all_when_everything_filtered?
           puts "No examples were matched by #{filter.inspect}, running all"
@@ -38,21 +42,38 @@ module Micronaut
     end
 
     def filter_behaviours
-      behaviours.inject([]) do |list, b|
-        b.examples_to_run.replace(find(b.examples, filter).uniq)
-        # Do not add behaviours with 0 examples to run
-        list << (b.examples_to_run.size == 0 ? nil : b)
+      behaviours.inject([]) do |list_of_behaviors, _behavior|
+        examples = _behavior.examples
+        examples = apply_exclusion_filters(examples, exclusion_filter) if exclusion_filter
+        examples = apply_inclusion_filters(examples, filter) if filter
+        examples.uniq!
+        _behavior.examples_to_run.replace(examples)
+        if examples.empty?
+          list_of_behaviors << nil
+        else
+          list_of_behaviors << _behavior
+        end
       end.compact
     end
 
-    def find(collection, conditions={})
+    def find(collection, type_of_filter=:positive, conditions={})
+      negative = type_of_filter != :positive
+      
       collection.select do |item|
-        conditions.all? { |filter_on, filter| apply_condition(filter_on, filter, item.metadata) }
+        # negative conditions.any?, positive conditions.all? ?????
+        result = conditions.all? do |filter_on, filter| 
+                   apply_condition(filter_on, filter, item.metadata)
+                 end
+        negative ? !result : result
       end
     end
     
-    def find_behaviours(conditions={})
-      find(behaviours, conditions)
+    def apply_inclusion_filters(collection, conditions={})
+      find(collection, :positive, conditions)
+    end
+    
+    def apply_exclusion_filters(collection, conditions={})
+      find(collection, :negative, conditions)
     end
 
     def apply_condition(filter_on, filter, metadata)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: micronaut
 version: !ruby/object:Gem::Version 
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors: 
 - Chad Humphries
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-23 00:00:00 -04:00
+date: 2009-08-10 00:00:00 -04:00
 default_executable: micronaut
 dependencies: []
 
@@ -23,7 +23,6 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files: 
-- History.txt
 - LICENSE
 - README.markdown
 - RSPEC-LICENSE
@@ -125,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: spicycode-depot
-rubygems_version: 1.3.3
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: An excellent replacement for the wheel...

data/History.txt

@@ -1,15 +0,0 @@
-0.0.8
-=======================
-- It turns out I'm horrible at updating history files
-- Added MockWith::AbsolutelyNothing as the default
-- Added the ability to setup before, after, include, and extend blocks using a extensible API
-
-0.0.6 
-=======================
-- MockWith::Mocha autoloads now
-- Beginnings of the configure block in example helper
-- Ability to search behaviour groups is in
-
-0.0.5
-=======================
-- Describes are working at any level, befores/afters correctly cascade