activerecord 4.0.0.beta1 → 4.0.0.rc1

data/lib/active_record/associations/collection_proxy.rb

@@ -83,16 +83,16 @@ module ActiveRecord
       #   #      #<Pet id: 3, name: "Choo-Choo">
       #   #    ]
       #
-      # Be careful because this also means you’re initializing a model
-      # object with only the fields that you’ve selected. If you attempt
-      # to access a field that is not in the initialized record you’ll
+      # Be careful because this also means you're initializing a model
+      # object with only the fields that you've selected. If you attempt
+      # to access a field that is not in the initialized record you'll
       # receive:
       #
       #   person.pets.select(:name).first.person_id
       #   # => ActiveModel::MissingAttributeError: missing attribute: person_id
       #
       # *Second:* You can pass a block so it can be used just like Array#select.
-      # This build an array of objects from the database for the scope,
+      # This builds an array of objects from the database for the scope,
       # converting them into an array and iterating through them using
       # Array#select.
       #
@@ -228,6 +228,7 @@ module ActiveRecord
       def build(attributes = {}, &block)
         @association.build(attributes, &block)
       end
+      alias_method :new, :build
 
       # Returns a new object of the collection type that has been instantiated with
       # attributes, linked to this object and that has already been saved (if it
@@ -303,7 +304,7 @@ module ActiveRecord
         @association.concat(*records)
       end
 
-      # Replace this collection with +other_array+. This will perform a diff
+      # Replaces this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       #
       #   class Person < ActiveRecord::Base
@@ -649,11 +650,12 @@ module ActiveRecord
       #   #      #<Pet name: "Fancy-Fancy">
       #   #    ]
       #
-      #   person.pets.select(:name).uniq
+      #   person.pets.select(:name).distinct
       #   # => [#<Pet name: "Fancy-Fancy">]
-      def uniq
-        @association.uniq
+      def distinct
+        @association.distinct
       end
+      alias uniq distinct
 
       # Count all records using SQL.
       #
@@ -831,8 +833,6 @@ module ActiveRecord
         @association.include?(record)
       end
 
-      alias_method :new, :build
-
       def proxy_association
         @association
       end
@@ -847,10 +847,8 @@ module ActiveRecord
 
       # Returns a <tt>Relation</tt> object for the records in this association
       def scope
-        association = @association
-
-        @association.scope.extending! do
-          define_method(:proxy_association) { association }
+        @association.scope.tap do |scope|
+          scope.proxy_association = @association
         end
       end
 
@@ -924,7 +922,7 @@ module ActiveRecord
       alias_method :to_a, :to_ary
 
       # Adds one or more +records+ to the collection by setting their foreign keys
-      # to the association‘s primary key. Returns +self+, so several appends may be
+      # to the association's primary key. Returns +self+, so several appends may be
       # chained together.
       #
       #   class Person < ActiveRecord::Base
@@ -947,6 +945,11 @@ module ActiveRecord
         proxy_association.concat(records) && self
       end
       alias_method :push, :<<
+      alias_method :append, :<<
+
+      def prepend(*args)
+        raise NoMethodError, "prepend on association is not defined. Please use << or append"
+      end
 
       # Equivalent to +delete_all+. The difference is that returns +self+, instead
       # of an array with the deleted objects, so methods can be chained. See

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -26,7 +26,7 @@ module ActiveRecord
             join_table[reflection.association_foreign_key] => record.id
           )
 
-          owner.connection.insert stmt
+          owner.class.connection.insert stmt
         end
 
         record
@@ -41,7 +41,7 @@ module ActiveRecord
         def delete_records(records, method)
           if sql = options[:delete_sql]
             records = load_target if records == :all
-            records.each { |record| owner.connection.delete(interpolate(sql, record)) }
+            records.each { |record| owner.class.connection.delete(interpolate(sql, record)) }
           else
             relation  = join_table
             condition = relation[reflection.foreign_key].eq(owner.id)
@@ -53,7 +53,7 @@ module ActiveRecord
               )
             end
 
-            owner.connection.delete(relation.where(condition).compile_delete)
+            owner.class.connection.delete(relation.where(condition).compile_delete)
           end
         end
 

data/lib/active_record/associations/has_many_association.rb

@@ -22,10 +22,11 @@ module ActiveRecord
         else
           if options[:dependent] == :destroy
             # No point in executing the counter update since we're going to destroy the parent anyway
-            load_target.each(&:mark_for_destruction)
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
           end
-
-          delete_all
         end
       end
 

data/lib/active_record/associations/has_many_through_association.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       def concat(*records)
         unless owner.new_record?
           records.flatten.each do |record|
-            raise_on_type_mismatch(record)
+            raise_on_type_mismatch!(record)
             record.save! if record.new_record?
           end
         end

data/lib/active_record/associations/has_one_association.rb

@@ -22,7 +22,7 @@ module ActiveRecord
       end
 
       def replace(record, save = true)
-        raise_on_type_mismatch(record) if record
+        raise_on_type_mismatch!(record) if record
         load_target
 
         # If target and record are nil, or target is equal to record,

data/lib/active_record/associations/join_dependency.rb

@@ -5,10 +5,31 @@ module ActiveRecord
       autoload :JoinBase,        'active_record/associations/join_dependency/join_base'
       autoload :JoinAssociation, 'active_record/associations/join_dependency/join_association'
 
-      attr_reader :join_parts, :reflections, :alias_tracker, :active_record
-
+      attr_reader :join_parts, :reflections, :alias_tracker, :base_klass
+
+      # base is the base class on which operation is taking place.
+      # associations is the list of associations which are joined using hash, symbol or array.
+      # joins is the list of all string join commnads and arel nodes.
+      #
+      #  Example :
+      #
+      #  class Physician < ActiveRecord::Base
+      #    has_many :appointments
+      #    has_many :patients, through: :appointments
+      #  end
+      #
+      #  If I execute `@physician.patients.to_a` then
+      #    base #=> Physician
+      #    associations #=> []
+      #    joins #=>  [#<Arel::Nodes::InnerJoin: ...]
+      #
+      #  However if I execute `Physician.joins(:appointments).to_a` then
+      #    base #=> Physician
+      #    associations #=> [:appointments]
+      #    joins #=>  []
+      #
       def initialize(base, associations, joins)
-        @active_record = base
+        @base_klass    = base
         @table_joins   = joins
         @join_parts    = [JoinBase.new(base)]
         @associations  = {}
@@ -54,10 +75,12 @@ module ActiveRecord
           parent
         }.uniq
 
-        remove_duplicate_results!(active_record, records, @associations)
+        remove_duplicate_results!(base_klass, records, @associations)
         records
       end
 
+      protected
+
       def remove_duplicate_results!(base, records, associations)
         case associations
         when Symbol, String
@@ -88,8 +111,6 @@ module ActiveRecord
         end
       end
 
-      protected
-
       def cache_joined_association(association)
         associations = []
         parent = association.parent
@@ -108,8 +129,8 @@ module ActiveRecord
         parent ||= join_parts.last
         case associations
         when Symbol, String
-          reflection = parent.reflections[associations.to_s.intern] or
-          raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+          reflection = parent.reflections[associations.intern] or
+          raise ConfigurationError, "Association named '#{ associations }' was not found on #{ parent.base_klass.name }; perhaps you misspelled it?"
           unless join_association = find_join_association(reflection, parent)
             @reflections << reflection
             join_association = build_join_association(reflection, parent)

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

@@ -55,14 +55,19 @@ module ActiveRecord
 
         def find_parent_in(other_join_dependency)
           other_join_dependency.join_parts.detect do |join_part|
-            parent == join_part
+            case parent
+            when JoinBase
+              parent.base_klass == join_part.base_klass
+            else
+              parent == join_part
+            end
           end
         end
 
-        def join_to(relation)
+        def join_to(manager)
           tables        = @tables.dup
           foreign_table = parent_table
-          foreign_klass = parent.active_record
+          foreign_klass = parent.base_klass
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
@@ -75,7 +80,7 @@ module ActiveRecord
               foreign_key = reflection.foreign_key
             when :has_and_belongs_to_many
               # Join the join table first...
-              relation.from(join(
+              manager.from(join(
                 table,
                 table[reflection.foreign_key].
                   eq(foreign_table[reflection.active_record_primary_key])
@@ -109,15 +114,30 @@ module ActiveRecord
               constraint = constraint.and(item.arel.constraints) unless item.arel.constraints.empty?
             end
 
-            relation.from(join(table, constraint))
+            manager.from(join(table, constraint))
 
             # The current table in this iteration becomes the foreign table in the next
             foreign_table, foreign_klass = table, reflection.klass
           end
 
-          relation
+          manager
         end
 
+        #  Builds equality condition.
+        #
+        #  Example:
+        #
+        #  class Physician < ActiveRecord::Base
+        #    has_many :appointments
+        #  end
+        #
+        #  If I execute `Physician.joins(:appointments).to_a` then
+        #    reflection    #=> #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
+        #    table         #=> #<Arel::Table @name="appointments" ...>
+        #    key           #=>  physician_id
+        #    foreign_table #=> #<Arel::Table @name="physicians" ...>
+        #    foreign_key   #=> id
+        #
         def build_constraint(reflection, table, key, foreign_table, foreign_key)
           constraint = table[key].eq(foreign_table[foreign_key])
 

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

@@ -4,7 +4,7 @@ module ActiveRecord
       class JoinBase < JoinPart # :nodoc:
         def ==(other)
           other.class == self.class &&
-            other.active_record == active_record
+            other.base_klass == base_klass
         end
 
         def aliased_prefix
@@ -16,7 +16,7 @@ module ActiveRecord
         end
 
         def aliased_table_name
-          active_record.table_name
+          base_klass.table_name
         end
       end
     end

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

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
+      # A JoinPart represents a part of a JoinDependency. It is inherited
       # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
       # everything else is being joined onto. A JoinAssociation represents an association which
       # is joining to the base. A JoinAssociation may result in more than one actual join
@@ -11,12 +11,12 @@ module ActiveRecord
         # The Active Record class which this join part is associated 'about'; for a JoinBase
         # this is the actual base model, for a JoinAssociation this is the target model of the
         # association.
-        attr_reader :active_record
+        attr_reader :base_klass
 
-        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :active_record
+        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :base_klass
 
-        def initialize(active_record)
-          @active_record = active_record
+        def initialize(base_klass)
+          @base_klass = base_klass
           @cached_record = {}
           @column_names_with_alias = nil
         end
@@ -70,7 +70,7 @@ module ActiveRecord
         end
 
         def instantiate(row)
-          @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
+          @cached_record[record_id(row)] ||= base_klass.instantiate(extract_record(row))
         end
       end
     end

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

@@ -35,7 +35,7 @@ module ActiveRecord
         # record
         def associated_records_by_owner
           records = {}
-          super.each do |owner_key, rows|
+          super.each_value do |rows|
             rows.map! { |row| records[row[klass.primary_key]] ||= klass.instantiate(row) }
           end
         end

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

@@ -5,9 +5,13 @@ module ActiveRecord
         include ThroughAssociation
 
         def associated_records_by_owner
-          super.each do |owner, records|
-            records.uniq! if reflection_scope.uniq_value
+          records_by_owner = super
+
+          if reflection_scope.distinct_value
+            records_by_owner.each_value { |records| records.uniq! }
           end
+
+          records_by_owner
         end
       end
     end

data/lib/active_record/associations/through_association.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         def target_scope
           scope = super
           chain[1..-1].each do |reflection|
-            scope = scope.merge(
+            scope.merge!(
               reflection.klass.all.with_default_scope.
                 except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )

data/lib/active_record/attribute_assignment.rb

@@ -81,7 +81,7 @@ module ActiveRecord
     end
 
     def extract_callstack_for_multiparameter_attributes(pairs)
-      attributes = { }
+      attributes = {}
 
       pairs.each do |(multiparameter_name, value)|
         attribute_name = multiparameter_name.split("(").first
@@ -146,7 +146,7 @@ module ActiveRecord
           end
         else
           # else column is a timestamp, so if Date bits were not provided, error
-          validate_missing_parameters!([1,2,3])
+          validate_required_parameters!([1,2,3])
 
           # If Date bits were provided but blank, then return nil
           return if blank_date_parameter?
@@ -172,14 +172,14 @@ module ActiveRecord
       def read_other(klass)
         max_position = extract_max_param
         positions    = (1..max_position)
-        validate_missing_parameters!(positions)
+        validate_required_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
+      # 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?
@@ -187,7 +187,7 @@ module ActiveRecord
       end
 
       # If some position is not provided, it errors out a missing parameter exception.
-      def validate_missing_parameters!(positions)
+      def validate_required_parameters!(positions)
         if missing_parameter = positions.detect { |position| !values.key?(position) }
           raise ArgumentError.new("Missing Parameter - #{name}(#{missing_parameter})")
         end

data/lib/active_record/attribute_methods.rb

@@ -21,7 +21,7 @@ module ActiveRecord
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods # :nodoc:
-        # Use a mutex; we don't want two thread simaltaneously trying to define
+        # Use a mutex; we don't want two thread simultaneously trying to define
         # attribute methods.
         @attribute_methods_mutex.synchronize do
           return if attribute_methods_generated?
@@ -56,7 +56,7 @@ module ActiveRecord
       #   # => false
       def instance_method_already_implemented?(method_name)
         if dangerous_attribute_method?(method_name)
-          raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord"
+          raise DangerousAttributeError, "#{method_name} is defined by Active Record"
         end
 
         if superclass == Base
@@ -163,8 +163,22 @@ module ActiveRecord
     #   person.respond_to('age?')   # => true
     #   person.respond_to(:nothing) # => false
     def respond_to?(name, include_private = false)
+      name = name.to_s
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
-      super
+      result = super
+
+      # If the result is false the answer is false.
+      return false unless result
+
+      # If the result is true then check for the select case.
+      # For queries selecting a subset of columns, return false for unselected columns.
+      # We check defined?(@attributes) not to issue warnings if called on objects that
+      # have been allocated but not yet initialized.
+      if defined?(@attributes) && @attributes.present? && self.class.column_names.include?(name)
+        return has_attribute?(name)
+      end
+
+      return true
     end
 
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
@@ -328,13 +342,14 @@ module ActiveRecord
     end
 
     def attribute_method?(attr_name) # :nodoc:
+      # We check defined? because Syck calls respond_to? before actually calling initialize.
       defined?(@attributes) && @attributes.include?(attr_name)
     end
 
     private
 
     # Returns a Hash of the Arel::Attributes and attribute values that have been
-    # type casted for use in an Arel insert/update method.
+    # typecasted for use in an Arel insert/update method.
     def arel_attributes_with_values(attribute_names)
       attrs = {}
       arel_table = self.class.arel_table
@@ -348,7 +363,7 @@ module ActiveRecord
     # Filters the primary keys and readonly attributes from the attribute names.
     def attributes_for_update(attribute_names)
       attribute_names.select do |name|
-        column_for_attribute(name) && !pk_attribute?(name) && !readonly_attribute?(name)
+        column_for_attribute(name) && !readonly_attribute?(name)
       end
     end