Ruby 1.9 compat: compatibility wrapper for new Module#const_defined? behavior

activesupport/lib/active_support/dependencies.rb

@@ -120,15 +120,26 @@ def qualified_const_defined?(path)
     # We can't use defined? because it will invoke const_missing for the parent
     # of the name we are checking.
     names.inject(Object) do |mod, name|
-      return false unless mod.const_defined? name
+      return false unless uninherited_const_defined?(mod, name)
       mod.const_get name
     end
     return true
   end
 
+  if Module.method(:const_defined?).arity == 1
+    # Does this module define this constant?
+    # Wrapper to accomodate changing Module#const_defined? in Ruby 1.9
+    def uninherited_const_defined?(mod, const)
+      mod.const_defined?(const)
+    end
+  else
+    def uninherited_const_defined?(mod, const) #:nodoc:
+      mod.const_defined?(const, false)
+    end
+  end
+
   # Given +path+, a filesystem path to a ruby file, return an array of constant
   # paths which would cause Dependencies to attempt to load this file.
-  #
   def loadable_constants_for_path(path, bases = load_paths)
     path = $1 if path =~ /\A(.*)\.rb\Z/
     expanded_path = File.expand_path(path)
@@ -237,7 +248,7 @@ def load_missing_constant(from_mod, const_name)
       raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
     end
 
-    raise ArgumentError, "#{from_mod} is not missing constant #{const_name}!" if from_mod.const_defined?(const_name)
+    raise ArgumentError, "#{from_mod} is not missing constant #{const_name}!" if uninherited_const_defined?(from_mod, const_name)
 
     qualified_name = qualified_name_for from_mod, const_name
     path_suffix = qualified_name.underscore
@@ -246,12 +257,12 @@ def load_missing_constant(from_mod, const_name)
     file_path = search_for_file(path_suffix)
     if file_path && ! loaded.include?(File.expand_path(file_path)) # We found a matching file to load
       require_or_load file_path
-      raise LoadError, "Expected #{file_path} to define #{qualified_name}" unless from_mod.const_defined?(const_name)
+      raise LoadError, "Expected #{file_path} to define #{qualified_name}" unless uninherited_const_defined?(from_mod, const_name)
       return from_mod.const_get(const_name)
     elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
       return mod
     elsif (parent = from_mod.parent) && parent != from_mod &&
-          ! from_mod.parents.any? { |p| p.const_defined?(const_name) }
+          ! from_mod.parents.any? { |p| uninherited_const_defined?(p, const_name) }
       # If our parents do not have a constant named +const_name+ then we are free
       # to attempt to load upwards. If they do have such a constant, then this
       # const_missing must be due to from_mod::const_name, which should not

activesupport/test/inflector_test.rb

@@ -120,14 +120,8 @@ def test_constantize
     assert_raises(NameError) { Inflector.constantize("InvalidClass\n") }
   end
 
-  if RUBY_VERSION < '1.9.0'
-    def test_constantize_does_lexical_lookup
-      assert_raises(NameError) { Inflector.constantize("Ace::Base::InflectorTest") }
-    end
-  else
-    def test_constantize_does_dynamic_lookup
-      assert_equal self.class, Inflector.constantize("Ace::Base::InflectorTest")
-    end
+  def test_constantize_does_lexical_lookup
+    assert_raises(NameError) { Inflector.constantize("Ace::Base::InflectorTest") }
   end
 
   def test_ordinal