activerecord 3.2.22.4 → 4.0.13

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,64 +1,70 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
+      class Type # :nodoc:
+        def initialize(column)
+          @column = column
+        end
+
+        def type_cast(value)
+          value = @column.type_cast(value)
+          value.acts_like?(:time) ? value.in_time_zone : value
+        end
+
+        def type
+          @column.type
+        end
+      end
+
       extend ActiveSupport::Concern
 
       included do
-        cattr_accessor :time_zone_aware_attributes, :instance_writer => false
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false
         self.time_zone_aware_attributes = false
 
-        class_attribute :skip_time_zone_conversion_for_attributes, :instance_writer => false
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
         self.skip_time_zone_conversion_for_attributes = []
       end
 
       module ClassMethods
         protected
-          # The enhanced read method automatically converts the UTC time stored in the database to the time
-          # zone stored in Time.zone.
-          def attribute_cast_code(attr_name)
-            column = columns_hash[attr_name]
-
-            if create_time_zone_conversion_attribute?(attr_name, column)
-              typecast             = "v = #{super}"
-              time_zone_conversion = "v.acts_like?(:time) ? v.in_time_zone : v"
-
-              "((#{typecast}) && (#{time_zone_conversion}))"
-            else
-              super
-            end
-          end
-
-          # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
-          def define_method_attribute=(attr_name)
-            if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
-              method_body, line = <<-EOV, __LINE__ + 1
-                def #{attr_name}=(original_time)
-                  original_time = nil if original_time.blank?
-                  time = original_time
-                  unless time.acts_like?(:time)
-                    time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
-                  end
-                  time = time.in_time_zone rescue nil if time
-                  previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
-                  write_attribute(:#{attr_name}, original_time)
-                  #{attr_name}_will_change! if previous_time != time
-                  @attributes_cache["#{attr_name}"] = time
-                end
-              EOV
-              generated_attribute_methods.module_eval(method_body, __FILE__, line)
-            else
-              super
-            end
+        # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
+        # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
+        def define_method_attribute=(attr_name)
+          if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
+            method_body, line = <<-EOV, __LINE__ + 1
+              def #{attr_name}=(time)
+                time_with_zone = convert_value_to_time_zone(time)
+                previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
+                write_attribute(:#{attr_name}, time)
+                #{attr_name}_will_change! if previous_time != time_with_zone
+                @attributes_cache["#{attr_name}"] = time_with_zone
+              end
+            EOV
+            generated_attribute_methods.module_eval(method_body, __FILE__, line)
+          else
+            super
           end
+        end
 
         private
-          def create_time_zone_conversion_attribute?(name, column)
-            time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) && column.type.in?([:datetime, :timestamp])
-          end
+        def create_time_zone_conversion_attribute?(name, column)
+          time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
+            (:datetime == column.type || :timestamp == column.type)
+        end
+      end
+
+      private
+
+      def convert_value_to_time_zone(value)
+        if value.is_a?(Array)
+          value.map { |v| convert_value_to_time_zone(v) }
+        elsif value.respond_to?(:in_time_zone)
+          value.in_time_zone
+        else
+          nil
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/write.rb

@@ -9,62 +9,57 @@ module ActiveRecord
 
       module ClassMethods
         protected
-          def define_method_attribute=(attr_name)
-            if attr_name =~ ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
-            else
-              generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
-                write_attribute(attr_name, new_value)
-              end
+
+        # See define_method_attribute in read.rb for an explanation of
+        # this code.
+        def define_method_attribute=(name)
+          safe_name = name.unpack('h*').first
+          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              write_attribute(AttrNames::ATTR_#{safe_name}, value)
             end
-          end
+            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+            undef_method :__temp__#{safe_name}=
+          STR
+        end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
-      # for fixnum and float columns are turned into +nil+.
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for fixnum and float columns are
+      # turned into +nil+.
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
         attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
         @attributes_cache.delete(attr_name)
         column = column_for_attribute(attr_name)
 
-        unless column || @attributes.has_key?(attr_name)
-          ActiveSupport::Deprecation.warn(
-            "You're trying to create an attribute `#{attr_name}'. Writing arbitrary " \
-            "attributes on a model is deprecated. Please just use `attr_writer` etc."
-          )
+        # If we're dealing with a binary column, write the data to the cache
+        # so we don't attempt to typecast multiple times.
+        if column && column.binary?
+          @attributes_cache[attr_name] = value
         end
 
-        @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+        if column || @attributes.has_key?(attr_name)
+          @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+        else
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+        end
       end
       alias_method :raw_write_attribute, :write_attribute
 
       private
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
-        end
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
 
-        def type_cast_attribute_for_write(column, value)
-          if column && column.number?
-            convert_number_column_value(value)
-          else
-            value
-          end
-        end
+      def type_cast_attribute_for_write(column, value)
+        return value unless column
 
-        def convert_number_column_value(value)
-          case value
-          when FalseClass
-            0
-          when TrueClass
-            1
-          when String
-            value.presence
-          else
-            value
-          end
-        end
+        column.type_cast_for_write value
+      end
     end
   end
 end