activerecord 2.3.5 → 2.3.6

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -244,8 +244,8 @@ module ActiveRecord
         column ? column['name'] : nil
       end
 
-      def remove_index(table_name, options={}) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name)}"
       end
 
       def rename_table(name, new_name)

data/lib/active_record/dirty.rb

@@ -167,13 +167,13 @@ module ActiveRecord
 
     module ClassMethods
       def self.extended(base)
-        base.metaclass.alias_method_chain(:alias_attribute, :dirty)
+        base.singleton_class.alias_method_chain(:alias_attribute, :dirty)
       end
 
       def alias_attribute_with_dirty(new_name, old_name)
         alias_attribute_without_dirty(new_name, old_name)
         DIRTY_SUFFIXES.each do |suffix|
-          module_eval <<-STR, __FILE__, __LINE__+1
+          module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{new_name}#{suffix}; self.#{old_name}#{suffix}; end  # def subject_changed?; self.title_changed?; end
           STR
         end

data/lib/active_record/fixtures.rb

@@ -891,6 +891,7 @@ module ActiveRecord
 
             instances.size == 1 ? instances.first : instances
           end
+          private table_name
         end
       end
 

data/lib/active_record/locking/optimistic.rb

@@ -23,6 +23,16 @@ module ActiveRecord
     #   p2.first_name = "should fail"
     #   p2.save # Raises a ActiveRecord::StaleObjectError
     #
+    # Optimistic locking will also check for stale data when objects are destroyed.  Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #
+    #   p2.destroy # Raises a ActiveRecord::StaleObjectError
+    #
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
     #
@@ -39,6 +49,7 @@ module ActiveRecord
         base.lock_optimistically = true
 
         base.alias_method_chain :update, :lock
+        base.alias_method_chain :destroy, :lock
         base.alias_method_chain :attributes_from_column_definition, :lock
 
         class << base
@@ -86,7 +97,7 @@ module ActiveRecord
             end_sql
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
             end
 
             affected_rows
@@ -98,6 +109,28 @@ module ActiveRecord
           end
         end
 
+        def destroy_with_lock #:nodoc:
+          return destroy_without_lock unless locking_enabled?
+
+          unless new_record?
+            lock_col = self.class.locking_column
+            previous_value = send(lock_col).to_i
+
+            affected_rows = connection.delete(
+              "DELETE FROM #{self.class.quoted_table_name} " +
+              "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quoted_id} " +
+                    "AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}",
+              "#{self.class.name} Destroy"
+            )
+
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
+            end
+          end
+
+          freeze
+        end
+
       module ClassMethods
         DEFAULT_LOCKING_COLUMN = 'lock_version'
 

data/lib/active_record/migration.rb

@@ -381,6 +381,7 @@ module ActiveRecord
       def migrate(migrations_path, target_version = nil)
         case
           when target_version.nil?              then up(migrations_path, target_version)
+          when current_version == 0 && target_version == 0 then # noop
           when current_version > target_version then down(migrations_path, target_version)
           else                                       up(migrations_path, target_version)
         end
@@ -408,6 +409,10 @@ module ActiveRecord
         self.new(direction, migrations_path, target_version).run
       end
 
+      def migrations_path
+        'db/migrate'
+      end
+
       def schema_migrations_table_name
         Base.table_name_prefix + 'schema_migrations' + Base.table_name_suffix
       end

data/lib/active_record/nested_attributes.rb

@@ -184,6 +184,8 @@ module ActiveRecord
     # the parent model is saved. This happens inside the transaction initiated
     # by the parents save method. See ActiveRecord::AutosaveAssociation.
     module ClassMethods
+      REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |_, value| value.blank? } }
+
       # Defines an attributes writer for the specified association(s). If you
       # are using <tt>attr_protected</tt> or <tt>attr_accessible</tt>, then you
       # will need to add the attribute writer to the allowed list.
@@ -208,39 +210,40 @@ module ActiveRecord
       #   nested attributes array exceeds the specified limit, NestedAttributes::TooManyRecords
       #   exception is raised. If omitted, any number associations can be processed.
       #   Note that the :limit option is only applicable to one-to-many associations.
+      # [:update_only]
+      #   Allows you to specify that an existing record may only be updated.
+      #   A new record may only be created when there is no existing record.
+      #   This option only works for one-to-one associations and is ignored for
+      #   collection associations. This option is off by default.
       #
       # Examples:
       #   # creates avatar_attributes=
       #   accepts_nested_attributes_for :avatar, :reject_if => proc { |attributes| attributes['name'].blank? }
+      #   # creates avatar_attributes=
+      #   accepts_nested_attributes_for :avatar, :reject_if => :all_blank
       #   # creates avatar_attributes= and posts_attributes=
       #   accepts_nested_attributes_for :avatar, :posts, :allow_destroy => true
       def accepts_nested_attributes_for(*attr_names)
-        options = { :allow_destroy => false }
+        options = { :allow_destroy => false, :update_only => false }
         options.update(attr_names.extract_options!)
-        options.assert_valid_keys(:allow_destroy, :reject_if, :limit)
+        options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
+        options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
 
         attr_names.each do |association_name|
           if reflection = reflect_on_association(association_name)
-            type = case reflection.macro
-            when :has_one, :belongs_to
-              :one_to_one
-            when :has_many, :has_and_belongs_to_many
-              :collection
-            end
-
             reflection.options[:autosave] = true
-            self.nested_attributes_options[association_name.to_sym] = options
+            add_autosave_association_callbacks(reflection)
+            nested_attributes_options[association_name.to_sym] = options
+            type = (reflection.collection? ? :collection : :one_to_one)
 
             # def pirate_attributes=(attributes)
-            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, false)
+            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
             # end
-            class_eval %{
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
               end
-            }, __FILE__, __LINE__
-
-            add_autosave_association_callbacks(reflection)
+            EOS
           else
             raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
           end
@@ -257,46 +260,41 @@ module ActiveRecord
       marked_for_destruction?
     end
 
-    # Deal with deprecated _delete.
-    #
-    def _delete #:nodoc:
-      ActiveSupport::Deprecation.warn "_delete is deprecated in nested attributes. Use _destroy instead."
-      _destroy
-    end
-
     private
 
     # Attribute hash keys that should not be assigned as normal attributes.
     # These hash keys are nested attributes implementation details.
-    #
-    # TODO Remove _delete from UNASSIGNABLE_KEYS when deprecation warning are
-    # removed.
-    UNASSIGNABLE_KEYS = %w( id _destroy _delete )
+    UNASSIGNABLE_KEYS = %w( id _destroy )
 
     # Assigns the given attributes to the association.
     #
-    # If the given attributes include an <tt>:id</tt> that matches the existing
-    # record’s id, then the existing record will be modified. Otherwise a new
-    # record will be built.
+    # If update_only is false and the given attributes include an <tt>:id</tt>
+    # that matches the existing record’s id, then the existing record will be
+    # modified. If update_only is true, a new record is only created when no
+    # object exists. Otherwise a new record will be built.
     #
-    # If the given attributes include a matching <tt>:id</tt> attribute _and_ a
-    # <tt>:_destroy</tt> key set to a truthy value, then the existing record
-    # will be marked for destruction.
+    # If the given attributes include a matching <tt>:id</tt> attribute, or
+    # update_only is true, and a <tt>:_destroy</tt> key set to a truthy value,
+    # then the existing record will be marked for destruction.
     def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
-      options = self.nested_attributes_options[association_name]
+      options = nested_attributes_options[association_name]
       attributes = attributes.with_indifferent_access
+      check_existing_record = (options[:update_only] || !attributes['id'].blank?)
 
-      if attributes['id'].blank?
-        unless reject_new_record?(association_name, attributes)
-          method = "build_#{association_name}"
-          if respond_to?(method)
-            send(method, attributes.except(*UNASSIGNABLE_KEYS))
-          else
-            raise ArgumentError, "Cannot build association #{association_name}. Are you trying to build a polymorphic one-to-one association?"
-          end
+      if check_existing_record && (record = send(association_name)) &&
+          (options[:update_only] || record.id.to_s == attributes['id'].to_s)
+        assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy])
+
+      elsif attributes['id']
+        raise_nested_attributes_record_not_found(association_name, attributes['id'])
+
+      elsif !reject_new_record?(association_name, attributes)
+        method = "build_#{association_name}"
+        if respond_to?(method)
+          send(method, attributes.except(*UNASSIGNABLE_KEYS))
+        else
+          raise ArgumentError, "Cannot build association #{association_name}. Are you trying to build a polymorphic one-to-one association?"
         end
-      elsif (existing_record = send(association_name)) && existing_record.id.to_s == attributes['id'].to_s
-        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
       end
     end
 
@@ -328,7 +326,7 @@ module ActiveRecord
     #     { :id => '2', :_destroy => true }
     #   ])
     def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
-      options = self.nested_attributes_options[association_name]
+      options = nested_attributes_options[association_name]
 
       unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
         raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
@@ -342,15 +340,27 @@ module ActiveRecord
         attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
       end
 
+      association = send(association_name)
+
+      existing_records = if association.loaded?
+        association.to_a
+      else
+        attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+        attribute_ids.present? ? association.all(:conditions => {association.primary_key => attribute_ids}) : []
+      end
+
       attributes_collection.each do |attributes|
         attributes = attributes.with_indifferent_access
 
         if attributes['id'].blank?
           unless reject_new_record?(association_name, attributes)
-            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+            association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
-        elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes['id'].to_s }
+        elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
+          association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
           assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+        else
+          raise_nested_attributes_record_not_found(association_name, attributes['id'])
         end
       end
     end
@@ -367,8 +377,7 @@ module ActiveRecord
 
     # Determines if a hash contains a truthy _destroy key.
     def has_destroy_flag?(hash)
-      ConnectionAdapters::Column.value_to_boolean(hash['_destroy']) ||
-      ConnectionAdapters::Column.value_to_boolean(hash['_delete']) # TODO Remove after deprecation.
+      ConnectionAdapters::Column.value_to_boolean(hash['_destroy'])
     end
 
     # Determines if a new record should be build by checking for
@@ -379,14 +388,17 @@ module ActiveRecord
     end
 
     def call_reject_if(association_name, attributes)
-      callback = self.nested_attributes_options[association_name][:reject_if]
-
-      case callback
+      case callback = nested_attributes_options[association_name][:reject_if]
       when Symbol
         method(callback).arity == 0 ? send(callback) : send(callback, attributes)
       when Proc
-        callback.try(:call, attributes)
+        callback.call(attributes)
       end
     end
+
+    def raise_nested_attributes_record_not_found(association_name, record_id)
+      reflection = self.class.reflect_on_association(association_name)
+      raise RecordNotFound, "Couldn't find #{reflection.klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+    end
   end
 end

data/lib/active_record/reflection.rb

@@ -212,6 +212,15 @@ module ActiveRecord
       end
 
       def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
       end
 
       def through_reflection
@@ -225,10 +234,64 @@ module ActiveRecord
         nil
       end
 
+      def has_inverse?
+        !@options[:inverse_of].nil?
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
+        end
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is one of +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        if @collection.nil?
+          @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+        end
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitely disable validation with
+      # <tt>:validate => false</tt>, it will take place when:
+      #
+      # * you explicitely enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      def dependent_conditions(record, base_class, extra_conditions)
+        dependent_conditions = []
+        dependent_conditions << "#{primary_key_name} = #{record.send(name).send(:owner_quoted_id)}"
+        dependent_conditions << "#{options[:as]}_type = '#{base_class.name}'" if options[:as]
+        dependent_conditions << klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+        dependent_conditions = dependent_conditions.collect {|where| "(#{where})" }.join(" AND ")
+        dependent_conditions << extra_conditions if extra_conditions
+        dependent_conditions = dependent_conditions.gsub('@', '\@')
+        dependent_conditions
+      end
+
       private
         def derive_class_name
           class_name = name.to_s.camelize
-          class_name = class_name.singularize if [ :has_many, :has_and_belongs_to_many ].include?(macro)
+          class_name = class_name.singularize if collection?
           class_name
         end
 
@@ -300,6 +363,8 @@ module ActiveRecord
         unless [:belongs_to, :has_many, :has_one].include?(source_reflection.macro) && source_reflection.options[:through].nil?
           raise HasManyThroughSourceAssociationMacroError.new(self)
         end
+
+        check_validity_of_inverse!
       end
 
       def through_reflection_primary_key

data/lib/active_record/schema.rb

@@ -28,6 +28,10 @@ module ActiveRecord
   class Schema < Migration
     private_class_method :new
 
+    def self.migrations_path
+      ActiveRecord::Migrator.migrations_path
+    end
+
     # Eval the given block. All methods available to the current connection
     # adapter are available within the block, so you can easily use the
     # database definition DSL to build up your schema (+create_table+,
@@ -44,7 +48,7 @@ module ActiveRecord
 
       unless info[:version].blank?
         initialize_schema_migrations_table
-        assume_migrated_upto_version info[:version]
+        assume_migrated_upto_version(info[:version], migrations_path)
       end
     end
   end

data/lib/active_record/schema_dumper.rb

@@ -171,6 +171,9 @@ HEADER
             statment_parts << (':name => ' + index.name.inspect)
             statment_parts << ':unique => true' if index.unique
 
+            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
+            statment_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
+
             '  ' + statment_parts.join(', ')
           end
 

data/lib/active_record/serializers/json_serializer.rb

@@ -79,7 +79,7 @@ module ActiveRecord #:nodoc:
 
     def as_json(options = nil) #:nodoc:
       hash = Serializer.new(self, options).serializable_record
-      hash = { self.class.model_name.element => hash } if include_root_in_json
+      hash = { options[:root] || self.class.model_name.element => hash } if include_root_in_json
       hash
     end