From f208cc8108d6d3ae70de2705cc1111edcf9b82b1 Mon Sep 17 00:00:00 2001
From: Aaron Patterson <aaron.patterson@gmail.com>
Date: Wed, 3 Jul 2013 10:49:16 -0700
Subject: move the reader method cache in to the read module

---
 .../lib/active_record/attribute_methods.rb         | 48 ---------------------
 .../lib/active_record/attribute_methods/read.rb    | 50 +++++++++++++++++++++-
 2 files changed, 49 insertions(+), 49 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index 4846965b59..2fd2ea896b 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -28,54 +28,6 @@ module ActiveRecord
       end
     }
 
-    ReaderMethodCache = Class.new {
-      include Mutex_m
-
-      def initialize
-        super
-        @module = Module.new
-        @method_cache = {}
-      end
-
-      # We want to generate the methods via module_eval rather than
-      # define_method, because define_method is slower on dispatch.
-      # Evaluating many similar methods may use more memory as the instruction
-      # sequences are duplicated and cached (in MRI).  define_method may
-      # be slower on dispatch, but if you're careful about the closure
-      # created, then define_method will consume much less memory.
-      #
-      # But sometimes the database might return columns with
-      # characters that are not allowed in normal method names (like
-      # 'my_column(omg)'. So to work around this we first define with
-      # the __temp__ identifier, and then use alias method to rename
-      # it to what we want.
-      #
-      # We are also defining a constant to hold the frozen string of
-      # the attribute name. Using a constant means that we do not have
-      # to allocate an object on each call to the attribute method.
-      # Making it frozen means that it doesn't get duped when used to
-      # key the @attributes_cache in read_attribute.
-      def [](name)
-        synchronize do
-          @method_cache.fetch(name) {
-            safe_name = name.unpack('h*').first
-            temp_method = "__temp__#{safe_name}"
-
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-            @module.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def #{temp_method}
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                read_attribute(name) { |n| missing_attribute(n, caller) }
-              end
-            STR
-
-            @method_cache[name] = @module.instance_method temp_method
-          }
-        end
-      end
-    }.new
-
     module ClassMethods
       def inherited(child_class) #:nodoc:
         child_class.initialize_generated_modules
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 0ac2e7507a..d43f4b55e8 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -1,6 +1,54 @@
 module ActiveRecord
   module AttributeMethods
     module Read
+      ReaderMethodCache = Class.new {
+        include Mutex_m
+
+        def initialize
+          super
+          @module = Module.new
+          @method_cache = {}
+        end
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes_cache in read_attribute.
+        def [](name)
+          synchronize do
+            @method_cache.fetch(name) {
+              safe_name = name.unpack('h*').first
+              temp_method = "__temp__#{safe_name}"
+
+              ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+              @module.module_eval <<-STR, __FILE__, __LINE__ + 1
+                def #{temp_method}
+                  name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                  read_attribute(name) { |n| missing_attribute(n, caller) }
+                end
+              STR
+
+              @method_cache[name] = @module.instance_method temp_method
+            }
+          end
+        end
+      }.new
+
       extend ActiveSupport::Concern
 
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
@@ -33,7 +81,7 @@ module ActiveRecord
         protected
 
         def define_method_attribute(name)
-          method = ActiveRecord::AttributeMethods::ReaderMethodCache[name]
+          method = ReaderMethodCache[name]
           generated_attribute_methods.module_eval { define_method name, method }
         end
 
-- 
cgit v1.2.3