micronaut 0.2.9

data/examples/lib/micronaut_example.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
+
+describe Micronaut do
+
+  describe "#configuration" do
+    
+    it "should return an instance of Micronaut::Configuration" do
+      Micronaut.configuration.should be_an_instance_of(Micronaut::Configuration)
+    end
+    
+  end
+  
+  describe "#configure" do
+    
+    it "should yield the current configuration" do
+      Micronaut.configure do |config|
+        config.should == Micronaut.configuration
+      end
+    end
+    
+    it "should be callable without a block" do
+      Micronaut.configure
+    end
+    
+  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/examples/resources/example_classes.rb

@@ -0,0 +1,67 @@
+# This file contains various classes used by the specs.
+module Micronaut
+  module Expectations
+    class Person
+      attr_reader :name
+      def initialize name
+        @name = name
+      end
+      def == other
+        return @name == other.name
+      end
+    end
+    
+    class ClassWithMultiWordPredicate
+      def multi_word_predicate?
+        true 
+      end
+    end
+
+    module Helper
+      class CollectionWithSizeMethod
+        def initialize; @list = []; end
+        def size; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithLengthMethod
+        def initialize; @list = []; end
+        def length; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionOwner
+        attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method
+
+        def initialize
+          @items_in_collection_with_size_method = CollectionWithSizeMethod.new
+          @items_in_collection_with_length_method = CollectionWithLengthMethod.new
+        end
+
+        def add_to_collection_with_size_method(item)
+          @items_in_collection_with_size_method.push(item)
+        end
+
+        def add_to_collection_with_length_method(item)
+          @items_in_collection_with_length_method.push(item)
+        end
+        
+        def items_for(arg)
+          return [1, 2, 3] if arg == 'a'
+          [1]
+        end
+        
+        def items
+          @items_in_collection_with_size_method
+        end
+      end
+
+      class ClassWithUnqueriedPredicate
+        attr_accessor :foo
+        def initialize(foo)
+          @foo = foo
+        end
+      end
+    end
+  end
+end

data/lib/micronaut.rb

@@ -0,0 +1,40 @@
+require 'micronaut/mocking/with_absolutely_nothing'
+require 'micronaut/matchers'
+require 'micronaut/expectations'
+require 'micronaut/world'
+require 'micronaut/configuration'
+require 'micronaut/runner'
+require 'micronaut/example'
+require 'micronaut/behaviour'
+require 'micronaut/kernel_extensions'
+require 'micronaut/formatters'
+
+module Micronaut
+  file = if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
+           File.expand_path __FILE__
+         elsif  __FILE__ =~ /^[^\.]/ then # assume both relative
+           require 'pathname'
+           pwd = Pathname.new(Dir.pwd)
+           path_name = Pathname.new(File.expand_path(__FILE__))
+           path_name = File.join(".", path_name.relative_path_from(pwd)) unless path_name.relative?
+           path_name.to_s
+         else                             # assume both are expanded
+           __FILE__
+         end
+
+  # './lib' in project dir, or '/usr/local/blahblah' if installed
+  InstallDirectory = File.expand_path(File.dirname(File.dirname(file)) + "/lib")
+
+  def self.configuration
+    @configuration ||= Micronaut::Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+  
+  def self.world
+    @world ||= Micronaut::World.new
+  end
+  
+end

data/lib/micronaut/behaviour.rb

@@ -0,0 +1,217 @@
+module Micronaut
+  class Behaviour
+    include Micronaut::Matchers 
+    
+    attr_accessor :running_example, :reporter
+    
+    def self.inherited(klass)
+      super
+      Micronaut.configuration.autorun!
+      Micronaut.world.behaviours << klass
+    end
+    
+    def self.extended_modules #:nodoc:
+      ancestors = class << self; ancestors end
+      ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+    end
+
+    def self.befores
+      @_befores ||= { :all => [], :each => [] }
+    end
+
+    def self.before_eachs
+      befores[:each]
+    end
+
+    def self.before_alls
+      befores[:all]
+    end
+
+    def self.before(type=:each, &block)
+      befores[type] << block
+    end
+
+    def self.afters
+      @_afters ||= { :all => [], :each => [] }
+    end
+
+    def self.after_eachs
+      afters[:each]
+    end
+
+    def self.after_alls
+      afters[:all]
+    end
+
+    def self.after(type=:each, &block)
+      afters[type] << block
+    end
+
+    def self.example(desc=nil, options={}, &block)
+      examples << Micronaut::Example.new(self, desc, options.update(:caller => caller[0]), block)
+    end
+        
+    def self.alias_example_to(new_alias, extra_options={})
+      new_alias = <<-END_RUBY
+                    def self.#{new_alias}(desc=nil, options={}, &block)
+                      updated_options = options.update(:caller => caller[0])
+                      updated_options.update(#{extra_options.inspect})
+                      block = nil if updated_options[:pending] == true || updated_options[:disabled] == true
+                      examples << Micronaut::Example.new(self, desc, updated_options, block)
+                    end
+                  END_RUBY
+      module_eval(new_alias, __FILE__, __LINE__)
+    end
+
+    alias_example_to :it
+    alias_example_to :focused, :focused => true
+    alias_example_to :disabled, :disabled => true
+    alias_example_to :pending, :pending => true
+    
+    def self.examples
+      @_examples ||= []
+    end
+    
+    def self.examples_to_run
+      @_examples_to_run ||= []
+    end
+
+    def self.set_it_up(*args)
+      @metadata = { }
+      extra_metadata = args.last.is_a?(Hash) ? args.pop : {}
+      extra_metadata.delete(:behaviour) # Remove it when present to prevent it clobbering the one we setup
+      @metadata.update(self.superclass.metadata) 
+      @metadata[:behaviour] = {}
+      @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)
+      @metadata[:behaviour][:caller] = extra_metadata.delete(:caller) || caller(1)
+      @metadata[:behaviour][:file_path] = extra_metadata.delete(:file_path) || @metadata[:behaviour][:caller][4].split(":")[0].strip
+      @metadata[:behaviour][:line_number] = extra_metadata.delete(:line_number) || @metadata[:behaviour][:caller][4].split(":")[1].to_i
+      
+      @metadata.update(extra_metadata)
+      
+      Micronaut.configuration.find_modules(self).each do |include_or_extend, mod, opts|                                                                                                                                                                               
+        if include_or_extend == :extend
+          Micronaut.configuration.trace { "Extending module #{mod} on #{self}" }
+          send(:extend, mod) unless extended_modules.include?(mod)                                                                                                                                                                                                    
+        else
+          Micronaut.configuration.trace { "Including module #{mod} on #{self}" }
+          send(:include, mod) unless included_modules.include?(mod)
+        end
+      end
+    end
+
+    def self.metadata
+      @metadata ||= { :behaviour => {} }
+    end
+
+    def self.name(friendly=true)
+      friendly ? metadata[:behaviour][:name] : super()
+    end
+
+    def self.describes
+      metadata[:behaviour][:describes]
+    end
+
+    def self.description
+      metadata[:behaviour][:description]
+    end
+    
+    def self.file_path
+      metadata[:behaviour][:file_path]
+    end
+   
+    def self.describe(*args, &behaviour_block)
+      raise(ArgumentError, "No arguments given.  You must a least supply a type or description") if args.empty? 
+      raise(ArgumentError, "You must supply a block when calling describe") if behaviour_block.nil?
+      
+      subclass('NestedLevel') do
+        args << {} unless args.last.is_a?(Hash)
+        args.last.update(:behaviour_block => behaviour_block)
+        set_it_up(*args)
+        module_eval(&behaviour_block)
+      end
+    end
+
+    def self.ancestors(superclass_last=false)
+      classes = []
+      current_class = self
+
+      while current_class < Micronaut::Behaviour
+        superclass_last ? classes << current_class : classes.unshift(current_class)
+        current_class = current_class.superclass
+      end
+      
+      classes
+    end
+    
+    def self.before_ancestors
+      @_before_ancestors ||= ancestors 
+    end
+    
+    def self.after_ancestors
+      @_after_ancestors ||= ancestors(true)
+    end
+
+    def self.before_all_ivars
+      @before_all_ivars ||= {}
+    end
+
+    def self.eval_before_alls(running_behaviour)
+      superclass.before_all_ivars.each { |ivar, val| running_behaviour.instance_variable_set(ivar, val) }
+      Micronaut.configuration.find_before_or_after(:before, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
+      
+      before_alls.each { |blk| running_behaviour.instance_eval(&blk) }
+      running_behaviour.instance_variables.each { |ivar| before_all_ivars[ivar] = running_behaviour.instance_variable_get(ivar) }
+    end
+        
+    def self.eval_before_eachs(running_behaviour)
+      Micronaut.configuration.find_before_or_after(:before, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
+      before_ancestors.each { |ancestor| ancestor.before_eachs.each { |blk| running_behaviour.instance_eval(&blk) } }
+    end
+
+    def self.eval_after_alls(running_behaviour)
+      after_alls.each { |blk| running_behaviour.instance_eval(&blk) }
+      Micronaut.configuration.find_before_or_after(:after, :all, self).each { |blk| running_behaviour.instance_eval(&blk) }
+      before_all_ivars.keys.each { |ivar| before_all_ivars[ivar] = running_behaviour.instance_variable_get(ivar) }
+    end
+
+    def self.eval_after_eachs(running_behaviour)
+      after_ancestors.each { |ancestor| ancestor.after_eachs.each { |blk| running_behaviour.instance_eval(&blk) } }
+      Micronaut.configuration.find_before_or_after(:after, :each, self).each { |blk| running_behaviour.instance_eval(&blk) }
+    end
+
+    def self.run(reporter)
+      behaviour_instance = new
+      reporter.add_behaviour(self)
+      eval_before_alls(behaviour_instance)
+      success = run_examples(behaviour_instance, reporter)
+      eval_after_alls(behaviour_instance)
+      
+      success
+    end
+    
+    # Runs all examples, returning true only if all of them pass
+    def self.run_examples(behaviour_instance, reporter)
+      examples_to_run.map { |ex| ex.run(behaviour_instance) }.all?
+    end
+
+    def self.subclass(base_name, &body) # :nodoc:
+      @_sub_class_count ||= 0
+      @_sub_class_count += 1
+      klass = Class.new(self)
+      class_name = "#{base_name}_#{@_sub_class_count}"
+      const_set(class_name, klass)
+      klass.instance_eval(&body)
+      klass
+    end
+
+    def self.to_s
+      self == Micronaut::Behaviour ? 'Micronaut::Behaviour' : name
+    end
+   
+  end
+end

data/lib/micronaut/configuration.rb

@@ -0,0 +1,162 @@
+module Micronaut
+
+  class Configuration
+    # Regex patterns to scrub backtrace with
+    attr_reader :backtrace_clean_patterns
+    
+    # All of the defined before/after blocks setup in the configuration
+    attr_reader :before_and_afters
+    
+    # Allows you to control what examples are ran by filtering 
+    attr_reader :filter
+    
+    # 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.  Normally this is what you want -
+    # when using focused examples for instance.  Defaults to true
+    attr_accessor :run_all_when_everything_filtered
+
+    # Enable profiling of example run - defaults to false
+    attr_accessor :profile_examples
+    
+    # Enable verbose interal logging of the framework - defaults to false
+    attr_accessor :trace
+    
+    attr_reader :mock_framework
+    
+    def initialize
+      @backtrace_clean_patterns = [/\/lib\/ruby\//, /bin\/rcov:/, /vendor\/rails/, /bin\/micronaut/, /#{::Micronaut::InstallDirectory}/]
+      @run_all_when_everything_filtered = true
+      @trace = false
+      @profile_examples = false
+      @color_enabled = false
+      @before_and_afters = { :before => { :each => [], :all => [] }, :after => { :each => [], :all => [] } }
+      @include_or_extend_modules = []
+      @formatter_to_use = Micronaut::Formatters::ProgressFormatter
+      @filter = nil
+      mock_with nil unless @mock_framework_established
+    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)
+      @backtrace_clean_patterns.any? { |regex| line =~ regex }
+    end
+    
+    def mock_with(make_a_mockery_with=nil)
+      @mock_framework_established = true
+      @mock_framework = make_a_mockery_with
+      mock_framework_class = case make_a_mockery_with.to_s
+                             when /mocha/i
+                               require 'micronaut/mocking/with_mocha'
+                               Micronaut::Mocking::WithMocha
+                             when /rr/i
+                               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_class)
+    end
+    
+    def autorun!
+      Micronaut::Runner.autorun
+    end
+       
+    # Turn ANSI on with 'true', or off with 'false'
+    def color_enabled=(on_or_off)
+      @color_enabled = on_or_off
+    end
+    
+    # Output with ANSI color enabled? Defaults to false
+    def color_enabled?
+      @color_enabled
+    end
+    
+    def filter_run(options={})
+      @filter = options
+    end
+    
+    def run_all_when_everything_filtered?
+      @run_all_when_everything_filtered
+    end
+    
+    def formatter=(formatter_to_use)
+      @formatter_to_use = case formatter_to_use.to_s
+                          when 'documentation' then Micronaut::Formatters::DocumentationFormatter
+                          when 'progress' then Micronaut::Formatters::ProgressFormatter
+                          else raise(ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?.")
+                          end
+    end
+    
+    # The formatter all output should use.  Defaults to the progress formatter
+    def formatter
+      @formatter ||= @formatter_to_use.new
+    end
+        
+    # Where does output go? For now $stdout
+    def output
+      $stdout
+    end
+    
+    # Output some string for debugging/tracing assistance if trace is enabled
+    # The trace string should be sent as a block, which means it will only be interpolated if trace is actually enabled
+    # We allow an override here so that trace can be set at lower levels (such as the describe or example level)
+    def trace(override = false)
+      raise(ArgumentError, "Must yield a block with your string to trace.") unless block_given?
+      return unless trace? || override
+      puts("[TRACE] #{yield}")
+    end
+
+    def puts(msg)
+      output.puts(msg)    
+    end
+    
+    # If true, Micronaut will provide detailed trace output of its self as it runs.
+    # Can be turned on at the global (configuration) level or at the individual behaviour (describe) level.
+    def trace?
+      @trace == true
+    end
+
+    def include(mod, options={})
+      include_or_extend_modules << [:include, mod, options]
+    end
+    
+    def extend(mod, options={})
+      include_or_extend_modules << [:extend, mod, options]
+    end
+    
+    def find_modules(group)
+      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 before(each_or_all=:each, options={}, &block)
+      before_and_afters[:before][each_or_all] << [options, block]
+    end
+    
+    def after(each_or_all=:each, options={}, &block)
+      before_and_afters[:after][each_or_all] << [options, block]
+    end
+    
+    def find_before_or_after(desired_before_or_after, desired_each_or_all, group)
+      before_and_afters[desired_before_or_after][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 { |options, block| block }
+    end
+    
+  end
+  
+end