activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/associations/preloader/association.rb

@@ -2,16 +2,16 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association #:nodoc:
-        attr_reader :owners, :reflection, :preload_options, :model, :klass
-
-        def initialize(klass, owners, reflection, preload_options)
-          @klass           = klass
-          @owners          = owners
-          @reflection      = reflection
-          @preload_options = preload_options || {}
-          @model           = owners.first && owners.first.class
-          @scoped          = nil
-          @owners_by_key   = nil
+        attr_reader :owners, :reflection, :preload_scope, :model, :klass
+
+        def initialize(klass, owners, reflection, preload_scope)
+          @klass         = klass
+          @owners        = owners
+          @reflection    = reflection
+          @preload_scope = preload_scope
+          @model         = owners.first && owners.first.class
+          @scope         = nil
+          @owners_by_key = nil
         end
 
         def run
@@ -24,12 +24,12 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        def scoped
-          @scoped ||= build_scope
+        def scope
+          @scope ||= build_scope
         end
 
         def records_for(ids)
-          scoped.where(association_key.in(ids))
+          scope.where(association_key.in(ids))
         end
 
         def table
@@ -76,8 +76,8 @@ module ActiveRecord
           else
             # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
             # Make several smaller queries if necessary or make one query if the adapter supports it
-            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
-            records = sliced.map { |slice| records_for(slice) }.flatten
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice).to_a }.flatten
           end
 
           # Each record may have multiple owners, and vice-versa
@@ -92,33 +92,29 @@ module ActiveRecord
           records_by_owner
         end
 
+        def reflection_scope
+          @reflection_scope ||= reflection.scope ? klass.unscoped.instance_exec(nil, &reflection.scope) : klass.unscoped
+        end
+
         def build_scope
-          scope = klass.scoped
+          scope = klass.unscoped
+          scope.default_scoped = true
 
-          scope = scope.where(process_conditions(options[:conditions]))
-          scope = scope.where(process_conditions(preload_options[:conditions]))
+          values         = reflection_scope.values
+          preload_values = preload_scope.values
 
-          scope = scope.select(preload_options[:select] || options[:select] || table[Arel.star])
-          scope = scope.includes(preload_options[:include] || options[:include])
+          scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+          scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+
+          scope.select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope.includes! preload_values[:includes] || values[:includes]
 
           if options[:as]
-            scope = scope.where(
-              klass.table_name => {
-                reflection.type => model.base_class.sti_name
-              }
-            )
+            scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
           end
 
           scope
         end
-
-        def process_conditions(conditions)
-          if conditions.respond_to?(:to_proc) && !conditions.is_a?(Hash)
-            conditions = klass.send(:instance_eval, &conditions)
-          end
-
-          conditions
-        end
       end
     end
   end

data/lib/active_record/associations/preloader/collection_association.rb

@@ -6,7 +6,7 @@ module ActiveRecord
         private
 
         def build_scope
-          super.order(preload_options[:order] || options[:order])
+          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
         end
 
         def preload

data/lib/active_record/associations/preloader/has_and_belongs_to_many.rb

@@ -6,7 +6,7 @@ module ActiveRecord
 
         def initialize(klass, records, reflection, preload_options)
           super
-          @join_table = Arel::Table.new(options[:join_table]).alias('t0')
+          @join_table = Arel::Table.new(reflection.join_table).alias('t0')
         end
 
         # Unlike the other associations, we want to get a raw array of rows so that we can

data/lib/active_record/associations/preloader/has_many_through.rb

@@ -6,7 +6,7 @@ module ActiveRecord
 
         def associated_records_by_owner
           super.each do |owner, records|
-            records.uniq! if options[:uniq]
+            records.uniq! if reflection_scope.uniq_value
           end
         end
       end

data/lib/active_record/associations/preloader/has_one.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         private
 
         def build_scope
-          super.order(preload_options[:order] || options[:order])
+          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
         end
 
       end

data/lib/active_record/associations/preloader/through_association.rb

@@ -14,10 +14,7 @@ module ActiveRecord
         def associated_records_by_owner
           through_records = through_records_by_owner
 
-          ActiveRecord::Associations::Preloader.new(
-            through_records.values.flatten,
-            source_reflection.name, options
-          ).run
+          Preloader.new(through_records.values.flatten, source_reflection.name, reflection_scope).run
 
           through_records.each do |owner, records|
             records.map! { |r| r.send(source_reflection.name) }.flatten!
@@ -28,16 +25,13 @@ module ActiveRecord
         private
 
         def through_records_by_owner
-          ActiveRecord::Associations::Preloader.new(
-            owners, through_reflection.name,
-            through_options
-          ).run
+          Preloader.new(owners, through_reflection.name, through_scope).run
 
           Hash[owners.map do |owner|
             through_records = Array.wrap(owner.send(through_reflection.name))
 
             # Dont cache the association - we would only be caching a subset
-            if (preload_options != through_options) ||
+            if (through_scope != through_reflection.klass.unscoped) ||
                (reflection.options[:source_type] && through_reflection.collection?)
               owner.association(through_reflection.name).reset
             end
@@ -46,20 +40,22 @@ module ActiveRecord
           end]
         end
 
-        def through_options
-          through_options = {}
+        def through_scope
+          through_scope = through_reflection.klass.unscoped
 
           if options[:source_type]
-            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+            through_scope.where! reflection.foreign_type => options[:source_type]
           else
-            if options[:conditions]
-              through_options[:include]    = options[:include] || options[:source]
-              through_options[:conditions] = options[:conditions]
+            unless reflection_scope.where_values.empty?
+              through_scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+              through_scope.where_values    = reflection_scope.values[:where]
             end
-            through_options[:order] = options[:order] if options.has_key?(:order)
+
+            through_scope.references! reflection_scope.values[:references]
+            through_scope.order! reflection_scope.values[:order] if through_scope.eager_loading?
           end
 
-          through_options
+          through_scope
         end
       end
     end

data/lib/active_record/associations/singular_association.rb

@@ -12,21 +12,21 @@ module ActiveRecord
         target
       end
 
-      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
       def writer(record)
         replace(record)
       end
 
-      def create(attributes = {}, options = {}, &block)
-        create_record(attributes, options, &block)
+      def create(attributes = {}, &block)
+        create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, options = {}, &block)
-        create_record(attributes, options, true, &block)
+      def create!(attributes = {}, &block)
+        create_record(attributes, true, &block)
       end
 
-      def build(attributes = {}, options = {})
-        record = build_record(attributes, options)
+      def build(attributes = {})
+        record = build_record(attributes)
         yield(record) if block_given?
         set_new_record(record)
         record
@@ -35,11 +35,11 @@ module ActiveRecord
       private
 
         def create_scope
-          scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+          scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
         def find_target
-          scoped.first.tap { |record| set_inverse_instance(record) }
+          scope.first.tap { |record| set_inverse_instance(record) }
         end
 
         # Implemented by subclasses
@@ -51,8 +51,8 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, options, raise_error = false)
-          record = build_record(attributes, options)
+        def create_record(attributes, raise_error = false)
+          record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save
           set_new_record(record)

data/lib/active_record/associations/through_association.rb

@@ -15,7 +15,7 @@ module ActiveRecord
           scope = super
           chain[1..-1].each do |reflection|
             scope = scope.merge(
-              reflection.klass.scoped.with_default_scope.
+              reflection.klass.all.with_default_scope.
                 except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
@@ -28,7 +28,7 @@ module ActiveRecord
         # methods which create and delete records on the association.
         #
         # We only support indirectly modifying through associations which has a belongs_to source.
-        # This is the "has_many :tags, :through => :taggings" situation, where the join model
+        # This is the "has_many :tags, through: :taggings" situation, where the join model
         # typically has a belongs_to on both side. In other words, associations which could also
         # be represented as has_and_belongs_to_many associations.
         #

data/lib/active_record/attribute_assignment.rb

@@ -1,206 +1,91 @@
-require 'active_support/concern'
 
 module ActiveRecord
   module AttributeAssignment
     extend ActiveSupport::Concern
-    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::DeprecatedMassAssignmentSecurity
+    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.
-    #
-    #   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 = {})
+    # 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.
+    def assign_attributes(new_attributes)
       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
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise UnknownAttributeError, "unknown attribute: #{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 Fixnum 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 = { }
 
-      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 +102,100 @@ module ActiveRecord
       multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
     end
 
+    class MultiparameterAttribute #:nodoc:
+      attr_reader :object, :name, :values, :column
+
+      def initialize(object, name, values)
+        @object = object
+        @name   = name
+        @values = values
+      end
+
+      def read_value
+        return if values.values.compact.empty?
+
+        @column = object.class.reflect_on_aggregation(name.to_sym) || object.column_for_attribute(name)
+        klass   = column.klass
+
+        if klass == Time
+          read_time
+        elsif klass == Date
+          read_date
+        else
+          read_other(klass)
+        end
+      end
+
+      private
+
+      def instantiate_time_object(set_values)
+        if object.class.send(:create_time_zone_conversion_attribute?, name, column)
+          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 :timestamp) there is no need to validate if
+        # there are year/month/day fields
+        if column.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_missing_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(klass)
+        max_position = extract_max_param
+        positions    = (1..max_position)
+        validate_missing_parameters!(positions)
+
+        set_values = values.values_at(*positions)
+        klass.new(*set_values)
+      end
+
+      # Checks whether some blank date parameter exists. Note that this is different
+      # than the validate_missing_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_missing_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