activerecord 3.1.0.beta1 → 3.1.0.rc1

data/lib/active_record/associations/collection_proxy.rb

@@ -64,9 +64,12 @@ module ActiveRecord
 
       def method_missing(method, *args, &block)
         match = DynamicFinderMatch.match(method)
-        if match && match.creator?
-          attributes = match.attribute_names
-          return send(:"find_by_#{attributes.join('_and_')}", *args) || create(Hash[attributes.zip(args)])
+        if match && match.instantiator?
+          record = send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
+            @association.send :set_owner_attributes, r
+            @association.send :add_to_target, r
+            yield(r) if block_given?
+          end
         end
 
         if target.respond_to?(method) || (!@association.klass.respond_to?(method) && Class.respond_to?(method))
@@ -120,6 +123,30 @@ module ActiveRecord
           method_missing(:new, *args, &block)
         end
       end
+
+      def proxy_owner
+        ActiveSupport::Deprecation.warn(
+          "Calling record.#{@association.reflection.name}.proxy_owner is deprecated. Please use " \
+          "record.association(:#{@association.reflection.name}).owner instead."
+        )
+        @association.owner
+      end
+
+      def proxy_target
+        ActiveSupport::Deprecation.warn(
+          "Calling record.#{@association.reflection.name}.proxy_target is deprecated. Please use " \
+          "record.association(:#{@association.reflection.name}).target instead."
+        )
+        @association.target
+      end
+
+      def proxy_reflection
+        ActiveSupport::Deprecation.warn(
+          "Calling record.#{@association.reflection.name}.proxy_reflection is deprecated. Please use " \
+          "record.association(:#{@association.reflection.name}).reflection instead."
+        )
+        @association.reflection
+      end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -10,7 +10,7 @@ module ActiveRecord
 
         reflection.klass.transaction do
           if target && target != record
-            remove_target!(options[:dependent])
+            remove_target!(options[:dependent]) unless target.destroyed?
           end
 
           if record

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -91,12 +91,12 @@ module ActiveRecord
 
             constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
 
-            relation.from(join(table, constraint))
-
             unless conditions[i].empty?
-              relation.where(sanitize(conditions[i], table))
+              constraint = constraint.and(sanitize(conditions[i], table))
             end
 
+            relation.from(join(table, constraint))
+
             # The current table in this iteration becomes the foreign table in the next
             foreign_table = table
           end

data/lib/active_record/associations/join_helper.rb

@@ -32,7 +32,7 @@ module ActiveRecord
       end
 
       def table_alias_for(reflection, join = false)
-        name = alias_tracker.pluralize(reflection.name)
+        name = alias_tracker.pluralize(reflection.name, reflection.active_record)
         name << "_#{alias_suffix}"
         name << "_join" if join
         name

data/lib/active_record/associations/singular_association.rb

@@ -17,20 +17,28 @@ module ActiveRecord
         replace(record)
       end
 
-      def create(attributes = {}, options = {})
-        new_record(:create, attributes, options)
+      def create(attributes = {}, options = {}, &block)
+        build(attributes, options, &block).tap { |record| record.save }
       end
 
-      def create!(attributes = {}, options = {})
-        build(attributes, options).tap { |record| record.save! }
+      def create!(attributes = {}, options = {}, &block)
+        build(attributes, options, &block).tap { |record| record.save! }
       end
 
       def build(attributes = {}, options = {})
-        new_record(:build, attributes, options)
+        record = reflection.build_association(attributes, options)
+        record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
+        yield(record) if block_given?
+        set_new_record(record)
+        record
       end
 
       private
 
+        def create_scope
+          scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+        end
+
         def find_target
           scoped.first.tap { |record| set_inverse_instance(record) }
         end
@@ -43,13 +51,6 @@ module ActiveRecord
         def set_new_record(record)
           replace(record)
         end
-
-        def new_record(method, attributes, options)
-          attributes = scoped.scope_for_create.merge(attributes || {})
-          record = reflection.send("#{method}_association", attributes, options)
-          set_new_record(record)
-          record
-        end
     end
   end
 end

data/lib/active_record/associations/through_association.rb

@@ -14,7 +14,10 @@ module ActiveRecord
         def target_scope
           scope = super
           chain[1..-1].each do |reflection|
-            scope = scope.merge(reflection.klass.scoped)
+            scope = scope.merge(
+              reflection.klass.scoped.with_default_scope.
+                except(:select, :create_with)
+            )
           end
           scope
         end

data/lib/active_record/base.rb

@@ -393,8 +393,8 @@ module ActiveRecord #:nodoc:
     # Indicates whether table names should be the pluralized versions of the corresponding class names.
     # If true, the default table name for a Product class will be +products+. If false, it would just be +product+.
     # See table_name for the full rules on table/class naming. This is true, by default.
-    cattr_accessor :pluralize_table_names, :instance_writer => false
-    @@pluralize_table_names = true
+    class_attribute :pluralize_table_names, :instance_writer => false
+    self.pluralize_table_names = true
 
     ##
     # :singleton-method:
@@ -482,7 +482,7 @@ module ActiveRecord #:nodoc:
       #   # Create a single new object
       #   User.create(:first_name => 'Jamie')
       #
-      #   # Create a single new object using the :admin mass-assignment security scope
+      #   # Create a single new object using the :admin mass-assignment security role
       #   User.create({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)
       #
       #   # Create a single new object bypassing mass-assignment security
@@ -577,15 +577,25 @@ module ActiveRecord #:nodoc:
       #
       # ==== Examples
       #
-      #   class Invoice < ActiveRecord::Base; end;
+      #   class Invoice < ActiveRecord::Base
+      #   end
+      #
       #   file                  class               table_name
       #   invoice.rb            Invoice             invoices
       #
-      #   class Invoice < ActiveRecord::Base; class Lineitem < ActiveRecord::Base; end; end;
+      #   class Invoice < ActiveRecord::Base
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
       #   file                  class               table_name
       #   invoice.rb            Invoice::Lineitem   invoice_lineitems
       #
-      #   module Invoice; class Lineitem < ActiveRecord::Base; end; end;
+      #   module Invoice
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
       #   file                  class               table_name
       #   invoice/lineitem.rb   Invoice::Lineitem   lineitems
       #
@@ -767,6 +777,17 @@ module ActiveRecord #:nodoc:
         super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, '')))
       end
 
+      # Returns an array of column names as strings if it's not
+      # an abstract class and table exists.
+      # Otherwise it returns an empty array.
+      def attribute_names
+        @attribute_names ||= if !abstract_class? && table_exists?
+            column_names
+          else
+            []
+          end
+      end
+
       # Set the lookup ancestors for ActiveModel.
       def lookup_ancestors #:nodoc:
         klass = self
@@ -830,6 +851,10 @@ module ActiveRecord #:nodoc:
         @symbolized_base_class ||= base_class.to_s.to_sym
       end
 
+      def symbolized_sti_name
+        @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
+      end
+
       # Returns the base AR subclass that this class descends from. If A
       # extends AR::Base, A.base_class will return A. If B descends from A
       # through some arbitrarily deep hierarchy, B.base_class will return A.
@@ -891,7 +916,7 @@ module ActiveRecord #:nodoc:
       # not use the default_scope:
       #
       #   Post.unscoped {
-      #     limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+      #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
       #   }
       #
       # It is recommended to use block form of unscoped because chaining unscoped with <tt>scope</tt>
@@ -1482,7 +1507,7 @@ MSG
       #   # Instantiates a single new object
       #   User.new(:first_name => 'Jamie')
       #
-      #   # Instantiates a single new object using the :admin mass-assignment security scope
+      #   # Instantiates a single new object using the :admin mass-assignment security role
       #   User.new({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)
       #
       #   # Instantiates a single new object bypassing mass-assignment security
@@ -1648,17 +1673,16 @@ MSG
 
         return unless new_attributes.is_a?(Hash)
 
-        guard_protected_attributes ||= true
-        if guard_protected_attributes
-          assign_attributes(new_attributes)
-        else
+        if guard_protected_attributes == false
           assign_attributes(new_attributes, :without_protection => true)
+        else
+          assign_attributes(new_attributes)
         end
       end
 
       # Allows you to set all the attributes for a particular mass-assignment
-      # security scope by passing in a hash of attributes with keys matching
-      # the attribute names (which again matches the column names) and the scope
+      # 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
@@ -1684,13 +1708,15 @@ MSG
       #   user.name       # => "Josh"
       #   user.is_admin?  # => true
       def assign_attributes(new_attributes, options = {})
+        return unless new_attributes
+
         attributes = new_attributes.stringify_keys
-        scope = options[:as] || :default
+        role = options[:as] || :default
 
         multi_parameter_attributes = []
 
         unless options[:without_protection]
-          attributes = sanitize_for_mass_assignment(attributes, scope)
+          attributes = sanitize_for_mass_assignment(attributes, role)
         end
 
         attributes.each do |k, v|
@@ -1943,32 +1969,9 @@ MSG
         errors = []
         callstack.each do |name, values_with_empty_parameters|
           begin
-            klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
-            # in order to allow a date to be set without a year, we must keep the empty values.
-            # Otherwise, we wouldn't be able to distinguish it from a date with an empty day.
-            values = values_with_empty_parameters.reject { |v| v.nil? }
-
-            if values.empty?
-              send(name + "=", nil)
-            else
-
-              value = if Time == klass
-                instantiate_time_object(name, values)
-              elsif Date == klass
-                begin
-                  values = values_with_empty_parameters.collect do |v| v.nil? ? 1 : v end
-                  Date.new(*values)
-                rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
-                  instantiate_time_object(name, values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
-                end
-              else
-                klass.new(*values)
-              end
-
-              send(name + "=", value)
-            end
+            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
           rescue => ex
-            errors << AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
+            errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name}", ex, name)
           end
         end
         unless errors.empty?
@@ -1976,19 +1979,65 @@ MSG
         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)
+        set_values = (1..max_position).collect{|position| values_hash_from_param[position] }
+        # If Date bits were provided but blank, then default to 1
+        # If Time bits are not there, then default to 0
+        [1,1,1,0,0,0].each_with_index{|v,i| set_values[i] = set_values[i].blank? ? v : set_values[i]}
+        instantiate_time_object(name, set_values)
+      end
+
+      def read_date_parameter_value(name, values_hash_from_param)
+        set_values = (1..3).collect{|position| values_hash_from_param[position].blank? ? 1 : values_hash_from_param[position]}
+        begin
+          Date.new(*set_values)
+        rescue ArgumentError => ex # 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 = { }
 
-        for pair in pairs
+        pairs.each do |pair|
           multiparameter_name, value = pair
           attribute_name = multiparameter_name.split("(").first
-          attributes[attribute_name] = [] unless attributes.include?(attribute_name)
+          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 ]
+          attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
         end
 
-        attributes.each { |name, values| attributes[name] = values.sort_by{ |v| v.first }.collect { |v| v.last } }
+        attributes
       end
 
       def type_cast_attribute_value(multiparameter_name, value)
@@ -1996,7 +2045,7 @@ MSG
       end
 
       def find_parameter_position(multiparameter_name)
-        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
       end
 
       # Returns a comma-separated pair list, like "key1 = val1, key2 = val2".

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -6,15 +6,7 @@ module ActiveRecord
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
       def select_all(sql, name = nil, binds = [])
-        if supports_statement_cache?
-          select(sql, name, binds)
-        else
-          return select(sql, name) if binds.empty?
-          binds = binds.dup
-          select sql.gsub('?') {
-            quote(*binds.shift.reverse)
-          }, name
-        end
+        select(sql, name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values

data/lib/active_record/connection_adapters/column.rb

@@ -189,7 +189,7 @@ module ActiveRecord
 
           def new_time(year, mon, mday, hour, min, sec, microsec)
             # Treat 0000-00-00 00:00:00 as nil.
-            return nil if year.nil? || year == 0
+            return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
 
             Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
           end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -184,6 +184,10 @@ module ActiveRecord
         QUOTED_FALSE
       end
 
+      def substitute_at(column, index)
+        Arel.sql "\0"
+      end
+
       # REFERENTIAL INTEGRITY ====================================
 
       def disable_referential_integrity(&block) #:nodoc:
@@ -292,14 +296,14 @@ module ActiveRecord
         binds = binds.dup
 
         # Pretend to support bind parameters
-        execute sql.gsub('?') { quote(*binds.shift.reverse) }, name
+        execute sql.gsub("\0") { quote(*binds.shift.reverse) }, name
       end
 
       def exec_delete(sql, name, binds)
         binds = binds.dup
 
         # Pretend to support bind parameters
-        execute sql.gsub('?') { quote(*binds.shift.reverse) }, name
+        execute sql.gsub("\0") { quote(*binds.shift.reverse) }, name
         @connection.affected_rows
       end
       alias :exec_update :exec_delete
@@ -646,7 +650,8 @@ module ActiveRecord
         # Returns an array of record hashes with the column names as keys and
         # column values as values.
         def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds).to_a
+          binds = binds.dup
+          exec_query(sql.gsub("\0") { quote(*binds.shift.reverse) }, name).to_a
         end
 
         def exec_query(sql, name = 'SQL', binds = [])