rconditions 0.1.1 → 0.2.0

data/README

@@ -7,21 +7,7 @@ will throw an exception. The exception will include auto-generated modules
 that give information which predicate methods passed or failed in the bang
 method's execution.
 
-== A Simple Example
-
-  require "rconditions"
-  
-  begin 
-    [1,2].empty!
-  rescue Array::NotEmptyError => e
-    p e    
-  end
-  
-  # => #<Exception: Array::NotEmptyError>
-
-The raised exception includes a module defined on the class where the method is defined. The module's name is derived from the predicate method's name.
-
-== A More Complicated Example
+== Example
 
   require "rconditions"
   
@@ -71,32 +57,33 @@ The raised exception includes a module defined on the class where the method is
   # => #<Exception: User::NotAdminError, Posting::SpamError,
   #      Posting::NotVisibleError, User::NotCanViewPostingError>  
 
-As you can see, the exception includes modules for each of the evaluated 
-predicate methods: <tt>User#can_view_posting!(posting)</tt> in the context
-above called <tt>User#can_view_posting?(posting)</tt>, which called 
-<tt>User#admin?</tt> and <tt>Posting#can_view_posting?</tt>, which called
+As you can see, the raised exception includes modules for each of the
+evaluated predicate methods: <tt>User#can_view_posting!(posting)</tt> in the
+context above called <tt>User#can_view_posting?(posting)</tt>, which called 
+<tt>User#admin?</tt> and <tt>Posting#visible?</tt>, which called
 <tt>Posting#spam?</tt>.
     
 The results were
 
-* <tt>User#admin?                # => false</tt>
-* <tt>Posting#spam?              # => true</tt>
-* <tt>Posting#can_view_posting?  # => false</tt>
-* <tt>User#can_view_posting?     # => false</tt>
+* <tt>User#admin?               # => false</tt>
+* <tt>Posting#spam?             # => true</tt>
+* <tt>Posting#visible?          # => false</tt>
+* <tt>User#can_view_posting?    # => false</tt>
 
-so the included exception modules are
+The names of the included exception modules are derived from the names of the
+predicate methods:
 
 * <tt>User::NotAdminError</tt>
 * <tt>Posting::SpamError</tt>
-* <tt>Posting::NotCanViewPostingError</tt> 
+* <tt>Posting::NotVisibleError</tt> 
 * <tt>User::NotCanViewPostingError</tt>
 
 == Performance
 
 As almost all predicate methods are extended by default, RConditions carries
 a performance penalty which varies with the number of calls to predicate
-methods. A simple test setup using mongrel/rails was slowed down by 10-20%
-by adding <tt>require "rconditions"</tt> to the bottom of its 
+methods. A simple test setup using mongrel/rails was slowed down by more than
+30% by adding <tt>require "rconditions"</tt> to the bottom of its 
 <tt>enviroment.rb</tt>.
 
 The performance penalty can be avoided by applying RConditions only to new
@@ -104,12 +91,20 @@ methods, that is, methods defined after <tt>require "rconditions"</tt>. To
 achieve this, set <tt>RCONDITIONS_ONLY_FOR_NEW_METHODS = true</tt> before
 the require call. Our test setup had no measurable slowdown afterwards.
 
+== Supported Ruby Versions
+
+The test suite of RConditions passes for
+* ruby 1.8.6
+* ruby 1.9.0 (tested with revision 13680)
+
+If you use another ruby version, please check whether the tests pass.
+
 == Limitations
 
-* RConditions currently only support predicate methods starting with a letter
-  and containing only word characters except the question mark at the end.
-* RConditions does not support singleton methods. These includes all class
-  methods.
+* RConditions only processes predicate methods starting with a letter and
+  containing only word characters except the question mark at the end.
+* <tt>Kernel#block_given?</tt> is not processed.
+* Singleton methods are not processed. These includes all class methods.
 
 == License
 

data/lib/rconditions.rb

@@ -12,6 +12,7 @@ module RConditions
     def extend_predicate_method_and_define_bang_method(mod, id)
       return if Thread.current[:rconditions_processing_predicate_method]
       return if (predicate_method = id.to_s) !~ PREDICATE_METHOD
+      return if mod == Kernel && predicate_method == 'block_given?'
       
       begin
         Thread.current[:rconditions_processing_predicate_method] = true
@@ -29,18 +30,24 @@ module RConditions
     # requiring RConditions.
     def extend_predicate_methods_and_define_bang_methods
       ObjectSpace.each_object(Module) do |mod|
-        mod.instance_methods(false).each do |id|
+        (mod.instance_methods(false) + mod.private_instance_methods(false)).each do |id|
           RConditions.extend_predicate_method_and_define_bang_method(mod, id) 
         end
       end
     end  
-      
-    def exception_modules #:nodoc:
-      Thread.current[:rconditions_exception_modules]
+    
+    def collect_exception_modules #:nodoc:
+      mods = Thread.current[:rconditions_exception_modules] = []
+      yield
+      mods
+    ensure 
+      Thread.current[:rconditions_exception_modules] = nil
     end
     
-    def exception_modules=(value) #:nodoc:
-      Thread.current[:rconditions_exception_modules] = value
+    def add_exception_module(mod) #:nodoc:
+      if mods = Thread.current[:rconditions_exception_modules]
+        mods << mod
+      end
     end
     
     private
@@ -57,7 +64,6 @@ module RConditions
         
         time = Time.now
         predicate_method_without_rconditions = "#{predicate_method_without_questionmark}_rconditions_#{mod.object_id}_#{time.to_i}_#{time.usec}"
-        original_visibility = visibility(mod, predicate_method)
 
         mod.class_eval <<-EOS, __FILE__, __LINE__ + 1
           alias_method :#{predicate_method_without_rconditions}, :#{predicate_method}
@@ -65,10 +71,10 @@ module RConditions
 
           def #{predicate_method}(*args, &block)
             result = #{predicate_method_without_rconditions}(*args, &block)
-            RConditions.exception_modules << (result ? #{positive_module} : #{negative_module}) if RConditions.exception_modules
+            ::RConditions.add_exception_module(result ? #{positive_module} : #{negative_module})
             result
           end
-          #{original_visibility} :#{predicate_method}
+          #{visibility(mod, predicate_method)} :#{predicate_method}
         EOS
       end
       
@@ -76,21 +82,15 @@ module RConditions
         bang_method = predicate_method[0...-1] + '!'
         return if mod.method_defined?(bang_method) || mod.private_method_defined?(bang_method)
 
-        visibility = visibility(mod, predicate_method)
-
         mod.class_eval <<-EOS, __FILE__, __LINE__ + 1
           def #{bang_method}(*args, &block)
-            RConditions.exception_modules = []
-            result = #{predicate_method}(*args, &block)
-            return result if result
-
-            e = Exception.new(RConditions.exception_modules.map { |m| m.name }.join(', '))
-            RConditions.exception_modules.each { |m| e.extend(m) }
-            raise e
-          ensure
-            RConditions.exception_modules = nil
+            mods = ::RConditions.collect_exception_modules do
+              result = #{predicate_method}(*args, &block)
+              return result if result
+            end
+            raise Exception.new(mods.join(', ')).extend(*mods)
           end
-          #{visibility} :#{bang_method}
+          #{visibility(mod, predicate_method)} :#{bang_method}
         EOS
       end
       
@@ -99,10 +99,13 @@ module RConditions
       end
       
       def visibility(mod, id)
-        case id 
-        when *mod.public_instance_methods(false): 'public'
-        when *mod.protected_instance_methods(false): 'protected'
-        when *mod.private_instance_methods(false): 'private'
+        case id
+        when *mod.public_instance_methods(false)
+          'public'
+        when *mod.protected_instance_methods(false)
+          'protected'
+        when *mod.private_instance_methods(false)
+          'private'
         end
       end  
   end
@@ -123,7 +126,7 @@ class Module #:nodoc:
   private :method_added_without_rconditions
   
   def method_added(id) #:nodoc:
-    RConditions.extend_predicate_method_and_define_bang_method(self, id)
+    ::RConditions.extend_predicate_method_and_define_bang_method(self, id)
     method_added_without_rconditions(id)
   end
-end
+end

data/test/rconditions_test.rb

@@ -1,6 +1,14 @@
 require 'test/unit'
 require 'rconditions'
 
+class Array
+  # This method is used in the tests below to convert Arrays of Symbols to
+  # Arrays of Strings, so that the tests can be run with Ruby 1.9 as well.
+  def map_to_s
+    map {|each| each.to_s}
+  end
+end
+
 class RConditionsTest < Test::Unit::TestCase
 
   class Foo
@@ -16,7 +24,18 @@ class RConditionsTest < Test::Unit::TestCase
   end
 
   def test_defines_bang_method_on_predicate_methods_defined_before_r_conditions_was_required
-    assert [].class.method_defined?(:empty!)
+    assert Array.method_defined?(:empty!)
+  end
+
+  def test_defines_bang_method_on_private_predicate_methods_defined_before_r_conditions_was_required
+    assert Kernel.private_method_defined?(:autoload!)
+  end
+  
+  # we cannot apply RConditions to Kernel#block_given?, since the
+  # implementation would require Binding.of_caller, which is broken since
+  # Ruby 1.8.5. 
+  def test_defines_no_bang_method_for_block_given
+    assert !Kernel.private_method_defined?(:block_given!)
   end
   
   def test_defines_bang_method_on_predicate_methods_defined_after_r_conditions_was_required
@@ -24,13 +43,13 @@ class RConditionsTest < Test::Unit::TestCase
   end
 
   def test_does_not_define_methods_for_non_predicate_methods
-    foo_methods_with_new_method = Foo.new.methods + ['new_method']
+    foo_methods_with_new_method = Foo.new.methods.map_to_s + ['new_method']
     eval "class Foo;def new_method; end; end"
-    assert_equal foo_methods_with_new_method.sort, Foo.new.methods.sort
+    assert_equal foo_methods_with_new_method.sort, Foo.new.methods.map_to_s.sort
   end  
 
   def test_bang_method_returns_true_if_predicate_method_returns_true
-    assert Foo.new.d!
+    assert_equal true, Foo.new.d!
   end
   
   def test_bang_method_passes_predicate_method_result
@@ -82,9 +101,9 @@ class RConditionsTest < Test::Unit::TestCase
   end
 
   def test_no_visible_methods_added_except_bang_method
-    foo_methods_with_predicate_method = Foo.new.methods + ['new_predicate_method?']
+    foo_methods_with_predicate_method = Foo.new.methods.map_to_s + ['new_predicate_method?']
     eval "class Foo;def new_predicate_method?; false; end; end"
-    assert_equal ['new_predicate_method!'], Foo.new.methods - foo_methods_with_predicate_method
+    assert_equal ['new_predicate_method!'], Foo.new.methods.map_to_s - foo_methods_with_predicate_method
   end
 
   def test_no_bang_method_will_be_overridden
@@ -97,7 +116,7 @@ class RConditionsTest < Test::Unit::TestCase
   def test_no_bang_method_will_be_overridden_even_if_it_is_private
     eval "class Foo;private;def private_do_not_override_me!; 'private'; end; end"
     eval "class Foo;def private_do_not_override_me?; true; end; end"
-    assert_equal 'private', Foo.new.__send__(:private_do_not_override_me!)
+    assert_equal 'private', Foo.new.instance_eval { private_do_not_override_me! }
   end
   
   def test_no_bang_method_will_be_overridden_even_if_it_is_in_a_superclas
@@ -128,8 +147,8 @@ class RConditionsTest < Test::Unit::TestCase
   
   def test_does_work_for_modules
     # any? is defined in the module Enumerable and included in Array
-    assert Enumerable.instance_methods(false).include?('any?')
-    assert !Array.instance_methods(false).include?('any?')
+    assert Enumerable.instance_methods(false).map_to_s.include?('any?')
+    assert !Array.instance_methods(false).map_to_s.include?('any?')
     assert Array.ancestors.include?(Enumerable)
 
     e = exception_raised_by { [].any! } 
@@ -140,7 +159,18 @@ class RConditionsTest < Test::Unit::TestCase
   def test_does_work_for_alias_method
     eval <<-EOS
       class Foo
-        alias_method :a_alias?, :a?
+        alias_method :a_alias_method?, :a?
+      end
+    EOS
+    e = exception_raised_by { Foo.new.a_alias_method! }
+    assert e.kind_of?(Foo::NotAAliasMethodError)
+    assert e.kind_of?(Foo::NotAError)
+  end
+
+  def test_does_work_for_alias
+    eval <<-EOS
+      class Foo
+        alias a_alias? a?
       end
     EOS
     e = exception_raised_by { Foo.new.a_alias! }
@@ -202,7 +232,7 @@ class RConditionsTest < Test::Unit::TestCase
         false
       end
     EOS
-    Foo.send(:include, m)
+    Foo.instance_eval { include m }
     e = exception_raised_by { Foo.new.activated! }
     assert e.kind_of?(m.const_get(:NotActivatedError))
     self.class.const_set(:NowANamedModule, m)
@@ -241,13 +271,13 @@ class RConditionsTest < Test::Unit::TestCase
       end
     EOS
     
-    assert Foo.public_instance_methods(false).include?('public_p?')
-    assert Foo.protected_instance_methods(false).include?('protected_p?')
-    assert Foo.private_instance_methods(false).include?('private_p?')
+    assert Foo.public_instance_methods(false).map_to_s.include?('public_p?')
+    assert Foo.protected_instance_methods(false).map_to_s.include?('protected_p?')
+    assert Foo.private_instance_methods(false).map_to_s.include?('private_p?')
     
-    assert Foo.public_instance_methods(false).include?('public_p!')
-    assert Foo.protected_instance_methods(false).include?('protected_p!')
-    assert Foo.private_instance_methods(false).include?('private_p!')
+    assert Foo.public_instance_methods(false).map_to_s.include?('public_p!')
+    assert Foo.protected_instance_methods(false).map_to_s.include?('protected_p!')
+    assert Foo.private_instance_methods(false).map_to_s.include?('private_p!')
   end
   
   private

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rconditions
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-09-27 00:00:00 +02:00
+  version: 0.2.0
+date: 2007-10-14 00:00:00 +02:00
 summary: RConditions generates a bang method (for example, Array#empty!) for each predicate method (for example, Array#empty?). The bang method will return true if the predicate method returns true, otherwise it will throw an exception. The exception will include auto-generated modules that give information on predicate methods passed or failed in the bang method's execution.
 require_paths: 
 - lib