spicycode-micronaut 0.0.2 → 0.0.3

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

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+module Micronaut
+  module Matchers
+    describe SimpleMatcher do
+      it "should pass match arg to block" do
+        actual = nil
+        matcher = simple_matcher("message") do |given| actual = given end
+        matcher.matches?("foo")
+        actual.should == "foo"
+      end
+      
+      it "should provide a stock failure message" do
+        matcher = simple_matcher("thing") do end
+        matcher.matches?("other")
+        matcher.failure_message.should =~ /expected \"thing\" but got \"other\"/
+      end
+      
+      it "should provide a stock negative failure message" do
+        matcher = simple_matcher("thing") do end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/
+      end
+      
+      it "should provide the given description" do
+        matcher = simple_matcher("thing") do end
+        matcher.description.should =="thing"
+      end
+      
+      it "should fail if a wrapped 'should' fails" do
+        matcher = simple_matcher("should fail") do
+          2.should == 3
+        end
+        lambda do
+          matcher.matches?("anything").should be_true
+        end.should fail_with(/expected: 3/)
+      end
+    end
+    
+    describe "with arity of 2" do
+      it "should provide the matcher so you can access its messages" do
+        provided_matcher = nil
+        matcher = simple_matcher("thing") do |given, matcher|
+          provided_matcher = matcher
+        end
+        matcher.matches?("anything")
+        provided_matcher.should equal(matcher)
+      end
+      
+      it "should support a custom failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.failure_message.should == "custom message"
+      end
+
+      it "should complain when asked for a failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom negative failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.negative_failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should == "custom message"
+      end
+      
+      it "should complain when asked for a negative failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom description" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.description = "custom message"
+        end
+        matcher.matches?("description")
+        matcher.description.should == "custom message"
+      end
+
+      it "should tell you no description was provided when it doesn't receive one" do
+        matcher = simple_matcher do end
+        matcher.description.should =~ /No description provided/
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,96 @@
+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") }
+    
+        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
+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/autotest/micronaut.rb

@@ -7,10 +7,10 @@ Autotest.add_hook :initialize do |at|
   at.add_mapping(%r%^examples/.*_example.rb$%) { |filename, _| 
     filename 
   }
-  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| 
-    ["examples/#{m[1]}_example.rb"]
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |filename, m| 
+    ["examples/lib/#{m[1]}_example.rb"]
   }
-  at.add_mapping(%r%^examples/(examples_helper|shared/.*)\.rb$%) { 
+  at.add_mapping(%r%^examples/(example_helper|shared/.*)\.rb$%) { 
     at.files_matching %r%^examples/.*_example\.rb$%
   }
 end
@@ -37,7 +37,12 @@ class Autotest::Micronaut < Autotest
 
   def make_test_cmd(files_to_test)
     return '' if files_to_test.empty?
-    return "#{ruby} -S #{files_to_test.keys.flatten.join(' ')}"
+    
+    examples = files_to_test.keys.flatten
+    
+    examples.map! {|f| %Q(require "#{f}")}
+
+    return "#{ruby} -e '#{examples.join("; ")}'"
   end
   
 end

data/lib/micronaut/behaviour_group.rb

@@ -0,0 +1,43 @@
+module Micronaut
+  class BehaviourGroup
+    extend Micronaut::BehaviourGroupClassMethods
+    include Micronaut::Matchers
+    include Micronaut::Mocking::WithMocha
+
+    def execute(runner)
+      result = ''
+      return result if self.class.examples.empty?
+      self.class.all_before_alls.each { |aba| instance_eval(&aba) }
+      
+      self.class.examples.each do |desc, opts, block|
+        execution_error = nil
+
+        begin
+          setup_mocks
+          self.class.befores[:each].each { |be| instance_eval(&be) }
+          if block
+            result << '.'
+            instance_eval(&block)
+          else
+            result << 'P'
+          end
+          verify_mocks
+        rescue Exception => e
+          runner.complain(self, e)
+          execution_error ||= e
+        ensure
+          teardown_mocks
+        end
+        
+        begin
+          self.class.afters[:each].each { |ae| instance_eval(&ae) }
+        rescue Exception => e
+          runner.complain(self, e)
+          execution_error ||= e
+        end
+      end
+      result
+    end
+     
+  end
+end

data/lib/micronaut/behaviour_group_class_methods.rb

@@ -0,0 +1,134 @@
+module Micronaut
+  module BehaviourGroupClassMethods
+    
+    def inherited(klass)
+      super
+      Micronaut::ExampleWorld.example_groups << klass
+    end
+    
+    def befores
+      @_befores ||= { :all => [], :each => [] }
+    end
+    
+    def before_eachs
+      befores[:each]
+    end
+    
+    def before_alls
+      befores[:all]
+    end
+    
+    def before(type=:each, &block)
+      befores[type] << block
+    end
+    
+    def afters
+      @_afters ||= { :all => [], :each => [] }
+    end
+    
+    def after_eachs
+      afters[:each]
+    end
+    
+    def after_alls
+      afters[:all]
+    end
+    
+    def after(type=:each, &block)
+      afters[type] << block
+    end
+    
+    def it(desc=nil, options={}, &block)
+      examples << [desc, options, block]
+    end
+    
+    def examples
+      @_examples ||= []
+    end
+    
+    def set_it_up(name_or_const, given_description, given_options)
+      @_behaviour_group_name = name_or_const.to_s
+      @_behaviour_described_type = name_or_const.is_a?(String) ? Object : name_or_const
+      @_behaviour_group_description = given_description
+      @_behaviour_group_options =  given_options
+    end
+    
+    def name
+      @_behaviour_group_name
+    end
+    
+    def described_type
+      @_behaviour_described_type
+    end
+    
+    def description
+      @_behaviour_group_description
+    end
+    
+    def options
+      @_behaviour_group_options
+    end
+    
+    def describe(name_or_const, desc=nil, options={}, &block)
+      raise ArgumentError if block.nil? || name_or_const.nil?
+      
+      subclass('NestedLevel') do
+        set_it_up(name_or_const, desc, options)
+        
+        module_eval(&block)
+      end
+    end
+    
+    def create_example_group(name_or_const, desc=nil, options={}, &describe_block)
+      describe(name_or_const, desc, options, &describe_block)
+    end
+    
+    def each_ancestor(superclass_last=false)
+      classes = []
+      current_class = self
+      while is_example_group_class?(current_class)
+        superclass_last ? classes << current_class : classes.unshift(current_class)
+        current_class = current_class.superclass
+      end
+      
+      classes.each do |example_group|
+        yield example_group
+      end
+    end
+    
+    def is_example_group_class?(klass)
+      klass.kind_of?(Micronaut::BehaviourGroup)
+    end    
+  
+    def all_before_alls
+      _before_alls = []
+      each_ancestor do |ancestor|
+        _before_alls << ancestor.befores[:all]
+      end
+      _before_alls
+    end
+    
+    def run(runner)
+      new.execute(runner)
+    end
+    
+    def subclass(base_name, &body)
+      klass = Class.new(self)
+      class_name = "#{base_name}_#{_sub_class_count!}"
+      instance_eval do
+        const_set(class_name, klass)
+      end
+      klass.instance_eval(&body) if block_given?
+      klass
+    end
+    
+    private
+    
+    def _sub_class_count!
+      @_sub_class_count ||= 0
+      @_sub_class_count += 1
+      @_sub_class_count
+    end
+    
+  end
+end

data/lib/micronaut/example_runner.rb

@@ -26,22 +26,20 @@ module Micronaut
     end
     
     def location(e)
-      e.backtrace.find { |s|
-        s !~ /in .(assert|refute|flunk|pass|fail|raise)/
-      }.sub(/:in .*$/, '')
+      e.backtrace.find { |s| s !~ /in .(expectations|fail)/ }.sub(/:in .*$/, '')
     end
 
-    def complain(cls, method_in_question, e)
+    def complain(group, e)
       bt = Micronaut::filter_backtrace(e.backtrace).join("\n    ")
       
       e = case e.class.to_s
-          when 'Micronaut::Exceptions::ExpectationNotMetError', 'Mocha::ExpectationError' then
+          when /Micronaut::Expectations/, 'Mocha::ExpectationError' then
             @failures += 1
-            "Failure:\n#{method_in_question}(#{cls}) [#{location(e)}]:\n#{e.message}\n    #{bt}\n"
+            "Failure:\n#{group.class.name}(#{group.class}) [#{location(e)}]:\n#{e.message}\n    #{bt}\n"
           else
             puts e.to_s
             @errors += 1
-            "Error:\n#{method_in_question}(#{cls}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+            "Error:\n#{group.class.name}(#{group.class}):\n#{e.class}: #{e.message}\n    #{bt}\n"
           end
       @report << e
       e[0, 1]
@@ -90,12 +88,12 @@ module Micronaut
           @@out.print "#{example_group.name}: " if @verbose
 
           t = Time.now if @verbose
-          result = example_group.run_group_using(self)
+          result = example_group.run(self)
 
           @example_count += example_group.examples.size
           
           @@out.print "%.6fs: " % (Time.now - t) if @verbose
-          @@out.print result
+          @@out.print(result) if result
           @@out.puts if @verbose
         # end
       end

data/lib/micronaut/example_world.rb

@@ -1,13 +1,17 @@
-class Micronaut::ExampleWorld
+module Micronaut
+
+  class ExampleWorld
   
-  def self.reset
-    @@example_groups = []
-  end
+    def self.reset
+      @@example_groups = []
+    end
 
-  reset
+    reset
+  
+    def self.example_groups
+      @@example_groups
+    end
   
-  def self.example_groups
-    @@example_groups
   end
   
 end

data/lib/micronaut/expectations/differs/default.rb

@@ -12,9 +12,8 @@ module Micronaut
 
       # TODO add some rdoc
       class Default
-        def initialize(diff_type = :unified, context_lines = 3)
-          @format = diff_type
-          @context_lines = context_lines
+        def initialize(format = :unified, context_lines = 3)
+          @format, @context_lines = format, context_lines
         end
 
         # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
@@ -28,17 +27,17 @@ module Micronaut
           file_length_difference = 0
           diffs.each do |piece|
             begin
-              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @context_lines,
                                          file_length_difference)
               file_length_difference = hunk.file_length_difference      
               next unless oldhunk      
               # Hunks may overlap, which is why we need to be careful when our
               # diff includes lines of context. Otherwise, we might print
               # redundant lines.
-              if (context_lines > 0) and hunk.overlaps?(oldhunk)
+              if (@context_lines > 0) and hunk.overlaps?(oldhunk)
                 hunk.unshift(oldhunk)
               else
-                output << oldhunk.diff(format)
+                output << oldhunk.diff(@format)
               end
             ensure
               oldhunk = hunk
@@ -46,21 +45,13 @@ module Micronaut
             end
           end  
           #Handle the last remaining hunk
-          output << oldhunk.diff(format) << "\n"
+          output << oldhunk.diff(@format) << "\n"
         end  
 
         def diff_as_object(target,expected)
           diff_as_string(PP.pp(target,""), PP.pp(expected,""))
         end
 
-        protected
-        def format
-          @format
-        end
-
-        def context_lines
-          @context_lines
-        end
       end
     end
   end

data/lib/micronaut/expectations/errors.rb

@@ -0,0 +1,7 @@
+module Micronaut
+  module Expectations
+    class ExpectationNotMetError < ::StandardError
+      
+    end
+  end
+end

data/lib/micronaut/expectations/{object_extensions.rb → extensions/object.rb}

@@ -1,7 +1,8 @@
 module Micronaut
   module Expectations
-    # We add #should and #should_not to every Object (and, implicitly, every Class).
-    module ObjectExtensions
+    # rspec adds #should and #should_not to every Object (and,
+    # implicitly, every Class).
+    module ObjectExpectations
       # :call-seq:
       #   should(matcher)
       #   should == expected
@@ -58,5 +59,5 @@ module Micronaut
 end
 
 class Object
-  include Micronaut::Expectations::ObjectExtensions
-end
+  include Micronaut::Expectations::ObjectExpectations
+end

data/lib/micronaut/expectations/extensions.rb

@@ -0,0 +1,2 @@
+require 'micronaut/expectations/extensions/object'
+require 'micronaut/expectations/extensions/string_and_symbol'

data/lib/micronaut/expectations/wrap_expectation.rb

@@ -5,6 +5,11 @@ module Micronaut
     # expectation passes and false if it fails (without bubbling up
     # the failure).
     #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
     # == Examples
     #
     #   def eat_cheese(cheese)

data/lib/micronaut/expectations.rb

@@ -1,6 +1,6 @@
 require 'micronaut/matchers'
-require 'micronaut/expectations/object_extensions'
-require 'micronaut/expectations/string_and_symbol_extensions'
+require 'micronaut/expectations/errors'
+require 'micronaut/expectations/extensions'
 require 'micronaut/expectations/handler'
 require 'micronaut/expectations/wrap_expectation'
 
@@ -28,13 +28,13 @@ module Micronaut
   # it returns +false+, the spec passes and execution continues. If it returns
   # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
   #
-  # Micronaut ships with a standard set of useful matchers, and writing your own
+  # RMicronaut ships with a standard set of useful matchers, and writing your own
   # matchers is quite simple. See Micronaut::Matchers for details.
   module Expectations
     class << self
       attr_accessor :differ
 
-      # raises a Micronaut::Exceptions::ExpectationNotMetError with message
+      # raises a Micronaut::Expectations::ExpectationNotMetError with message
       #
       # When a differ has been assigned and fail_with is passed
       # <code>expected</code> and <code>target</code>, passes them
@@ -50,7 +50,7 @@ module Micronaut
             message << "\nDiff:" << self.differ.diff_as_object(target, expected)
           end
         end
-        Kernel::raise(Micronaut::Exceptions::ExpectationNotMetError.new(message))
+        Kernel::raise(Micronaut::Expectations::ExpectationNotMetError.new(message))
       end
     end
   end

data/lib/micronaut/extensions/kernel.rb

@@ -2,10 +2,8 @@ module Micronaut
   module Extensions
     module Kernel
 
-      def describe(name_or_const, desc=nil, &describe_block)
-        example_group = Micronaut::ExampleGroup.new(name_or_const, desc)
-        example_group.instance_eval(&describe_block)
-        Micronaut::ExampleWorld.example_groups << example_group
+      def describe(name_or_const, desc=nil, options={}, &describe_block)
+        Micronaut::BehaviourGroup.create_example_group(name_or_const, desc, options, &describe_block)
       end
 
     end