From b1999be5a7efd67e2602c37ed898aa8433661863 Mon Sep 17 00:00:00 2001
From: David Heinemeier Hansson <david@loudthinking.com>
Date: Tue, 15 Feb 2005 01:45:35 +0000
Subject: A hopefully more successful attempt at the Routing branch merge

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@617 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
---
 activesupport/lib/dependencies.rb | 67 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 1 deletion(-)

(limited to 'activesupport/lib/dependencies.rb')

diff --git a/activesupport/lib/dependencies.rb b/activesupport/lib/dependencies.rb
index 7f53998e7a..0a9b8e1d3d 100644
--- a/activesupport/lib/dependencies.rb
+++ b/activesupport/lib/dependencies.rb
@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/module_attribute_accessors'
 
 module Dependencies
   extend self
-  
+
   @@loaded = [ ]
   mattr_accessor :loaded
 
@@ -41,6 +41,68 @@ module Dependencies
   def remove_subclasses_for(*classes)
     classes.each { |klass| klass.remove_subclasses }
   end
+  
+  # LoadingModules implement namespace-safe dynamic loading.
+  # They support automatic loading via const_missing, allowing contained items to be automatically
+  # loaded when required. No extra syntax is required, as expressions such as Controller::Admin::UserController
+  # load the relavent files automatically.
+  #
+  # Ruby-style modules are supported, as a folder named 'submodule' will load 'submodule.rb' when available.
+  class LoadingModule < Module
+    attr_reader :path
+
+    def initialize(filesystem_root, path=[])
+      @path = path
+      @filesystem_root = filesystem_root
+    end
+
+    # The path to this module in the filesystem.
+    # Any subpath provided is taken to be composed of filesystem names.
+    def filesystem_path(subpath=[])
+      File.join(@filesystem_root, self.path, subpath)
+    end
+
+    # Load missing constants if possible.
+    def const_missing(name)
+      return const_get(name) if const_defined?(name) == false && const_load!(name)
+      super(name)
+    end
+
+    # Load the controller class or a parent module.
+    def const_load!(name)
+      name = name.to_s if name.kind_of? Symbol
+
+      if File.directory? filesystem_path(name.underscore)
+        # Is it a submodule? If so, create a new LoadingModule *before* loading it.
+        # This ensures that subitems will be loadable
+        new_module = LoadingModule.new(@filesystem_root, self.path + [name.underscore])
+        const_set(name, new_module)
+        Object.const_set(name, new_module) if @path.empty?
+      end
+      
+      source_file = filesystem_path("#{(name == 'ApplicationController' ? 'Application' : name).underscore}.rb")
+      self.load_file(source_file) if File.file?(source_file)
+      self.const_defined?(name.camelize)
+    end
+
+    # Is this name present or loadable?
+    # This method is used by Routes to find valid controllers.
+    def const_available?(name)
+      name = name.to_s unless name.kind_of? String
+      File.directory?(filesystem_path(name.underscore)) || File.file?(filesystem_path("#{name.underscore}.rb"))
+    end
+
+    def clear
+      constants.each do |name|
+        Object.send(:remove_const, name) if Object.const_defined?(name) && @path.empty?
+        self.send(:remove_const, name)
+      end
+    end
+
+    def load_file(file_path)
+      Controllers.module_eval(IO.read(file_path), file_path, 1) # Hard coded Controller line here!!!
+    end
+  end
 end
 
 Object.send(:define_method, :require_or_load)     { |file_name| Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
@@ -52,6 +114,9 @@ class Object #:nodoc:
     # Use const_missing to autoload associations so we don't have to
     # require_association when using single-table inheritance.
     def const_missing(class_id)
+      if Object.const_defined?(:Controllers) and Object::Controllers.const_available?(class_id)
+        return Object::Controllers.const_get(class_id)
+      end
       begin
         require_or_load(class_id.to_s.demodulize.underscore)
         if Object.const_defined?(class_id) then return Object.const_get(class_id) else raise LoadError end
-- 
cgit v1.2.3