Push multi-parameter assignement into the types

This allows us to remove `Type::Value#klass`, as it was only used for
multi-parameter assignment to reach into the types internals. The
relevant type objects now accept a hash in addition to their previous
accepted arguments to `type_cast_from_user`. This required minor
modifications to the tests, since previously they were relying on the
fact that mulit-parameter assignement was reaching into the internals of
time zone aware attributes. In reaility, changing those properties at
runtime wouldn't change the accessor methods for all other forms of
assignment.

1 files changed, 6 insertions, 96 deletions

diff --git a/activerecord/lib/active_record/attribute_assignment.rb b/activerecord/lib/active_record/attribute_assignment.rb
index fdc90df5b6..483d4200bd 100644
--- a/activerecord/lib/active_record/attribute_assignment.rb
+++ b/activerecord/lib/active_record/attribute_assignment.rb
@@ -50,7 +50,12 @@ module ActiveRecord
       errors = []
       callstack.each do |name, values_with_empty_parameters|
         begin
-          send("#{name}=", MultiparameterAttribute.new(self, name, values_with_empty_parameters).read_value)
+          if values_with_empty_parameters.each_value.all?(&:nil?)
+            values = nil
+          else
+            values = values_with_empty_parameters
+          end
+          send("#{name}=", values)
         rescue => ex
           errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
         end
@@ -82,100 +87,5 @@ module ActiveRecord
     def find_parameter_position(multiparameter_name)
       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