1 files changed, 36 insertions, 17 deletions

diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index c9071a73d8..d6bc95a522 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -168,16 +168,30 @@ module ActiveSupport #:nodoc:
         end
       end
 
-      def const_missing(const_name, nesting = nil)
+      def const_missing(const_name)
         klass_name = name.presence || "Object"
 
-        unless nesting
-          # We'll assume that the nesting of Foo::Bar is ["Foo::Bar", "Foo"]
-          # even though it might not be, such as in the case of
-          # class Foo::Bar; Baz; end
-          nesting = []
-          klass_name.to_s.scan(/::|$/) { nesting.unshift $` }
-        end
+        # Since Ruby does not pass the nesting at the point the unknown
+        # constant triggered the callback we cannot fully emulate constant
+        # name lookup and need to make a trade-off: we are going to assume
+        # that the nesting in the body of Foo::Bar is [Foo::Bar, Foo] even
+        # though it might not be. Counterexamples are
+        #
+        #   class Foo::Bar
+        #     Module.nesting # => [Foo::Bar]
+        #   end
+        #
+        # or
+        #
+        #   module M::N
+        #     module S::T
+        #       Module.nesting # => [S::T, M::N]
+        #     end
+        #   end
+        #
+        # for example.
+        nesting = []
+        klass_name.to_s.scan(/::|$/) { nesting.unshift $` }
 
         # If there are multiple levels of nesting to search under, the top
         # level is the one we want to report as the lookup fail.
@@ -287,13 +301,11 @@ module ActiveSupport #:nodoc:
       Object.class_eval { include Loadable }
       Module.class_eval { include ModuleConstMissing }
       Exception.class_eval { include Blamable }
-      true
     end
 
     def unhook!
       ModuleConstMissing.exclude_from(Module)
       Loadable.exclude_from(Object)
-      true
     end
 
     def load?
@@ -319,7 +331,7 @@ module ActiveSupport #:nodoc:
 
     def require_or_load(file_name, const_path = nil)
       log_call file_name, const_path
-      file_name = $1 if file_name =~ /^(.*)\.rb$/
+      file_name = $` if file_name =~ /\.rb\z/
       expanded = File.expand_path(file_name)
       return if loaded.include?(expanded)
 
@@ -363,7 +375,7 @@ module ActiveSupport #:nodoc:
     # 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 = autoload_paths)
-      path = $1 if path =~ /\A(.*)\.rb\Z/
+      path = $` if path =~ /\.rb\z/
       expanded_path = File.expand_path(path)
       paths = []
 
@@ -431,7 +443,7 @@ module ActiveSupport #:nodoc:
     def load_file(path, const_paths = loadable_constants_for_path(path))
       log_call path, const_paths
       const_paths = [const_paths].compact unless const_paths.is_a? Array
-      parent_paths = const_paths.collect { |const_path| /(.*)::[^:]+\Z/ =~ const_path ? $1 : :Object }
+      parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || :Object }
 
       result = nil
       newly_defined_paths = new_constants_in(*parent_paths) do
@@ -467,10 +479,17 @@ module ActiveSupport #:nodoc:
 
       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, false)
-        return from_mod.const_get(const_name)
+      if file_path
+        expanded = File.expand_path(file_path)
+        expanded.sub!(/\.rb\z/, '')
+
+        if loaded.include?(expanded)
+          raise "Circular dependency detected while autoloading constant #{qualified_name}"
+        else
+          require_or_load(expanded)
+          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
+          return from_mod.const_get(const_name)
+        end
       elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
         return mod
       elsif (parent = from_mod.parent) && parent != from_mod &&