1 files changed, 49 insertions, 42 deletions

diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index c072a8e646..2c5950edf5 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -5,6 +5,7 @@ require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/qualified_const'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
@@ -70,14 +71,24 @@ module ActiveSupport #:nodoc:
     #
     # This is handled by walking back up the watch stack and adding the constants
     # found by child.rb to the list of original constants in parent.rb
-    class WatchStack < Hash
+    class WatchStack
+      include Enumerable
+
       # @watching is a stack of lists of constants being watched. For instance,
       # if parent.rb is autoloaded, the stack will look like [[Object]]. If parent.rb
       # then requires namespace/child.rb, the stack will look like [[Object], [Namespace]].
 
       def initialize
         @watching = []
-        super { |h,k| h[k] = [] }
+        @stack = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def each(&block)
+        @stack.each(&block)
+      end
+
+      def watching?
+        !@watching.empty?
       end
 
       # return a list of new constants found since the last call to watch_namespaces
@@ -88,20 +99,20 @@ module ActiveSupport #:nodoc:
         @watching.last.each do |namespace|
           # Retrieve the constants that were present under the namespace when watch_namespaces
           # was originally called
-          original_constants = self[namespace].last
+          original_constants = @stack[namespace].last
 
           mod = Inflector.constantize(namespace) if Dependencies.qualified_const_defined?(namespace)
           next unless mod.is_a?(Module)
 
           # Get a list of the constants that were added
-          new_constants = mod.local_constant_names - original_constants
+          new_constants = mod.local_constants - original_constants
 
           # self[namespace] returns an Array of the constants that are being evaluated
           # for that namespace. For instance, if parent.rb requires child.rb, the first
           # element of self[Object] will be an Array of the constants that were present
           # before parent.rb was required. The second element will be an Array of the
           # constants that were present before child.rb was required.
-          self[namespace].each do |namespace_constants|
+          @stack[namespace].each do |namespace_constants|
             namespace_constants.concat(new_constants)
           end
 
@@ -122,16 +133,17 @@ module ActiveSupport #:nodoc:
         namespaces.map do |namespace|
           module_name = Dependencies.to_constant_name(namespace)
           original_constants = Dependencies.qualified_const_defined?(module_name) ?
-            Inflector.constantize(module_name).local_constant_names : []
+            Inflector.constantize(module_name).local_constants : []
 
           watching << module_name
-          self[module_name] << original_constants
+          @stack[module_name] << original_constants
         end
         @watching << watching
       end
 
+      private
       def pop_modules(modules)
-        modules.each { |mod| self[mod].pop }
+        modules.each { |mod| @stack[mod].pop }
       end
     end
 
@@ -218,8 +230,8 @@ module ActiveSupport #:nodoc:
       end
 
       def load_dependency(file)
-        if Dependencies.load?
-          Dependencies.new_constants_in(Object) { yield }.presence
+        if Dependencies.load? && ActiveSupport::Dependencies.constant_watch_stack.watching?
+          Dependencies.new_constants_in(Object) { yield }
         else
           yield
         end
@@ -228,13 +240,13 @@ module ActiveSupport #:nodoc:
         raise
       end
 
-      def load(file, *)
+      def load(file, wrap = false)
         result = false
         load_dependency(file) { result = super }
         result
       end
 
-      def require(file, *)
+      def require(file)
         result = false
         load_dependency(file) { result = super }
         result
@@ -358,24 +370,11 @@ module ActiveSupport #:nodoc:
 
     # Is the provided constant path defined?
     def qualified_const_defined?(path)
-      names = path.sub(/^::/, '').to_s.split('::')
-
-      names.inject(Object) do |mod, name|
-        return false unless local_const_defined?(mod, name)
-        mod.const_get name
-      end
+      Object.qualified_const_defined?(path.sub(/^::/, ''), false)
     end
 
-    if Module.method(:const_defined?).arity == 1
-      # Does this module define this constant?
-      # Wrapper to accommodate changing Module#const_defined? in Ruby 1.9
-      def local_const_defined?(mod, const)
-        mod.const_defined?(const)
-      end
-    else
-      def local_const_defined?(mod, const) #:nodoc:
-        mod.const_defined?(const, false)
-      end
+    def local_const_defined?(mod, const) #:nodoc:
+      mod.const_defined?(const, false)
     end
 
     # Given +path+, a filesystem path to a ruby file, return an array of constant
@@ -426,7 +425,7 @@ module ActiveSupport #:nodoc:
     end
 
     # Attempt to autoload the provided module name by searching for a directory
-    # matching the expect path suffix. If found, the module is created and assigned
+    # matching the expected path suffix. If found, the module is created and assigned
     # to +into+'s constants with the name +const_name+. Provided that the directory
     # was loaded from a reloadable base path, it is added to the set of constants
     # that are to be unloaded.
@@ -525,7 +524,7 @@ module ActiveSupport #:nodoc:
 
     class ClassCache
       def initialize
-        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+        @store = Hash.new
       end
 
       def empty?
@@ -536,23 +535,24 @@ module ActiveSupport #:nodoc:
         @store.key?(key)
       end
 
-      def []=(key, value)
-        return unless key.respond_to?(:name)
-
-        raise(ArgumentError, 'anonymous classes cannot be cached') if key.name.blank?
-
-        @store[key.name] = value
+      def get(key)
+        key = key.name if key.respond_to?(:name)
+        @store[key] ||= Inflector.constantize(key)
       end
+      alias :[] :get
 
-      def [](key)
+      def safe_get(key)
         key = key.name if key.respond_to?(:name)
-
-        @store[key]
+        @store[key] || begin
+          klass = Inflector.safe_constantize(key)
+          @store[key] = klass
+        end
       end
-      alias :get :[]
 
-      def store(name)
-        self[name] = name
+      def store(klass)
+        return self unless klass.respond_to?(:name)
+        raise(ArgumentError, 'anonymous classes cannot be cached') if klass.name.empty?
+        @store[klass.name] = klass
         self
       end
 
@@ -569,10 +569,17 @@ module ActiveSupport #:nodoc:
     end
 
     # Get the reference for class named +name+.
+    # Raises an exception if referenced class does not exist.
     def constantize(name)
       Reference.get(name)
     end
 
+    # Get the reference for class named +name+ if one exists.
+    # Otherwise returns nil.
+    def safe_constantize(name)
+      Reference.safe_get(name)
+    end
+
     # Determine if the given constant has been automatically loaded.
     def autoloaded?(desc)
       # No name => anonymous module.