2 files changed, 86 insertions, 38 deletions

diff --git a/activesupport/lib/active_support/cache/strategy/local_cache.rb b/activesupport/lib/active_support/cache/strategy/local_cache.rb
index 4dce35f1c9..0649a058aa 100644
--- a/activesupport/lib/active_support/cache/strategy/local_cache.rb
+++ b/activesupport/lib/active_support/cache/strategy/local_cache.rb
@@ -50,34 +50,39 @@ module ActiveSupport
           end
         end
 
-        # Middleware class can be inserted as a Rack handler to be local cache for the
-        # duration of request.
-        def middleware
-          @middleware ||= begin
-            klass = Class.new
-            klass.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-              class << self
-                def name
-                  "ActiveSupport::Cache::Strategy::LocalCache"
-                end
-                alias :to_s :name
-              end
+        #--
+        # This class wraps up local storage for middlewares. Only the middleware method should
+        # construct them.
+        class Middleware # :nodoc:
+          attr_reader :name, :thread_local_key
 
-              def initialize(app)
-                @app = app
-              end
+          def initialize(name, thread_local_key)
+            @name             = name
+            @thread_local_key = thread_local_key
+            @app              = nil
+          end
 
-              def call(env)
-                Thread.current[:#{thread_local_key}] = LocalStore.new
-                @app.call(env)
-              ensure
-                Thread.current[:#{thread_local_key}] = nil
-              end
-            EOS
-            klass
+          def new(app)
+            @app = app
+            self
+          end
+
+          def call(env)
+            Thread.current[thread_local_key] = LocalStore.new
+            @app.call(env)
+          ensure
+            Thread.current[thread_local_key] = nil
           end
         end
 
+        # Middleware class can be inserted as a Rack handler to be local cache for the
+        # duration of request.
+        def middleware
+          @middleware ||= Middleware.new(
+            "ActiveSupport::Cache::Strategy::LocalCache",
+            thread_local_key)
+        end
+
         def clear(options = nil) # :nodoc:
           local_cache.clear(options) if local_cache
           super
diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index dab6fdbac6..47596a389d 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/deprecation'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
@@ -47,9 +48,6 @@ module ActiveSupport #:nodoc:
     mattr_accessor :autoloaded_constants
     self.autoloaded_constants = []
 
-    mattr_accessor :references
-    self.references = {}
-
     # An array of constant names that need to be unloaded on every request. Used
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants
@@ -524,31 +522,76 @@ module ActiveSupport #:nodoc:
       explicitly_unloadable_constants.each { |const| remove_constant const }
     end
 
-    class Reference
-      @@constants = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+    class ClassCache
+      def initialize
+        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+      end
+
+      def empty?
+        @store.empty?
+      end
+
+      def key?(key)
+        @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
+      end
+
+      def [](key)
+        key = key.name if key.respond_to?(:name)
+
+        @store[key]
+      end
+      alias :get :[]
 
-      attr_reader :name
+      class Getter # :nodoc:
+        def initialize(name)
+          @name = name
+        end
 
-      def initialize(name)
-        @name = name.to_s
-        @@constants[@name] = name if name.respond_to?(:name)
+        def get
+          Reference.get @name
+        end
+        deprecate :get
       end
 
-      def get
-        @@constants[@name]
+      def new(name)
+        self[name] = name
+        Getter.new(name)
       end
+      deprecate :new
 
-      def self.clear!
-        @@constants.clear
+      def store(name)
+        self[name] = name
+        self
+      end
+
+      def clear!
+        @store.clear
       end
     end
 
+    Reference = ClassCache.new
+
     def ref(name)
-      references[name] ||= Reference.new(name)
+      Reference.new(name)
+    end
+    deprecate :ref
+
+    # Store a reference to a class +klass+.
+    def reference(klass)
+      Reference.store klass
     end
 
+    # Get the reference for class named +name+.
     def constantize(name)
-      ref(name).get
+      Reference.get(name)
     end
 
     # Determine if the given constant has been automatically loaded.