diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb index 818dc88725c5eab7a784a27bfdf9d2fc6804ee8c..3c9fafb1ca06f6dde816cb8d7cb6f74844917aaa 100644 --- a/activerecord/lib/active_record/attribute_methods.rb +++ b/activerecord/lib/active_record/attribute_methods.rb @@ -29,6 +29,10 @@ def attribute_methods_generated? end end + def generated_attribute_methods + @generated_attribute_methods ||= (base_class == self ? super : base_class.generated_attribute_methods) + end + def undefine_attribute_methods if base_class == self super diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb index 8eec06302aab048529fffdd00d4764fe691593c7..41cd194c92fb0ab09b93484884f5348036536708 100644 --- a/activerecord/lib/active_record/attribute_methods/read.rb +++ b/activerecord/lib/active_record/attribute_methods/read.rb @@ -33,7 +33,7 @@ def undefine_attribute_methods if base_class == self generated_attribute_methods.module_eval do public_methods(false).each do |m| - singleton_class.send(:undef_method, m) if m.to_s =~ /^cast_/ + singleton_class.send(:undef_method, m) if m.to_s =~ /^attribute_/ end end end @@ -49,27 +49,27 @@ def undefine_attribute_methods # The second, slower, branch is necessary to support instances where the database # returns columns with extra stuff in (like 'my_column(omg)'). def define_method_attribute(attr_name) - access_code = attribute_access_code(attr_name) - cast_code = "v && (#{attribute_cast_code(attr_name)})" + internal = internal_attribute_access_code(attr_name) + external = external_attribute_access_code(attr_name) if attr_name =~ ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ def #{attr_name} - #{access_code} + #{internal} end - def self.cast_#{attr_name}(v) - #{cast_code} + def self.attribute_#{attr_name}(v, attributes_cache, attr_name) + #{external} end STR else generated_attribute_methods.module_eval do define_method(attr_name) do - eval(access_code) + eval(internal) end - singleton_class.send(:define_method, "cast_#{attr_name}") do |v| - eval(cast_code) + singleton_class.send(:define_method, "attribute_#{attr_name}") do |v, attributes_cache, attr_name| + eval(external) end end end @@ -80,7 +80,7 @@ def cacheable_column?(column) attribute_types_cached_by_default.include?(column.type) end - def attribute_access_code(attr_name) + def internal_attribute_access_code(attr_name) access_code = "(v=@attributes['#{attr_name}']) && #{attribute_cast_code(attr_name)}" unless attr_name == self.primary_key @@ -94,6 +94,16 @@ def attribute_access_code(attr_name) access_code end + def external_attribute_access_code(attr_name) + access_code = "v && #{attribute_cast_code(attr_name)}" + + if cache_attribute?(attr_name) + access_code = "attributes_cache[attr_name] ||= (#{access_code})" + end + + access_code + end + def attribute_cast_code(attr_name) columns_hash[attr_name].type_cast_code('v') end @@ -103,36 +113,26 @@ def attribute_cast_code(attr_name) # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)). def read_attribute(attr_name) attr_name = attr_name.to_s - caster = "cast_#{attr_name}" + accessor = "attribute_#{attr_name}" methods = self.class.generated_attribute_methods - if methods.respond_to?(caster) + if methods.respond_to?(accessor) if @attributes.has_key?(attr_name) - @attributes_cache[attr_name] || methods.send(caster, @attributes[attr_name]) + methods.send(accessor, @attributes[attr_name], @attributes_cache, attr_name) end + elsif !self.class.attribute_methods_generated? + # If we haven't generated the caster methods yet, do that and + # then try again + self.class.define_attribute_methods + read_attribute(attr_name) else - _read_attribute attr_name - end - end - - def _read_attribute(attr_name) - attr_name = attr_name.to_s - attr_name = self.class.primary_key if attr_name == 'id' - - unless @attributes[attr_name].nil? - type_cast_attribute(column_for_attribute(attr_name), @attributes[attr_name]) + # If we get here, the attribute has no associated DB column, so + # just return it verbatim. + @attributes[attr_name] end end private - def type_cast_attribute(column, value) - if column - column.type_cast(value) - else - value - end - end - def attribute(attribute_name) read_attribute(attribute_name) end diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb index e1eb2d6acfc8eba0bbc7968f71399cc2a497baa2..0a4432506ff603d1181c132cda3afcd9bf76399d 100644 --- a/activerecord/lib/active_record/attribute_methods/serialization.rb +++ b/activerecord/lib/active_record/attribute_methods/serialization.rb @@ -77,14 +77,6 @@ def set_serialized_attributes end end - def type_cast_attribute(column, value) - if column && self.class.serialized_attributes[column.name] - value.unserialized_value - else - super - end - end - def type_cast_attribute_for_write(column, value) if column && coder = self.class.serialized_attributes[column.name] Attribute.new(coder, value, :unserialized) diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb index 7cde9dbffd2d93f73f25dcdcd0b2e93696039a18..d7972917fed9d5b6ab1c63d19b19dd7d00e71b42 100644 --- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb +++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb @@ -19,12 +19,15 @@ module ClassMethods # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled. # This enhanced read method automatically converts the UTC time stored in the database to the time # zone stored in Time.zone. - def attribute_access_code(attr_name) - if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name]) + def internal_attribute_access_code(attr_name) + column = columns_hash[attr_name] + + if create_time_zone_conversion_attribute?(attr_name, column) <<-CODE cached = @attributes_cache['#{attr_name}'] return cached if cached - time = _read_attribute('#{attr_name}') + v = @attributes['#{attr_name}'] + time = #{column.type_cast_code('v')} @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time CODE else @@ -32,6 +35,16 @@ def attribute_access_code(attr_name) end end + def external_attribute_access_code(attr_name) + column = columns_hash[attr_name] + + if create_time_zone_conversion_attribute?(attr_name, column) + "attributes_cache[attr_name] ||= (#{attribute_cast_code(attr_name)})" + else + super + end + end + def attribute_cast_code(attr_name) if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name]) "v.acts_like?(:time) ? v.in_time_zone : v" diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb index 6ba571a632ddaf9378dd4717de51fd5ac43463b1..11469f7e43229679538e00b6330b731554abd532 100644 --- a/activerecord/lib/active_record/base.rb +++ b/activerecord/lib/active_record/base.rb @@ -1821,7 +1821,7 @@ def attribute_for_inspect(attr_name) # Returns true if the specified +attribute+ has been set by the user or by a database load and is neither # nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings). def attribute_present?(attribute) - value = _read_attribute(attribute) + value = read_attribute(attribute) !value.nil? || (value.respond_to?(:empty?) && !value.empty?) end