activerecord 3.1.12 → 3.2.0.rc1

data/lib/active_record/fixtures/file.rb

@@ -0,0 +1,65 @@
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'erb'
+require 'yaml'
+
+module ActiveRecord
+  class Fixtures
+    class File
+      include Enumerable
+
+      ##
+      # Open a fixture file named +file+.  When called with a block, the block
+      # is called with the filehandle and the filehandle is automatically closed
+      # when the block finishes.
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+        @rows = nil
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+      RESCUE_ERRORS = [ ArgumentError ] # :nodoc:
+
+      private
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        RESCUE_ERRORS << Psych::SyntaxError
+      end
+
+      def rows
+        return @rows if @rows
+
+        begin
+          data = YAML.load(render(IO.read(@file)))
+        rescue *RESCUE_ERRORS => error
+          raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+        end
+        @rows = data ? validate(data).to_a : []
+      end
+
+      def render(content)
+        ERB.new(content).result
+      end
+
+      # Validate our unmarshalled data.
+      def validate(data)
+        unless Hash === data || YAML::Omap === data
+          raise Fixture::FormatError, 'fixture is not a hash'
+        end
+
+        raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
+        data
+      end
+    end
+  end
+end

data/lib/active_record/identity_map.rb

@@ -90,7 +90,7 @@ module ActiveRecord
       end
 
       def add(record)
-        repository[record.class.symbolized_sti_name][record.id] = record if contain_all_columns?(record)
+        repository[record.class.symbolized_sti_name][record.id] = record
       end
 
       def remove(record)
@@ -104,12 +104,6 @@ module ActiveRecord
       def clear
         repository.clear
       end
-
-      private
-
-        def contain_all_columns?(record)
-          (record.class.column_names - record.attribute_names).empty?
-        end
     end
 
     # Reinitialize an Identity Map model object from +coder+.

data/lib/active_record/inheritance.rb

@@ -0,0 +1,167 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    included do
+      # Determine whether to store the full constant name including namespace when using STI
+      class_attribute :store_full_sti_class
+      self.store_full_sti_class = true
+    end
+
+    module ClassMethods
+      # True if this isn't a concrete subclass needing a STI type condition.
+      def descends_from_active_record?
+        if superclass.abstract_class?
+          superclass.descends_from_active_record?
+        else
+          superclass == Base || !columns_hash.include?(inheritance_column)
+        end
+      end
+
+      def finder_needs_type_condition? #:nodoc:
+        # This is like this because benchmarking justifies the strange :false stuff
+        :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
+      end
+
+      def symbolized_base_class
+        @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.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      def base_class
+        class_of_active_record_descendant(self)
+      end
+
+      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
+      attr_accessor :abstract_class
+
+      # Returns whether this class is an abstract class or not.
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        store_full_sti_class ? name : name.demodulize
+      end
+
+      # Finder methods must instantiate through this method to work with the
+      # single-table inheritance model that makes it possible to create
+      # objects of different types from the same table.
+      def instantiate(record)
+        sti_class = find_sti_class(record[inheritance_column])
+        record_id = sti_class.primary_key && record[sti_class.primary_key]
+
+        if ActiveRecord::IdentityMap.enabled? && record_id
+          if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
+            record_id = record_id.to_i
+          end
+          if instance = IdentityMap.get(sti_class, record_id)
+            instance.reinit_with('attributes' => record)
+          else
+            instance = sti_class.allocate.init_with('attributes' => record)
+            IdentityMap.add(instance)
+          end
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
+        end
+
+        instance
+      end
+
+      protected
+
+      # Returns the class descending directly from ActiveRecord::Base or an
+      # abstract class, if any, in the inheritance hierarchy.
+      def class_of_active_record_descendant(klass)
+        if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
+          klass
+        elsif klass.superclass.nil?
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        else
+          class_of_active_record_descendant(klass.superclass)
+        end
+      end
+
+      # Returns the class type of the record using the current module as a prefix. So descendants of
+      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+            rescue NameError => e
+              # We don't want to swallow NoMethodError < NameError errors
+              raise e unless e.instance_of?(NameError)
+            end
+          end
+
+          raise NameError, "uninitialized constant #{candidates.first}"
+        end
+      end
+
+      private
+
+      def find_sti_class(type_name)
+        if type_name.blank? || !columns_hash.include?(inheritance_column)
+          self
+        else
+          begin
+            if store_full_sti_class
+              ActiveSupport::Dependencies.constantize(type_name)
+            else
+              compute_type(type_name)
+            end
+          rescue NameError
+            raise SubclassNotFound,
+              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+              "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+              "or overwrite #{name}.inheritance_column to use another column for that information."
+          end
+        end
+      end
+
+      def type_condition(table = arel_table)
+        sti_column = table[inheritance_column.to_sym]
+        sti_names  = ([self] + descendants).map { |model| model.sti_name }
+
+        sti_column.in(sti_names)
+      end
+    end
+
+    private
+
+    # Sets the attribute used for single table inheritance to this class name if this is not the
+    # ActiveRecord::Base descendant.
+    # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+    # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
+    # No such attribute would be set for objects of the Message class in that example.
+    def ensure_proper_type
+      klass = self.class
+      if klass.finder_needs_type_condition?
+        write_attribute(klass.inheritance_column, klass.sti_name)
+      end
+    end
+  end
+end

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:
@@ -66,7 +65,7 @@ module ActiveRecord
         end
 
         def attributes_from_column_definition
-          result = super
+          result = self.class.column_defaults.dup
 
           # If the locking column has no default value set,
           # start the lock version at zero. Note we can't use
@@ -103,7 +102,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 +126,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 +144,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 +171,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

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

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.rb

@@ -68,9 +68,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 +116,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 +184,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 +230,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 +250,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 +302,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 +443,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 +457,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 +497,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
@@ -524,16 +528,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 +549,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 +594,16 @@ module ActiveRecord
         migrations_paths.first
       end
 
-      def migrations(paths)
+      def migrations(paths, subdirectories = true)
         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 +614,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 +657,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 +674,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)