activerecord 3.1.11 → 3.2.0

data/lib/active_record/integration.rb

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module Integration
+    # Returns a String, which Action Pack uses for constructing an URL to this
+    # object. The default implementation returns this record's id as a String,
+    # or nil if this record's unsaved.
+    #
+    # For example, suppose that you have a User model, and that you have a
+    # <tt>resources :users</tt> route. Normally, +user_path+ will
+    # construct a path with the user object's 'id' in it:
+    #
+    #   user = User.find_by_name('Phusion')
+    #   user_path(user)  # => "/users/1"
+    #
+    # You can override +to_param+ in your model to make +user_path+ construct
+    # a path using the user's name instead of the user's id:
+    #
+    #   class User < ActiveRecord::Base
+    #     def to_param  # overridden
+    #       name
+    #     end
+    #   end
+    #
+    #   user = User.find_by_name('Phusion')
+    #   user_path(user)  # => "/users/Phusion"
+    def to_param
+      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+      id && id.to_s # Be sure to stringify the id for routes
+    end
+
+    # Returns a cache key that can be used to identify this record.
+    #
+    # ==== Examples
+    #
+    #   Product.new.cache_key     # => "products/new"
+    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
+    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    def cache_key
+      case
+      when new_record?
+        "#{self.class.model_name.cache_key}/new"
+      when timestamp = self[:updated_at]
+        timestamp = timestamp.utc.to_s(:number)
+        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+      else
+        "#{self.class.model_name.cache_key}/#{id}"
+      end
+    end
+  end
+end

data/lib/active_record/locking/optimistic.rb

@@ -37,6 +37,9 @@ module ActiveRecord
     # 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.
     #
+    # This locking mechanism will function inside a single Ruby process. To make it work across all
+    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
+    #
     # You must ensure that your database schema defaults the +lock_version+ column to 0.
     #
     # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
@@ -48,10 +51,6 @@ module ActiveRecord
       included do
         cattr_accessor :lock_optimistically, :instance_writer => false
         self.lock_optimistically = true
-
-        class << self
-          alias_method :locking_column=, :set_locking_column
-        end
       end
 
       def locking_enabled? #:nodoc:
@@ -65,21 +64,6 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def attributes_from_column_definition
-          result = super
-
-          # If the locking column has no default value set,
-          # start the lock version at zero. Note we can't use
-          # <tt>locking_enabled?</tt> at this point as
-          # <tt>@attributes</tt> may not have been initialized yet.
-
-          if result.key?(self.class.locking_column) && lock_optimistically
-            result[self.class.locking_column] ||= 0
-          end
-
-          result
-        end
-
         def update(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
@@ -103,7 +87,7 @@ module ActiveRecord
             affected_rows = connection.update stmt
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "update")
             end
 
             affected_rows
@@ -127,7 +111,7 @@ module ActiveRecord
             affected_rows = self.class.unscoped.where(predicate).delete_all
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "destroy")
             end
           end
 
@@ -145,15 +129,24 @@ module ActiveRecord
           lock_optimistically && columns_hash[locking_column]
         end
 
+        def locking_column=(value)
+          @original_locking_column = @locking_column if defined?(@locking_column)
+          @locking_column          = value.to_s
+        end
+
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def set_locking_column(value = nil, &block)
-          define_attr_method :locking_column, value, &block
-          value
+          deprecated_property_setter :locking_column, value, block
         end
 
         # The version column used for optimistic locking. Defaults to +lock_version+.
         def locking_column
-          reset_locking_column
+          reset_locking_column unless defined?(@locking_column)
+          @locking_column
+        end
+
+        def original_locking_column #:nodoc:
+          deprecated_original_property_getter :locking_column
         end
 
         # Quote the column name used for optimistic locking.
@@ -163,7 +156,7 @@ module ActiveRecord
 
         # Reset the column used for optimistic locking back to the +lock_version+ default.
         def reset_locking_column
-          set_locking_column DEFAULT_LOCKING_COLUMN
+          self.locking_column = DEFAULT_LOCKING_COLUMN
         end
 
         # Make sure the lock version column gets updated when counters are
@@ -172,6 +165,18 @@ module ActiveRecord
           counters = counters.merge(locking_column => 1) if locking_enabled?
           super
         end
+
+        # If the locking column has no default value set,
+        # start the lock version at zero. Note we can't use
+        # <tt>locking_enabled?</tt> at this point as
+        # <tt>@attributes</tt> may not have been initialized yet.
+        def initialize_attributes(attributes) #:nodoc:
+          if attributes.key?(locking_column) && lock_optimistically
+            attributes[locking_column] ||= 0
+          end
+
+          attributes
+        end
       end
     end
   end

data/lib/active_record/locking/pessimistic.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     #   Account.transaction do
     #     # select * from accounts where name = 'shugo' limit 1 for update
     #     shugo = Account.where("name = 'shugo'").lock(true).first
-    #     yuko = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
@@ -38,6 +38,18 @@ module ActiveRecord
     #     account2.save!
     #   end
     #
+    # You can start a transaction and acquire the lock in one go by calling
+    # <tt>with_lock</tt> with a block. The block is called from within
+    # a transaction, the object is already locked. Example:
+    #
+    #   account = Account.first
+    #   account.with_lock do
+    #     # This block is called within a transaction,
+    #     # account is already locked.
+    #     account.balance -= 100
+    #     account.save!
+    #   end
+    #
     # Database-specific information on row locking:
     #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
     #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
@@ -50,6 +62,16 @@ module ActiveRecord
         reload(:lock => lock) if persisted?
         self
       end
+
+      # Wraps the passed block in a transaction, locking the object
+      # before yielding. You pass can the SQL locking clause
+      # as argument (see <tt>lock!</tt>).
+      def with_lock(lock = true)
+        transaction do
+          lock!(lock)
+          yield
+        end
+      end
     end
   end
 end

data/lib/active_record/log_subscriber.rb

@@ -26,9 +26,9 @@ module ActiveRecord
 
       return if 'SCHEMA' == payload[:name]
 
-      name    = '%s (%.1fms)' % [payload[:name], event.duration]
-      sql     = payload[:sql].squeeze(' ')
-      binds   = nil
+      name  = '%s (%.1fms)' % [payload[:name], event.duration]
+      sql   = payload[:sql].squeeze(' ')
+      binds = nil
 
       unless (payload[:binds] || []).empty?
         binds = "  " + payload[:binds].map { |col,v|

data/lib/active_record/migration/command_recorder.rb

@@ -1,12 +1,12 @@
 module ActiveRecord
   class Migration
-    # ActiveRecord::Migration::CommandRecorder records commands done during
-    # a migration and knows how to reverse those commands.  The CommandRecorder
+    # <tt>ActiveRecord::Migration::CommandRecorder</tt> records commands done during
+    # a migration and knows how to reverse those commands. The CommandRecorder
     # knows how to invert the following commands:
     #
     # * add_column
     # * add_index
-    # * add_timestamp
+    # * add_timestamps
     # * create_table
     # * remove_timestamps
     # * rename_column
@@ -20,21 +20,21 @@ module ActiveRecord
         @delegate = delegate
       end
 
-      # record +command+.  +command+ should be a method name and arguments.
+      # record +command+. +command+ should be a method name and arguments.
       # For example:
       #
-      #   recorder.record(:method_name, [:arg1, arg2])
+      #   recorder.record(:method_name, [:arg1, :arg2])
       def record(*command)
         @commands << command
       end
 
       # Returns a list that represents commands that are the inverse of the
-      # commands stored in +commands+.  For example:
+      # commands stored in +commands+. For example:
       #
       #   recorder.record(:rename_table, [:old, :new])
       #   recorder.inverse # => [:rename_table, [:new, :old]]
       #
-      # This method will raise an IrreversibleMigration exception if it cannot
+      # This method will raise an +IrreversibleMigration+ exception if it cannot
       # invert the +commands+.
       def inverse
         @commands.reverse.map { |name, args|
@@ -59,7 +59,7 @@ module ActiveRecord
       private
 
       def invert_create_table(args)
-        [:drop_table, args]
+        [:drop_table, [args.first]]
       end
 
       def invert_rename_table(args)

data/lib/active_record/migration.rb

@@ -1,6 +1,7 @@
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/class/attribute_accessors"
 require "active_support/core_ext/array/wrap"
+require 'active_support/deprecation'
 
 module ActiveRecord
   # Exception that can be raised to stop migrations from going backwards.
@@ -68,9 +69,9 @@ module ActiveRecord
   #       create_table :system_settings do |t|
   #         t.string  :name
   #         t.string  :label
-  #         t.text  :value
+  #         t.text    :value
   #         t.string  :type
-  #         t.integer  :position
+  #         t.integer :position
   #       end
   #
   #       SystemSetting.create  :name => "notice",
@@ -116,8 +117,9 @@ module ActiveRecord
   #   +column_names+ from the table called +table_name+.
   # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index
   #   with the name of the column. Other options include
-  #   <tt>:name</tt> and <tt>:unique</tt> (e.g.
-  #   <tt>{ :name => "users_name_index", :unique => true }</tt>).
+  #   <tt>:name</tt>, <tt>:unique</tt> (e.g.
+  #   <tt>{ :name => "users_name_index", :unique => true }</tt>) and <tt>:order</tt>
+  #   (e.g. { :order => {:name => :desc} }</tt>).
   # * <tt>remove_index(table_name, :column => column_name)</tt>: Removes the index
   #   specified by +column_name+.
   # * <tt>remove_index(table_name, :name => index_name)</tt>: Removes the index
@@ -183,7 +185,7 @@ module ActiveRecord
   #
   #   class RemoveEmptyTags < ActiveRecord::Migration
   #     def up
-  #       Tag.find(:all).each { |tag| tag.destroy if tag.pages.empty? }
+  #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
   #
   #     def down
@@ -229,7 +231,7 @@ module ActiveRecord
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
-  #       Person.find(:all).each do |p|
+  #       Person.all.each do |p|
   #         p.update_attribute :salary, SalaryCalculator.compute(p)
   #       end
   #     end
@@ -249,7 +251,7 @@ module ActiveRecord
   #   def up
   #     ...
   #     say_with_time "Updating salaries..." do
-  #       Person.find(:all).each do |p|
+  #       Person.all.each do |p|
   #         p.update_attribute :salary, SalaryCalculator.compute(p)
   #       end
   #     end
@@ -301,7 +303,7 @@ module ActiveRecord
   #
   #   class TenderloveMigration < ActiveRecord::Migration
   #     def change
-  #       create_table(:horses) do
+  #       create_table(:horses) do |t|
   #         t.column :content, :text
   #         t.column :remind_at, :datetime
   #       end
@@ -442,6 +444,7 @@ module ActiveRecord
       say_with_time "#{method}(#{arg_list})" do
         unless arguments.empty? || method == :execute
           arguments[0] = Migrator.proper_table_name(arguments.first)
+          arguments[1] = Migrator.proper_table_name(arguments.second) if method == :rename_table
         end
         return super unless connection.respond_to?(method)
         connection.send(method, *arguments, &block)
@@ -455,26 +458,28 @@ module ActiveRecord
 
       destination_migrations = ActiveRecord::Migrator.migrations(destination)
       last = destination_migrations.last
-      sources.each do |name, path|
+      sources.each do |scope, path|
         source_migrations = ActiveRecord::Migrator.migrations(path)
 
         source_migrations.each do |migration|
           source = File.read(migration.filename)
-          source = "# This migration comes from #{name} (originally #{migration.version})\n#{source}"
+          source = "# This migration comes from #{scope} (originally #{migration.version})\n#{source}"
 
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
-            options[:on_skip].call(name, migration) if File.read(duplicate.filename) != source && options[:on_skip]
+            if options[:on_skip] && duplicate.scope != scope.to_s
+              options[:on_skip].call(scope, migration)
+            end
             next
           end
 
           migration.version = next_migration_number(last ? last.version + 1 : 0).to_i
-          new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.rb")
+          new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.#{scope}.rb")
           old_path, migration.filename = migration.filename, new_path
           last = migration
 
-          FileUtils.cp(old_path, migration.filename)
+          File.open(migration.filename, "w") { |f| f.write source }
           copied << migration
-          options[:on_copy].call(name, migration, old_path) if options[:on_copy]
+          options[:on_copy].call(scope, migration, old_path) if options[:on_copy]
           destination_migrations << migration
         end
       end
@@ -493,9 +498,9 @@ module ActiveRecord
 
   # MigrationProxy is used to defer loading of the actual migration classes
   # until they are needed
-  class MigrationProxy < Struct.new(:name, :version, :filename)
+  class MigrationProxy < Struct.new(:name, :version, :filename, :scope)
 
-    def initialize(name, version, filename)
+    def initialize(name, version, filename, scope)
       super
       @migration = nil
     end
@@ -504,7 +509,7 @@ module ActiveRecord
       File.basename(filename)
     end
 
-    delegate :migrate, :announce, :write, :to=>:migration
+    delegate :migrate, :announce, :write, :to => :migration
 
     private
 
@@ -524,16 +529,16 @@ module ActiveRecord
       attr_writer :migrations_paths
       alias :migrations_path= :migrations_paths=
 
-      def migrate(migrations_paths, target_version = nil)
+      def migrate(migrations_paths, target_version = nil, &block)
         case
           when target_version.nil?
-            up(migrations_paths, target_version)
+            up(migrations_paths, target_version, &block)
           when current_version == 0 && target_version == 0
             []
           when current_version > target_version
-            down(migrations_paths, target_version)
+            down(migrations_paths, target_version, &block)
           else
-            up(migrations_paths, target_version)
+            up(migrations_paths, target_version, &block)
         end
       end
 
@@ -545,12 +550,12 @@ module ActiveRecord
         move(:up, migrations_paths, steps)
       end
 
-      def up(migrations_paths, target_version = nil)
-        self.new(:up, migrations_paths, target_version).migrate
+      def up(migrations_paths, target_version = nil, &block)
+        self.new(:up, migrations_paths, target_version).migrate(&block)
       end
 
-      def down(migrations_paths, target_version = nil)
-        self.new(:down, migrations_paths, target_version).migrate
+      def down(migrations_paths, target_version = nil, &block)
+        self.new(:down, migrations_paths, target_version).migrate(&block)
       end
 
       def run(direction, migrations_paths, target_version)
@@ -590,15 +595,23 @@ module ActiveRecord
         migrations_paths.first
       end
 
-      def migrations(paths)
+      def migrations(paths, *args)
+        if args.empty?
+          subdirectories = true
+        else
+          subdirectories = args.first
+          ActiveSupport::Deprecation.warn "The `subdirectories` argument to `migrations` is deprecated"
+        end
+
         paths = Array.wrap(paths)
 
-        files = Dir[*paths.map { |p| "#{p}/[0-9]*_*.rb" }]
+        glob = subdirectories ? "**/" : ""
+        files = Dir[*paths.map { |p| "#{p}/#{glob}[0-9]*_*.rb" }]
 
         seen = Hash.new false
 
         migrations = files.map do |file|
-          version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+          version, name, scope = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?.rb/).first
 
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
@@ -609,7 +622,7 @@ module ActiveRecord
 
           seen[version] = seen[name] = true
 
-          MigrationProxy.new(name, version, file)
+          MigrationProxy.new(name, version, file, scope)
         end
 
         migrations.sort_by(&:version)
@@ -652,7 +665,7 @@ module ActiveRecord
       end
     end
 
-    def migrate
+    def migrate(&block)
       current = migrations.detect { |m| m.version == current_version }
       target = migrations.detect { |m| m.version == @target_version }
 
@@ -669,6 +682,10 @@ module ActiveRecord
 
       ran = []
       runnable.each do |migration|
+        if block && !block.call(migration)
+          next
+        end
+
         Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
 
         seen = migrated.include?(migration.version.to_i)