rconditions 0.3.1 → 0.4.0

data/README

@@ -114,7 +114,7 @@ If you use another ruby version, please check whether the tests pass.
 * 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.
+* Singleton methods on classes and modules are not processed.
 
 == License
 

data/lib/rconditions.rb

@@ -6,7 +6,8 @@ module RConditions
     # Extends a given predicate method and defines a bang method for it. You
     # should never call this method yourself, it is called either from 
     # RConditions#extend_predicate_methods_and_define_bang_methods, or from 
-    # <tt>Module#method_added</tt> which is extended by RConditions.
+    # <tt>Module#method_added</tt> or <tt>Object#singleton_method_added</tt>
+    # which are extended by RConditions.
     # * <tt>mod</tt> -- the module on which the method is defined.
     # * <tt>id</tt> -- the name of the method.
     def extend_predicate_method_and_define_bang_method(mod, id)
@@ -58,9 +59,9 @@ module RConditions
         predicate_method_without_questionmark = predicate_method[0...-1]
 
         positive_module = camelize("#{predicate_method_without_questionmark}_error")
-        mod.const_set(positive_module, Module.new) unless mod.const_defined?(positive_module)
+        mod.const_set(positive_module, Module.new) unless mod.constants.include?(positive_module)
         negative_module = camelize("not_#{predicate_method_without_questionmark}_error")
-        mod.const_set(negative_module, Module.new) unless mod.const_defined?(negative_module)
+        mod.const_set(negative_module, Module.new) unless mod.constants.include?(negative_module)
 
         time = Time.now
         predicate_method_without_rconditions = "#{predicate_method_without_questionmark}_rconditions_#{mod.object_id.abs}_#{time.to_i}_#{time.usec}"
@@ -134,3 +135,12 @@ class Module #:nodoc:
     method_added_without_rconditions(id)
   end
 end
+
+class Object #:nodoc:
+  alias_method :singleton_method_added_without_rconditions, :singleton_method_added
+  private :singleton_method_added_without_rconditions
+  def singleton_method_added(id)
+    ::RConditions.extend_predicate_method_and_define_bang_method(class<<self; self; end, id) unless self.class <= Module
+    singleton_method_added_without_rconditions(id)
+  end
+end

data/test/rconditions_test.rb

@@ -239,14 +239,6 @@ class RConditionsTest < Test::Unit::TestCase
     assert e.kind_of?(NowANamedModule::NotActivatedError)
   end
   
-  def test_does_not_work_for_singleton_methods
-    f = Foo.new
-    class << f
-      def x?; b?; end
-    end
-    assert !f.respond_to?(:x!)
-  end
-  
   def test_does_not_break_module_functions
     eval <<-EOS
       module WithModuleFunctions
@@ -267,6 +259,15 @@ class RConditionsTest < Test::Unit::TestCase
     assert_equal 'module_function_2?', WithModuleFunctions.module_function_2?
   end
 
+  def test_does_not_support_class_methods
+    eval <<-EOS
+      class Foo
+        def self.moppel?;end
+      end
+    EOS
+    assert !Foo.respond_to?(:moppel!)
+  end
+
   def test_module_functions_fix_ignores_no_method_error_from_non_module_function
     eval <<-EOS
       module ModuleWithNoMethodError
@@ -316,6 +317,42 @@ class RConditionsTest < Test::Unit::TestCase
     assert Foo.private_instance_methods(false).map_to_s.include?('private_p!')
   end
   
+  def test_exception_module_is_reused_if_defined_in_superclass
+    eval <<-EOS
+      class SuperClass
+        def x?
+          true
+        end
+      end
+      class SubClass < SuperClass
+        def x?
+        end
+      end
+    EOS
+    assert SuperClass::NotXError == SubClass::NotXError
+    assert SuperClass::XError == SubClass::XError
+  end
+  
+  def test_does_work_for_singleton_methods
+    f = Foo.new
+    class << f
+      def x?; b?; end
+    end
+    assert f.respond_to?(:x!)
+    e = exception_raised_by { f.x! }
+    assert e.kind_of?((class<<f; self; end).const_get(:NotXError))
+    assert e.kind_of?(Foo::NotBError)
+  end
+  
+  def test_does_work_for_overwritten_singleton_methods
+    f = Foo.new
+    class << f
+      def a?; false; end
+    end
+    e = exception_raised_by { f.a! }
+    assert e.kind_of?(Foo::NotAError)
+  end
+  
   private
 
     def exception_raised_by(&block)

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.4
 specification_version: 1
 name: rconditions
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-11-12 00:00:00 +01:00
+  version: 0.4.0
+date: 2007-11-13 00:00:00 +01:00
 summary: Generates a bang method for each predicate method.
 require_paths: 
 - lib