activerecord 4.2.0

data/lib/active_record/attribute_methods/serialization.rb

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module AttributeMethods
+    module Serialization
+      extend ActiveSupport::Concern
+
+      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 assignment and retrieval.
+        # Otherwise <tt>SerializationTypeMismatch</tt> will be raised.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        #   or a class name that the object type should be equal to.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          # When ::JSON is used, force it to go through the Active Support JSON encoder
+          # to ensure special objects (e.g. Active Record models) are dumped correctly
+          # using the #as_json hook.
+          coder = if class_name_or_coder == ::JSON
+                    Coders::JSON
+                  elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                    class_name_or_coder
+                  else
+                    Coders::YAMLColumn.new(class_name_or_coder)
+                  end
+
+          decorate_attribute_type(attr_name, :serialize) do |type|
+            Type::Serialized.new(type, coder)
+          end
+        end
+
+        def serialized_attributes
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            `serialized_attributes` is deprecated without replacement, and will
+            be removed in Rails 5.0.
+          MSG
+
+          @serialized_attributes ||= Hash[
+            columns.select { |t| t.cast_type.is_a?(Type::Serialized) }.map { |c|
+              [c.name, c.cast_type.coder]
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -0,0 +1,65 @@
+module ActiveRecord
+  module AttributeMethods
+    module TimeZoneConversion
+      class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        include Type::Decorator
+
+        def type_cast_from_database(value)
+          convert_time_to_time_zone(super)
+        end
+
+        def type_cast_from_user(value)
+          if value.is_a?(Array)
+            value.map { |v| type_cast_from_user(v) }
+          elsif value.respond_to?(:in_time_zone)
+            value.in_time_zone || super
+          end
+        end
+
+        def convert_time_to_time_zone(value)
+          if value.is_a?(Array)
+            value.map { |v| convert_time_to_time_zone(v) }
+          elsif value.acts_like?(:time)
+            value.in_time_zone
+          else
+            value
+          end
+        end
+      end
+
+      extend ActiveSupport::Concern
+
+      included do
+        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
+        self.skip_time_zone_conversion_for_attributes = []
+      end
+
+      module ClassMethods
+        private
+
+        def inherited(subclass)
+          # We need to apply this decorator here, rather than on module inclusion. The closure
+          # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
+          # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
+          # `skip_time_zone_conversion_for_attributes` would not be picked up.
+          subclass.class_eval do
+            matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
+            decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
+              TimeZoneConverter.new(type)
+            end
+          end
+          super
+        end
+
+        def create_time_zone_conversion_attribute?(name, cast_type)
+          time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
+            (:datetime == cast_type.type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/write.rb

@@ -0,0 +1,83 @@
+require 'active_support/core_ext/module/method_transplanting'
+
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      WriterMethodCache = Class.new(AttributeMethodCache) {
+        private
+
+        def method_body(method_name, const_name)
+          <<-EOMETHOD
+          def #{method_name}(value)
+            name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
+            write_attribute(name, value)
+          end
+          EOMETHOD
+        end
+      }.new
+
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      module ClassMethods
+        protected
+
+        if Module.methods_transplantable?
+          def define_method_attribute=(name)
+            method = WriterMethodCache[name]
+            generated_attribute_methods.module_eval {
+              define_method "#{name}=", method
+            }
+          end
+        else
+          def define_method_attribute=(name)
+            safe_name = name.unpack('h*').first
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def __temp__#{safe_name}=(value)
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                write_attribute(name, value)
+              end
+              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+              undef_method :__temp__#{safe_name}=
+            STR
+          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)
+        write_attribute_with_type_cast(attr_name, value, true)
+      end
+
+      def raw_write_attribute(attr_name, value)
+        write_attribute_with_type_cast(attr_name, value, false)
+      end
+
+      private
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
+
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
+        attr_name = attr_name.to_s
+        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+
+        if should_type_cast
+          @attributes.write_from_user(attr_name, value)
+        else
+          @attributes.write_cast_value(attr_name, value)
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/active_record/attribute_set.rb

@@ -0,0 +1,77 @@
+require 'active_record/attribute_set/builder'
+
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      attributes[name] || Attribute.null(name)
+    end
+
+    def values_before_type_cast
+      attributes.transform_values(&:value_before_type_cast)
+    end
+
+    def to_hash
+      initialized_attributes.transform_values(&:value)
+    end
+    alias_method :to_h, :to_hash
+
+    def key?(name)
+      attributes.key?(name) && self[name].initialized?
+    end
+
+    def keys
+      attributes.initialized_keys
+    end
+
+    def fetch_value(name)
+      self[name].value { |n| yield n if block_given? }
+    end
+
+    def write_from_database(name, value)
+      attributes[name] = self[name].with_value_from_database(value)
+    end
+
+    def write_from_user(name, value)
+      attributes[name] = self[name].with_value_from_user(value)
+    end
+
+    def write_cast_value(name, value)
+      attributes[name] = self[name].with_cast_value(value)
+    end
+
+    def freeze
+      @attributes.freeze
+      super
+    end
+
+    def initialize_dup(_)
+      @attributes = attributes.dup
+      super
+    end
+
+    def initialize_clone(_)
+      @attributes = attributes.clone
+      super
+    end
+
+    def reset(key)
+      if key?(key)
+        write_from_database(key, nil)
+      end
+    end
+
+    protected
+
+    attr_reader :attributes
+
+    private
+
+    def initialized_attributes
+      attributes.select { |_, attr| attr.initialized? }
+    end
+  end
+end

data/lib/active_record/attribute_set/builder.rb

@@ -0,0 +1,86 @@
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      attr_reader :types, :always_initialized
+
+      def initialize(types, always_initialized = nil)
+        @types = types
+        @always_initialized = always_initialized
+      end
+
+      def build_from_database(values = {}, additional_types = {})
+        if always_initialized && !values.key?(always_initialized)
+          values[always_initialized] = nil
+        end
+
+        attributes = LazyAttributeHash.new(types, values, additional_types)
+        AttributeSet.new(attributes)
+      end
+    end
+  end
+
+  class LazyAttributeHash # :nodoc:
+    delegate :select, :transform_values, to: :materialize
+
+    def initialize(types, values, additional_types)
+      @types = types
+      @values = values
+      @additional_types = additional_types
+      @materialized = false
+      @delegate_hash = {}
+    end
+
+    def key?(key)
+      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
+    end
+
+    def [](key)
+      delegate_hash[key] || assign_default_value(key)
+    end
+
+    def []=(key, value)
+      if frozen?
+        raise RuntimeError, "Can't modify frozen hash"
+      end
+      delegate_hash[key] = value
+    end
+
+    def initialized_keys
+      delegate_hash.keys | values.keys
+    end
+
+    def initialize_dup(_)
+      @delegate_hash = delegate_hash.transform_values(&:dup)
+      super
+    end
+
+    protected
+
+    attr_reader :types, :values, :additional_types, :delegate_hash
+
+    private
+
+    def assign_default_value(name)
+      type = additional_types.fetch(name, types[name])
+      value_present = true
+      value = values.fetch(name) { value_present = false }
+
+      if value_present
+        delegate_hash[name] = Attribute.from_database(name, value, type)
+      elsif types.key?(name)
+        delegate_hash[name] = Attribute.uninitialized(name, type)
+      end
+    end
+
+    def materialize
+      unless @materialized
+        values.each_key { |key| self[key] }
+        types.each_key { |key| self[key] }
+        unless frozen?
+          @materialized = true
+        end
+      end
+      delegate_hash
+    end
+  end
+end

data/lib/active_record/attributes.rb

@@ -0,0 +1,139 @@
+module ActiveRecord
+  module Attributes # :nodoc:
+    extend ActiveSupport::Concern
+
+    Type = ActiveRecord::Type
+
+    included do
+      class_attribute :user_provided_columns, instance_accessor: false # :internal:
+      class_attribute :user_provided_defaults, instance_accessor: false # :internal:
+      self.user_provided_columns = {}
+      self.user_provided_defaults = {}
+    end
+
+    module ClassMethods # :nodoc:
+      # Defines or overrides a attribute on this model. This allows customization of
+      # Active Record's type casting behavior, as well as adding support for user defined
+      # types.
+      #
+      # +name+ The name of the methods to define attribute methods for, and the column which
+      # this will persist to.
+      #
+      # +cast_type+ A type object that contains information about how to type cast the value.
+      # See the examples section for more information.
+      #
+      # ==== Options
+      # The options hash accepts the following options:
+      #
+      # +default+ is the default value that the column should use on a new record.
+      #
+      # ==== Examples
+      #
+      # The type detected by Active Record can be overridden.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.decimal :price_in_cents
+      #   end
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveRecord::Base
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '10.1')
+      #
+      #   # before
+      #   store_listing.price_in_cents # => BigDecimal.new(10.1)
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, Type::Integer.new
+      #   end
+      #
+      #   # after
+      #   store_listing.price_in_cents # => 10
+      #
+      # Users may also define their own custom types, as long as they respond to the methods
+      # defined on the value type. The `type_cast` method on your type object will be called
+      # with values both from the database, and from your controllers. See
+      # `ActiveRecord::Attributes::Type::Value` for the expected API. It is recommended that your
+      # type objects inherit from an existing type, or the base value type.
+      #
+      #   class MoneyType < ActiveRecord::Type::Integer
+      #     def type_cast(value)
+      #       if value.include?('$')
+      #         price_in_dollars = value.gsub(/\$/, '').to_f
+      #         price_in_dollars * 100
+      #       else
+      #         value.to_i
+      #       end
+      #     end
+      #   end
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, MoneyType.new
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '$10.00')
+      #   store_listing.price_in_cents # => 1000
+      def attribute(name, cast_type, options = {})
+        name = name.to_s
+        clear_caches_calculated_from_columns
+        # Assign a new hash to ensure that subclasses do not share a hash
+        self.user_provided_columns = user_provided_columns.merge(name => cast_type)
+
+        if options.key?(:default)
+          self.user_provided_defaults = user_provided_defaults.merge(name => options[:default])
+        end
+      end
+
+      # Returns an array of column objects for the table associated with this class.
+      def columns
+        @columns ||= add_user_provided_columns(connection.schema_cache.columns(table_name))
+      end
+
+      # Returns a hash of column objects for the table associated with this class.
+      def columns_hash
+        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
+      end
+
+      def reset_column_information # :nodoc:
+        super
+        clear_caches_calculated_from_columns
+      end
+
+      private
+
+      def add_user_provided_columns(schema_columns)
+        existing_columns = schema_columns.map do |column|
+          new_type = user_provided_columns[column.name]
+          if new_type
+            column.with_type(new_type)
+          else
+            column
+          end
+        end
+
+        existing_column_names = existing_columns.map(&:name)
+        new_columns = user_provided_columns.except(*existing_column_names).map do |(name, type)|
+          connection.new_column(name, nil, type)
+        end
+
+        existing_columns + new_columns
+      end
+
+      def clear_caches_calculated_from_columns
+        @attributes_builder = nil
+        @column_names = nil
+        @column_types = nil
+        @columns = nil
+        @columns_hash = nil
+        @content_columns = nil
+        @default_attributes = nil
+      end
+
+      def raw_default_values
+        super.merge(user_provided_defaults)
+      end
+    end
+  end
+end