activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/attribute_assignment.rb

@@ -0,0 +1,221 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module AttributeAssignment
+    extend ActiveSupport::Concern
+    include ActiveModel::MassAssignmentSecurity
+
+    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.
+    #
+    # To bypass mass-assignment security you can use the :without_protection => true
+    # option.
+    #
+    #   class User < ActiveRecord::Base
+    #     attr_accessible :name
+    #     attr_accessible :name, :is_admin, :as => :admin
+    #   end
+    #
+    #   user = User.new
+    #   user.assign_attributes({ :name => 'Josh', :is_admin => true })
+    #   user.name       # => "Josh"
+    #   user.is_admin?  # => false
+    #
+    #   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 = {})
+      return if new_attributes.blank?
+
+      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.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
+        else
+          raise(UnknownAttributeError, "unknown attribute: #{k}")
+        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)
+    end
+
+    protected
+
+    def mass_assignment_options
+      @mass_assignment_options ||= {}
+    end
+
+    def mass_assignment_role
+      mass_assignment_options[:as] || :default
+    end
+
+    private
+
+    # 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.
+    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))
+        rescue => ex
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name}", 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]
+      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 = { }
+
+      pairs.each do |pair|
+        multiparameter_name, value = pair
+        attribute_name = multiparameter_name.split("(").first
+        attributes[attribute_name] = {} unless attributes.include?(attribute_name)
+
+        parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+        attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+      end
+
+      attributes
+    end
+
+    def type_cast_attribute_value(multiparameter_name, value)
+      multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+    end
+
+    def find_parameter_position(multiparameter_name)
+      multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
+    end
+
+  end
+end

data/lib/active_record/attribute_methods/deprecated_underscore_read.rb

@@ -0,0 +1,32 @@
+require 'active_support/concern'
+require 'active_support/deprecation'
+
+module ActiveRecord
+  module AttributeMethods
+    module DeprecatedUnderscoreRead
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_prefix "_"
+      end
+
+      module ClassMethods
+        protected
+
+        def define_method__attribute(attr_name)
+          # Do nothing, let it hit method missing instead.
+        end
+      end
+
+      protected
+
+      def _attribute(attr_name)
+        ActiveSupport::Deprecation.warn(
+          "You have called '_#{attr_name}'. This is deprecated. Please use " \
+          "either '#{attr_name}' or read_attribute('#{attr_name}')."
+        )
+        read_attribute(attr_name)
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/dirty.rb

@@ -34,9 +34,9 @@ module ActiveRecord
           @previously_changed = changes
           @changed_attributes.clear
         end
-        rescue
-          IdentityMap.remove(self) if IdentityMap.enabled?
-          raise
+      rescue
+        IdentityMap.remove(self) if IdentityMap.enabled?
+        raise
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
@@ -55,12 +55,12 @@ module ActiveRecord
         # The attribute already has an unsaved change.
         if attribute_changed?(attr)
           old = @changed_attributes[attr]
-          @changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+          @changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
         else
           old = clone_attribute_value(:read_attribute, attr)
           # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
           old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
-          @changed_attributes[attr] = old if field_changed?(attr, old, value)
+          @changed_attributes[attr] = old if _field_changed?(attr, old, value)
         end
 
         # Carry on.
@@ -77,13 +77,10 @@ module ActiveRecord
         end
       end
 
-      def field_changed?(attr, old, value)
+      def _field_changed?(attr, old, value)
         if column = column_for_attribute(attr)
-          if column.number? && column.null && (old.nil? || old == 0) && value.blank?
-            # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
-            # Hence we don't record it as a change if the value changes from nil to ''.
-            # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-            # be typecast back to 0 (''.to_i => 0)
+          if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
+                                changes_from_zero_to_string?(old, value))
             value = nil
           else
             value = column.type_cast(value)
@@ -96,6 +93,19 @@ module ActiveRecord
       def clone_with_time_zone_conversion_attribute?(attr, old)
         old.class.name == "Time" && time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
       end
+
+      def changes_from_nil_to_empty_string?(column, old, value)
+        # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
+        # Hence we don't record it as a change if the value changes from nil to ''.
+        # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+        # be typecast back to 0 (''.to_i => 0)
+        column.null && (old.nil? || old == 0) && value.blank?
+      end
+
+      def changes_from_zero_to_string?(old, value)
+        # For columns with old 0 and value non-empty string
+        old == 0 && value.is_a?(String) && value.present? && value != '0'
+      end
     end
   end
 end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -5,11 +5,44 @@ module ActiveRecord
 
       # Returns this record's primary key value wrapped in an Array if one is available
       def to_key
-        key = send(self.class.primary_key)
+        key = self.id
         [key] if key
       end
 
+      # Returns the primary key value
+      def id
+        read_attribute(self.class.primary_key)
+      end
+
+      # Sets the primary key value
+      def id=(value)
+        write_attribute(self.class.primary_key, value)
+      end
+
+      # Queries the primary key value
+      def id?
+        query_attribute(self.class.primary_key)
+      end
+
       module ClassMethods
+        def define_method_attribute(attr_name)
+          super
+
+          if attr_name == primary_key && attr_name != 'id'
+            generated_attribute_methods.send(:alias_method, :id, primary_key)
+            generated_external_attribute_methods.module_eval <<-CODE, __FILE__, __LINE__
+              def id(v, attributes, attributes_cache, attr_name)
+                attr_name = '#{primary_key}'
+                send(attr_name, attributes[attr_name], attributes, attributes_cache, attr_name)
+              end
+            CODE
+          end
+        end
+
+        def dangerous_attribute_method?(method_name)
+          super && !['id', 'id=', 'id?'].include?(method_name)
+        end
+
         # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
         # primary_key_prefix_type setting, though.
         def primary_key
@@ -23,11 +56,11 @@ module ActiveRecord
         end
 
         def reset_primary_key #:nodoc:
-          key = self == base_class ? get_primary_key(base_class.name) :
-            base_class.primary_key
-
-          set_primary_key(key)
-          key
+          if self == base_class
+            self.primary_key = get_primary_key(base_class.name)
+          else
+            self.primary_key = base_class.primary_key
+          end
         end
 
         def get_primary_key(base_name) #:nodoc:
@@ -39,37 +72,41 @@ module ActiveRecord
           when :table_name_with_underscore
             base_name.foreign_key
           else
-            if ActiveRecord::Base != self && connection.table_exists?(table_name)
-              connection.primary_key(table_name)
+            if ActiveRecord::Base != self && table_exists?
+              connection.schema_cache.primary_keys[table_name]
             else
               'id'
             end
           end
         end
 
-        attr_accessor :original_primary_key
-
-        # Attribute writer for the primary key column
-        def primary_key=(value)
-          @quoted_primary_key = nil
-          @primary_key = value
-
-          connection_pool.primary_keys[table_name] = @primary_key if connected?
+        def original_primary_key #:nodoc:
+          deprecated_original_property_getter :primary_key
         end
 
-        # Sets the name of the primary key column to use to the given value,
-        # or (if the value is nil or false) to the value returned by the given
-        # block.
+        # Sets the name of the primary key column.
         #
         #   class Project < ActiveRecord::Base
-        #     set_primary_key "sysid"
+        #     self.primary_key = "sysid"
         #   end
-        def set_primary_key(value = nil, &block)
+        #
+        # You can also define the primary_key method yourself:
+        #
+        #   class Project < ActiveRecord::Base
+        #     def self.primary_key
+        #       "foo_" + super
+        #     end
+        #   end
+        #   Project.primary_key # => "foo_id"
+        def primary_key=(value)
+          @original_primary_key = @primary_key if defined?(@primary_key)
+          @primary_key          = value && value.to_s
+          @quoted_primary_key   = nil
+        end
+
+        def set_primary_key(value = nil, &block) #:nodoc:
+          deprecated_property_setter :primary_key, value, block
           @quoted_primary_key = nil
-          @primary_key ||= ''
-          self.original_primary_key = @primary_key
-          value &&= value.to_s
-          self.primary_key = block_given? ? instance_eval(&block) : value
         end
       end
     end

data/lib/active_record/attribute_methods/read.rb

@@ -6,13 +6,8 @@ module ActiveRecord
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
       included do
-        attribute_method_suffix ""
-
         cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
         self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-
-        # Undefine id so it can be used as an attribute name
-        undef_method(:id) if method_defined?(:id)
       end
 
       module ClassMethods
@@ -34,107 +29,102 @@ module ActiveRecord
           cached_attributes.include?(attr_name)
         end
 
-        protected
-          def define_method_attribute(attr_name)
-            if serialized_attributes.include?(attr_name)
-              define_read_method_for_serialized_attribute(attr_name)
-            else
-              define_read_method(attr_name, attr_name, columns_hash[attr_name])
-            end
+        def undefine_attribute_methods
+          generated_external_attribute_methods.module_eval do
+            instance_methods.each { |m| undef_method(m) }
+          end
+
+          super
+        end
 
-            if attr_name == primary_key && attr_name != "id"
-              define_read_method('id', attr_name, columns_hash[attr_name])
+        def type_cast_attribute(attr_name, attributes, cache = {}) #:nodoc:
+          return unless attr_name
+          attr_name = attr_name.to_s
+
+          if generated_external_attribute_methods.method_defined?(attr_name)
+            if attributes.has_key?(attr_name) || attr_name == 'id'
+              generated_external_attribute_methods.send(attr_name, attributes[attr_name], attributes, cache, attr_name)
             end
+          elsif !attribute_methods_generated?
+            # If we haven't generated the caster methods yet, do that and
+            # then try again
+            define_attribute_methods
+            type_cast_attribute(attr_name, attributes, cache)
+          else
+            # If we get here, the attribute has no associated DB column, so
+            # just return it verbatim.
+            attributes[attr_name]
+          end
+        end
+
+        protected
+          # We want to generate the methods via module_eval rather than define_method,
+          # because define_method is slower on dispatch and uses more memory (because it
+          # creates a closure).
+          #
+          # But sometimes the database might return columns with characters that are not
+          # allowed in normal method names (like 'my_column(omg)'. So to work around this
+          # we first define with the __temp__ identifier, and then use alias method to
+          # rename it to what we want.
+          def define_method_attribute(attr_name)
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def __temp__
+                #{internal_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
+              end
+              alias_method '#{attr_name}', :__temp__
+              undef_method :__temp__
+            STR
           end
 
         private
-          def cacheable_column?(column)
-            serialized_attributes.include?(column.name) || attribute_types_cached_by_default.include?(column.type)
+
+          def define_external_attribute_method(attr_name)
+            generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def __temp__(v, attributes, attributes_cache, attr_name)
+                #{external_attribute_access_code(attr_name, attribute_cast_code(attr_name))}
+              end
+              alias_method '#{attr_name}', :__temp__
+              undef_method :__temp__
+            STR
           end
 
-          # Define read method for serialized attribute.
-          def define_read_method_for_serialized_attribute(attr_name)
-            access_code = "@attributes_cache['#{attr_name}'] ||= @attributes['#{attr_name}']"
-            generated_attribute_methods.module_eval("def _#{attr_name}; #{access_code}; end; alias #{attr_name} _#{attr_name}", __FILE__, __LINE__)
+          def cacheable_column?(column)
+            attribute_types_cached_by_default.include?(column.type)
           end
 
-          # Define an attribute reader method.  Cope with nil column.
-          # method_name is the same as attr_name except when a non-standard primary key is used,
-          # we still define #id as an accessor for the key
-          def define_read_method(method_name, attr_name, column)
-            cast_code = column.type_cast_code('v')
-            access_code = "(v=@attributes['#{attr_name}']) && #{cast_code}"
+          def internal_attribute_access_code(attr_name, cast_code)
+            access_code = "(v=@attributes[attr_name]) && #{cast_code}"
 
-            unless attr_name.to_s == self.primary_key.to_s
-              access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+            unless attr_name == primary_key
+              access_code.insert(0, "missing_attribute(attr_name, caller) unless @attributes.has_key?(attr_name); ")
             end
 
             if cache_attribute?(attr_name)
-              access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
+              access_code = "@attributes_cache[attr_name] ||= (#{access_code})"
             end
 
-            # Where possible, generate the method by evalling a string, as this will result in
-            # faster accesses because it avoids the block eval and then string eval incurred
-            # by the second branch.
-            #
-            # The second, slower, branch is necessary to support instances where the database
-            # returns columns with extra stuff in (like 'my_column(omg)').
-            if method_name =~ ActiveModel::AttributeMethods::COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__
-                def _#{method_name}
-                  #{access_code}
-                end
-
-                alias #{method_name} _#{method_name}
-              STR
-            else
-              generated_attribute_methods.module_eval do
-                define_method("_#{method_name}") { eval(access_code) }
-                alias_method(method_name, "_#{method_name}")
-              end
-            end
+            "attr_name = '#{attr_name}'; #{access_code}"
           end
-      end
 
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-      # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
-      def read_attribute(attr_name)
-        method = "_#{attr_name}"
-        if respond_to? method
-          send method if @attributes.has_key?(attr_name.to_s)
-        else
-          _read_attribute attr_name
-        end
-      end
+          def external_attribute_access_code(attr_name, cast_code)
+            access_code = "v && #{cast_code}"
 
-      def _read_attribute(attr_name)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id'
-        value = @attributes[attr_name]
-        unless value.nil?
-          if column = column_for_attribute(attr_name)
-            if unserializable_attribute?(attr_name, column)
-              unserialize_attribute(attr_name)
-            else
-              column.type_cast(value)
+            if cache_attribute?(attr_name)
+              access_code = "attributes_cache[attr_name] ||= (#{access_code})"
             end
-          else
-            value
+
+            access_code
           end
-        end
-      end
 
-      # Returns true if the attribute is of a text column and marked for serialization.
-      def unserializable_attribute?(attr_name, column)
-        column.text? && self.class.serialized_attributes.include?(attr_name)
+          def attribute_cast_code(attr_name)
+            columns_hash[attr_name].type_cast_code('v')
+          end
       end
 
-      # Returns the unserialized object of the attribute.
-      def unserialize_attribute(attr_name)
-        coder = self.class.serialized_attributes[attr_name]
-        unserialized_object = coder.load(@attributes[attr_name])
-
-        @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+      # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name)
+        self.class.type_cast_attribute(attr_name, @attributes, @attributes_cache)
       end
 
       private