activerecord 2.3.18 → 3.2.22

data/lib/active_record/attribute_methods/serialization.rb

@@ -0,0 +1,120 @@
+module ActiveRecord
+  module AttributeMethods
+    module Serialization
+      extend ActiveSupport::Concern
+
+      included do
+        # Returns a hash of all the attributes that have been specified for serialization as
+        # keys and their class restriction as values.
+        class_attribute :serialized_attributes
+        self.serialized_attributes = {}
+      end
+
+      class Attribute < Struct.new(:coder, :value, :state)
+        def unserialized_value
+          state == :serialized ? unserialize : value
+        end
+
+        def serialized_value
+          state == :unserialized ? serialize : value
+        end
+
+        def unserialize
+          self.state = :unserialized
+          self.value = coder.load(value)
+        end
+
+        def serialize
+          self.state = :serialized
+          self.value = coder.dump(value)
+        end
+      end
+
+      module ClassMethods
+        # If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object,
+        # then specify the name of that attribute using this method and it will be handled automatically.
+        # The serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that
+        # class on retrieval or SerializationTypeMismatch will be raised.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name+ - Optional, class name that the object type should be equal to.
+        #
+        # ==== Example
+        #   # Serialize a preferences attribute
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        def serialize(attr_name, class_name = Object)
+          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                    class_name
+                  else
+                    Coders::YAMLColumn.new(class_name)
+                  end
+
+          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
+          # has its own hash of own serialized attributes
+          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
+        end
+
+        def initialize_attributes(attributes, options = {}) #:nodoc:
+          serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
+          super(attributes, options)
+
+          serialized_attributes.each do |key, coder|
+            if attributes.key?(key)
+              attributes[key] = Attribute.new(coder, attributes[key], serialized)
+            end
+          end
+
+          attributes
+        end
+
+        private
+
+        def attribute_cast_code(attr_name)
+          if serialized_attributes.include?(attr_name)
+            "v.unserialized_value"
+          else
+            super
+          end
+        end
+      end
+
+      def type_cast_attribute_for_write(column, value)
+        if column && coder = self.class.serialized_attributes[column.name]
+          Attribute.new(coder, value, :unserialized)
+        else
+          super
+        end
+      end
+
+      def _field_changed?(attr, old, value)
+        if self.class.serialized_attributes.include?(attr)
+          old != value
+        else
+          super
+        end
+      end
+
+      def read_attribute_before_type_cast(attr_name)
+        if serialized_attributes.include?(attr_name)
+          super.unserialized_value
+        else
+          super
+        end
+      end
+
+      def attributes_before_type_cast
+        super.dup.tap do |attributes|
+          self.class.serialized_attributes.each_key do |key|
+            if attributes.key?(key)
+              attributes[key] = attributes[key].unserialized_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -0,0 +1,65 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveRecord
+  module AttributeMethods
+    module TimeZoneConversion
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_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
+        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
+          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
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/write.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      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
+            end
+          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+.
+      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."
+          )
+        end
+
+        @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+      end
+      alias_method :raw_write_attribute, :write_attribute
+
+      private
+        # 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 convert_number_column_value(value)
+          case value
+          when FalseClass
+            0
+          when TrueClass
+            1
+          when String
+            value.presence
+          else
+            value
+          end
+        end
+    end
+  end
+end