Merge remote-tracking branch 'upstream/master'

1 files changed, 55 insertions, 36 deletions

diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index 8cd4d15e4c..100b48312a 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,20 @@ 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
 
       # return a list of new constants found since the last call to watch_namespaces
@@ -88,7 +95,7 @@ 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)
@@ -101,7 +108,7 @@ module ActiveSupport #:nodoc:
           # 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
 
@@ -125,13 +132,14 @@ module ActiveSupport #:nodoc:
             Inflector.constantize(module_name).local_constant_names : []
 
           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
 
@@ -229,11 +237,15 @@ module ActiveSupport #:nodoc:
       end
 
       def load(file, *)
-        load_dependency(file) { super }
+        result = false
+        load_dependency(file) { result = super }
+        result
       end
 
       def require(file, *)
-        load_dependency(file) { super }
+        result = false
+        load_dependency(file) { result = super }
+        result
       end
 
       # Mark the given constant as unloadable. Unloadable constants are removed each
@@ -353,12 +365,13 @@ module ActiveSupport #:nodoc:
     end
 
     # 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
+    if Module.method(:const_defined?).arity == 1
+      def qualified_const_defined?(path)
+        Object.qualified_const_defined?(path.sub(/^::/, ''))
+      end
+    else
+      def qualified_const_defined?(path)
+        Object.qualified_const_defined?(path.sub(/^::/, ''), false)
       end
     end
 
@@ -417,11 +430,12 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      autoload_once_paths.any? { |base| path.starts_with? base }
+      # to_s works around a ruby1.9 issue where #starts_with?(Pathname) will always return false
+      autoload_once_paths.any? { |base| path.starts_with? base.to_s }
     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.
@@ -478,10 +492,6 @@ module ActiveSupport #:nodoc:
       qualified_name = qualified_name_for from_mod, const_name
       path_suffix = qualified_name.underscore
 
-      trace = caller.reject {|l| l.starts_with? __FILE__ }
-      name_error = NameError.new("uninitialized constant #{qualified_name}")
-      name_error.set_backtrace(trace)
-
       file_path = search_for_file(path_suffix)
 
       if file_path && ! loaded.include?(File.expand_path(file_path)) # We found a matching file to load
@@ -500,11 +510,12 @@ module ActiveSupport #:nodoc:
           return parent.const_missing(const_name)
         rescue NameError => e
           raise unless e.missing_name? qualified_name_for(parent, const_name)
-          raise name_error
         end
-      else
-        raise name_error
       end
+
+      raise NameError,
+            "uninitialized constant #{qualified_name}",
+            caller.reject {|l| l.starts_with? __FILE__ }
     end
 
     # Remove the constants that have been autoloaded, and those that have been
@@ -523,7 +534,7 @@ module ActiveSupport #:nodoc:
 
     class ClassCache
       def initialize
-        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+        @store = Hash.new
       end
 
       def empty?
@@ -534,23 +545,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
 
@@ -567,10 +579,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.