activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/attribute.rb

@@ -0,0 +1,163 @@
+module ActiveRecord
+  class Attribute # :nodoc:
+    class << self
+      def from_database(name, value, type)
+        FromDatabase.new(name, value, type)
+      end
+
+      def from_user(name, value, type)
+        FromUser.new(name, value, type)
+      end
+
+      def with_cast_value(name, value, type)
+        WithCastValue.new(name, value, type)
+      end
+
+      def null(name)
+        Null.new(name)
+      end
+
+      def uninitialized(name, type)
+        Uninitialized.new(name, type)
+      end
+    end
+
+    attr_reader :name, :value_before_type_cast, :type
+
+    # This method should not be called directly.
+    # Use #from_database or #from_user
+    def initialize(name, value_before_type_cast, type)
+      @name = name
+      @value_before_type_cast = value_before_type_cast
+      @type = type
+    end
+
+    def value
+      # `defined?` is cheaper than `||=` when we get back falsy values
+      @value = original_value unless defined?(@value)
+      @value
+    end
+
+    def original_value
+      type_cast(value_before_type_cast)
+    end
+
+    def value_for_database
+      type.type_cast_for_database(value)
+    end
+
+    def changed_from?(old_value)
+      type.changed?(old_value, value, value_before_type_cast)
+    end
+
+    def changed_in_place_from?(old_value)
+      has_been_read? && type.changed_in_place?(old_value, value)
+    end
+
+    def with_value_from_user(value)
+      self.class.from_user(name, value, type)
+    end
+
+    def with_value_from_database(value)
+      self.class.from_database(name, value, type)
+    end
+
+    def with_cast_value(value)
+      self.class.with_cast_value(name, value, type)
+    end
+
+    def type_cast(*)
+      raise NotImplementedError
+    end
+
+    def initialized?
+      true
+    end
+
+    def came_from_user?
+      false
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        name == other.name &&
+        value_before_type_cast == other.value_before_type_cast &&
+        type == other.type
+    end
+
+    protected
+
+    def initialize_dup(other)
+      if defined?(@value) && @value.duplicable?
+        @value = @value.dup
+      end
+    end
+
+    private
+
+    def has_been_read?
+      defined?(@value)
+    end
+
+    class FromDatabase < Attribute # :nodoc:
+      def type_cast(value)
+        type.type_cast_from_database(value)
+      end
+    end
+
+    class FromUser < Attribute # :nodoc:
+      def type_cast(value)
+        type.type_cast_from_user(value)
+      end
+
+      def came_from_user?
+        true
+      end
+    end
+
+    class WithCastValue < Attribute # :nodoc:
+      def type_cast(value)
+        value
+      end
+
+      def changed_in_place_from?(old_value)
+        false
+      end
+    end
+
+    class Null < Attribute # :nodoc:
+      def initialize(name)
+        super(name, nil, Type::Value.new)
+      end
+
+      def value
+        nil
+      end
+
+      def with_value_from_database(value)
+        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+      end
+      alias_method :with_value_from_user, :with_value_from_database
+    end
+
+    class Uninitialized < Attribute # :nodoc:
+      def initialize(name, type)
+        super(name, nil, type)
+      end
+
+      def value
+        if block_given?
+          yield name
+        end
+      end
+
+      def value_for_database
+      end
+
+      def initialized?
+        false
+      end
+    end
+    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized
+  end
+end

data/lib/active_record/attribute_assignment.rb

@@ -1,206 +1,103 @@
-require 'active_support/concern'
+require 'active_model/forbidden_attributes_protection'
 
 module ActiveRecord
   module AttributeAssignment
     extend ActiveSupport::Concern
-    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::ForbiddenAttributesProtection
 
-    module ClassMethods
-      private
-
-      # The primary key and inheritance column can never be set by mass-assignment for security reasons.
-      def attributes_protected_by_default
-        default = [ primary_key, inheritance_column ]
-        default << 'id' unless primary_key.eql? 'id'
-        default
-      end
-    end
-
-    # Allows you to set all the attributes at once by passing in a hash with keys
-    # matching the attribute names (which again matches the column names).
-    #
-    # If any attributes are protected by either +attr_protected+ or
-    # +attr_accessible+ then only settable attributes will be assigned.
-    #
-    #   class User < ActiveRecord::Base
-    #     attr_protected :is_admin
-    #   end
-    #
-    #   user = User.new
-    #   user.attributes = { :username => 'Phusion', :is_admin => true }
-    #   user.username   # => "Phusion"
-    #   user.is_admin?  # => false
-    def attributes=(new_attributes)
-      return unless new_attributes.is_a?(Hash)
-
-      assign_attributes(new_attributes)
-    end
-
-    # Allows you to set all the attributes for a particular mass-assignment
-    # security role by passing in a hash of attributes with keys matching
-    # the attribute names (which again matches the column names) and the role
-    # name using the :as option.
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names (which again matches the column names).
     #
-    # To bypass mass-assignment security you can use the :without_protection => true
-    # option.
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
     #
-    #   class User < ActiveRecord::Base
-    #     attr_accessible :name
-    #     attr_accessible :name, :is_admin, :as => :admin
-    #   end
+    #   cat = Cat.new(name: "Gorby", status: "yawning")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "yawning", "created_at" => nil, "updated_at" => nil}
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.attributes # =>  { "name" => "Gorby", "status" => "sleeping", "created_at" => nil, "updated_at" => nil }
     #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true })
-    #   user.name       # => "Josh"
-    #   user.is_admin?  # => false
+    # New attributes will be persisted in the database when the object is saved.
     #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :as => :admin)
-    #   user.name       # => "Josh"
-    #   user.is_admin?  # => true
-    #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :without_protection => true)
-    #   user.name       # => "Josh"
-    #   user.is_admin?  # => true
-    def assign_attributes(new_attributes, options = {})
+    # Aliased to <tt>attributes=</tt>.
+    def assign_attributes(new_attributes)
+      if !new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      end
       return if new_attributes.blank?
 
-      attributes = new_attributes.stringify_keys
-      multi_parameter_attributes = []
+      attributes                  = new_attributes.stringify_keys
+      multi_parameter_attributes  = []
       nested_parameter_attributes = []
-      @mass_assignment_options = options
 
-      unless options[:without_protection]
-        attributes = sanitize_for_mass_assignment(attributes, mass_assignment_role)
-      end
+      attributes = sanitize_for_mass_assignment(attributes)
 
       attributes.each do |k, v|
         if k.include?("(")
           multi_parameter_attributes << [ k, v ]
-        elsif respond_to?("#{k}=")
-          if v.is_a?(Hash)
-            nested_parameter_attributes << [ k, v ]
-          else
-            send("#{k}=", v)
-          end
+        elsif v.is_a?(Hash)
+          nested_parameter_attributes << [ k, v ]
         else
-          raise(UnknownAttributeError, "unknown attribute: #{k}")
+          _assign_attribute(k, v)
         end
       end
 
-      # assign any deferred nested attributes after the base attributes have been set
-      nested_parameter_attributes.each do |k,v|
-        send("#{k}=", v)
-      end
-
-      @mass_assignment_options = nil
-      assign_multiparameter_attributes(multi_parameter_attributes)
+      assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
+      assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
     end
 
-    protected
+    alias attributes= assign_attributes
 
-    def mass_assignment_options
-      @mass_assignment_options ||= {}
-    end
+    private
 
-    def mass_assignment_role
-      mass_assignment_options[:as] || :default
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v)
+    rescue NoMethodError, NameError
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise UnknownAttributeError.new(self, k)
+      end
     end
 
-    private
+    # Assign any deferred nested attributes after the base attributes have been set.
+    def assign_nested_parameter_attributes(pairs)
+      pairs.each { |k, v| _assign_attribute(k, v) }
+    end
 
     # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
     # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
     # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
     # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum,
-    # f for Float, s for String, and a for Array. If all the values for a given attribute are empty, the
-    # attribute will be set to nil.
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
+    # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
     def assign_multiparameter_attributes(pairs)
       execute_callstack_for_multiparameter_attributes(
         extract_callstack_for_multiparameter_attributes(pairs)
       )
     end
 
-    def instantiate_time_object(name, values)
-      if self.class.send(:create_time_zone_conversion_attribute?, name, column_for_attribute(name))
-        Time.zone.local(*values)
-      else
-        Time.time_with_datetime_fallback(self.class.default_timezone, *values)
-      end
-    end
-
     def execute_callstack_for_multiparameter_attributes(callstack)
       errors = []
       callstack.each do |name, values_with_empty_parameters|
         begin
-          send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
+          send("#{name}=", MultiparameterAttribute.new(self, name, values_with_empty_parameters).read_value)
         rescue => ex
-          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name}", ex, name)
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
         end
       end
       unless errors.empty?
-        raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
-      end
-    end
-
-    def read_value_from_parameter(name, values_hash_from_param)
-      klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
-      if values_hash_from_param.values.all?{|v|v.nil?}
-        nil
-      elsif klass == Time
-        read_time_parameter_value(name, values_hash_from_param)
-      elsif klass == Date
-        read_date_parameter_value(name, values_hash_from_param)
-      else
-        read_other_parameter_value(klass, name, values_hash_from_param)
-      end
-    end
-
-    def read_time_parameter_value(name, values_hash_from_param)
-      # If Date bits were not provided, error
-      raise "Missing Parameter" if [1,2,3].any?{|position| !values_hash_from_param.has_key?(position)}
-      max_position = extract_max_param_for_multiparameter_attributes(values_hash_from_param, 6)
-      # If Date bits were provided but blank, then return nil
-      return nil if (1..3).any? {|position| values_hash_from_param[position].blank?}
-
-      set_values = (1..max_position).collect{|position| values_hash_from_param[position] }
-      # If Time bits are not there, then default to 0
-      (3..5).each {|i| set_values[i] = set_values[i].blank? ? 0 : set_values[i]}
-      instantiate_time_object(name, set_values)
-    end
-
-    def read_date_parameter_value(name, values_hash_from_param)
-      return nil if (1..3).any? {|position| values_hash_from_param[position].blank?}
-      set_values = [values_hash_from_param[1], values_hash_from_param[2], values_hash_from_param[3]]
-      begin
-        Date.new(*set_values)
-      rescue ArgumentError # if Date.new raises an exception on an invalid date
-        instantiate_time_object(name, set_values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
-      end
-    end
-
-    def read_other_parameter_value(klass, name, values_hash_from_param)
-      max_position = extract_max_param_for_multiparameter_attributes(values_hash_from_param)
-      values = (1..max_position).collect do |position|
-        raise "Missing Parameter" if !values_hash_from_param.has_key?(position)
-        values_hash_from_param[position]
+        error_descriptions = errors.map { |ex| ex.message }.join(",")
+        raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
       end
-      klass.new(*values)
-    end
-
-    def extract_max_param_for_multiparameter_attributes(values_hash_from_param, upper_cap = 100)
-      [values_hash_from_param.keys.max,upper_cap].min
     end
 
     def extract_callstack_for_multiparameter_attributes(pairs)
-      attributes = { }
+      attributes = {}
 
-      pairs.each do |pair|
-        multiparameter_name, value = pair
+      pairs.each do |(multiparameter_name, value)|
         attribute_name = multiparameter_name.split("(").first
-        attributes[attribute_name] = {} unless attributes.include?(attribute_name)
+        attributes[attribute_name] ||= {}
 
         parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
         attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
@@ -217,5 +114,99 @@ module ActiveRecord
       multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
     end
 
+    class MultiparameterAttribute #:nodoc:
+      attr_reader :object, :name, :values, :cast_type
+
+      def initialize(object, name, values)
+        @object = object
+        @name   = name
+        @values = values
+      end
+
+      def read_value
+        return if values.values.compact.empty?
+
+        @cast_type = object.type_for_attribute(name)
+        klass = cast_type.klass
+
+        if klass == Time
+          read_time
+        elsif klass == Date
+          read_date
+        else
+          read_other
+        end
+      end
+
+      private
+
+      def instantiate_time_object(set_values)
+        if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type)
+          Time.zone.local(*set_values)
+        else
+          Time.send(object.class.default_timezone, *set_values)
+        end
+      end
+
+      def read_time
+        # If column is a :time (and not :date or :datetime) there is no need to validate if
+        # there are year/month/day fields
+        if cast_type.type == :time
+          # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
+          { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
+            values[key] ||= value
+          end
+        else
+          # else column is a timestamp, so if Date bits were not provided, error
+          validate_required_parameters!([1,2,3])
+
+          # If Date bits were provided but blank, then return nil
+          return if blank_date_parameter?
+        end
+
+        max_position = extract_max_param(6)
+        set_values   = values.values_at(*(1..max_position))
+        # If Time bits are not there, then default to 0
+        (3..5).each { |i| set_values[i] = set_values[i].presence || 0 }
+        instantiate_time_object(set_values)
+      end
+
+      def read_date
+        return if blank_date_parameter?
+        set_values = values.values_at(1,2,3)
+        begin
+          Date.new(*set_values)
+        rescue ArgumentError # if Date.new raises an exception on an invalid date
+          instantiate_time_object(set_values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
+        end
+      end
+
+      def read_other
+        max_position = extract_max_param
+        positions    = (1..max_position)
+        validate_required_parameters!(positions)
+
+        values.slice(*positions)
+      end
+
+      # Checks whether some blank date parameter exists. Note that this is different
+      # than the validate_required_parameters! method, since it just checks for blank
+      # positions instead of missing ones, and does not raise in case one blank position
+      # exists. The caller is responsible to handle the case of this returning true.
+      def blank_date_parameter?
+        (1..3).any? { |position| values[position].blank? }
+      end
+
+      # If some position is not provided, it errors out a missing parameter exception.
+      def validate_required_parameters!(positions)
+        if missing_parameter = positions.detect { |position| !values.key?(position) }
+          raise ArgumentError.new("Missing Parameter - #{name}(#{missing_parameter})")
+        end
+      end
+
+      def extract_max_param(upper_cap = 100)
+        [values.keys.max, upper_cap].min
+      end
+    end
   end
 end

data/lib/active_record/attribute_decorators.rb

@@ -0,0 +1,66 @@
+module ActiveRecord
+  module AttributeDecorators # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
+      self.attribute_type_decorations = TypeDecorator.new
+    end
+
+    module ClassMethods # :nodoc:
+      def decorate_attribute_type(column_name, decorator_name, &block)
+        matcher = ->(name, _) { name == column_name.to_s }
+        key = "_#{column_name}_#{decorator_name}"
+        decorate_matching_attribute_types(matcher, key, &block)
+      end
+
+      def decorate_matching_attribute_types(matcher, decorator_name, &block)
+        clear_caches_calculated_from_columns
+        decorator_name = decorator_name.to_s
+
+        # Create new hashes so we don't modify parent classes
+        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
+      end
+
+      private
+
+      def add_user_provided_columns(*)
+        super.map do |column|
+          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
+          column.with_type(decorated_type)
+        end
+      end
+    end
+
+    class TypeDecorator # :nodoc:
+      delegate :clear, to: :@decorations
+
+      def initialize(decorations = {})
+        @decorations = decorations
+      end
+
+      def merge(*args)
+        TypeDecorator.new(@decorations.merge(*args))
+      end
+
+      def apply(name, type)
+        decorations = decorators_for(name, type)
+        decorations.inject(type) do |new_type, block|
+          block.call(new_type)
+        end
+      end
+
+      private
+
+      def decorators_for(name, type)
+        matching(name, type).map(&:last)
+      end
+
+      def matching(name, type)
+        @decorations.values.select do |(matcher, _)|
+          matcher.call(name, type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -1,30 +1,75 @@
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods Before Type Cast
+    #
+    # <tt>ActiveRecord::AttributeMethods::BeforeTypeCast</tt> provides a way to
+    # read the value of the attributes before typecasting and deserialization.
+    #
+    #   class Task < ActiveRecord::Base
+    #   end
+    #
+    #   task = Task.new(id: '1', completed_on: '2012-10-21')
+    #   task.id           # => 1
+    #   task.completed_on # => Sun, 21 Oct 2012
+    #
+    #   task.attributes_before_type_cast
+    #   # => {"id"=>"1", "completed_on"=>"2012-10-21", ... }
+    #   task.read_attribute_before_type_cast('id')           # => "1"
+    #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+    #
+    # In addition to #read_attribute_before_type_cast and #attributes_before_type_cast,
+    # it declares a method for all attributes with the <tt>*_before_type_cast</tt>
+    # suffix.
+    #
+    #   task.id_before_type_cast           # => "1"
+    #   task.completed_on_before_type_cast # => "2012-10-21"
     module BeforeTypeCast
       extend ActiveSupport::Concern
 
       included do
         attribute_method_suffix "_before_type_cast"
+        attribute_method_suffix "_came_from_user?"
       end
 
+      # Returns the value of the attribute identified by +attr_name+ before
+      # typecasting and deserialization.
+      #
+      #   class Task < ActiveRecord::Base
+      #   end
+      #
+      #   task = Task.new(id: '1', completed_on: '2012-10-21')
+      #   task.read_attribute('id')                            # => 1
+      #   task.read_attribute_before_type_cast('id')           # => '1'
+      #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
+      #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
       def read_attribute_before_type_cast(attr_name)
-        @attributes[attr_name]
+        @attributes[attr_name.to_s].value_before_type_cast
       end
 
       # Returns a hash of attributes before typecasting and deserialization.
+      #
+      #   class Task < ActiveRecord::Base
+      #   end
+      #
+      #   task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
+      #   task.attributes
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
+      #   task.attributes_before_type_cast
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
       def attributes_before_type_cast
-        @attributes
+        @attributes.values_before_type_cast
       end
 
       private
 
       # Handle *_before_type_cast for method_missing.
       def attribute_before_type_cast(attribute_name)
-        if attribute_name == 'id'
-          read_attribute_before_type_cast(self.class.primary_key)
-        else
-          read_attribute_before_type_cast(attribute_name)
-        end
+        read_attribute_before_type_cast(attribute_name)
+      end
+
+      def attribute_came_from_user?(attribute_name)
+        @attributes[attribute_name].came_from_user?
       end
     end
   end