activerecord 4.1.0.beta2 → 4.1.0.rc1

data/lib/active_record/persistence.rb

@@ -181,6 +181,7 @@ module ActiveRecord
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)
       became.instance_variable_set("@attributes_cache", @attributes_cache)
+      became.instance_variable_set("@changed_attributes", @changed_attributes) if defined?(@changed_attributes)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
       became.instance_variable_set("@errors", errors)
@@ -195,7 +196,11 @@ module ActiveRecord
     # share the same set of attributes.
     def becomes!(klass)
       became = becomes(klass)
-      became.public_send("#{klass.inheritance_column}=", klass.sti_name) unless self.class.descends_from_active_record?
+      sti_type = nil
+      if !klass.descends_from_active_record?
+        sti_type = klass.sti_name
+      end
+      became.public_send("#{klass.inheritance_column}=", sti_type)
       became
     end
 
@@ -264,7 +269,7 @@ module ActiveRecord
     # This method raises an +ActiveRecord::ActiveRecordError+ when called on new
     # objects, or when at least one of the attributes is marked as readonly.
     def update_columns(attributes)
-      raise ActiveRecordError, "can not update on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot update on a new record object" unless persisted?
 
       attributes.each_key do |key|
         verify_readonly_attribute(key.to_s)
@@ -361,7 +366,7 @@ module ActiveRecord
     #   assert_equal 25, account.credit        # check it is updated in memory
     #   assert_equal 25, account.reload.credit # check it is also persisted
     #
-    # Another commom use case is optimistic locking handling:
+    # Another common use case is optimistic locking handling:
     #
     #   def with_optimistic_retry
     #     begin
@@ -384,7 +389,7 @@ module ActiveRecord
 
       fresh_object =
         if options && options[:lock]
-          self.class.unscoped { self.class.lock.find(id) }
+          self.class.unscoped { self.class.lock(options[:lock]).find(id) }
         else
           self.class.unscoped { self.class.find(id) }
         end
@@ -426,7 +431,7 @@ module ActiveRecord
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
     def touch(name = nil)
-      raise ActiveRecordError, "can not touch on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
       attributes = timestamp_attributes_for_update_in_model
       attributes << name if name

data/lib/active_record/querying.rb

@@ -1,6 +1,7 @@
 module ActiveRecord
   module Querying
     delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, to: :all
+    delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, to: :all
     delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
     delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
     delegate :find_by, :find_by!, to: :all

data/lib/active_record/railtie.rb

@@ -31,22 +31,16 @@ module ActiveRecord
 
 
     config.active_record.use_schema_cache_dump = true
+    config.active_record.maintain_test_schema = true
 
     config.eager_load_namespaces << ActiveRecord
 
     rake_tasks do
       require "active_record/base"
 
-      ActiveRecord::Tasks::DatabaseTasks.seed_loader = Rails.application
-      ActiveRecord::Tasks::DatabaseTasks.env = Rails.env
-
       namespace :db do
         task :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.db_dir = Rails.application.config.paths["db"].first
           ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths = Rails.application.paths['db/migrate'].to_a
-          ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures'
-          ActiveRecord::Tasks::DatabaseTasks.root = Rails.root
 
           if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
             if engine.paths['db/migrate'].existent
@@ -122,7 +116,16 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
-        self.configurations = app.config.database_configuration || {}
+
+        class ActiveRecord::NoDatabaseError
+          remove_possible_method :extend_message
+          def extend_message(message)
+            message << "Run `$ bin/rake db:create db:migrate` to create your database"
+            message
+          end
+        end
+
+        self.configurations = Rails.application.config.database_configuration
         establish_connection
       end
     end

data/lib/active_record/railties/databases.rake

@@ -2,7 +2,7 @@ require 'active_record'
 
 db_namespace = namespace :db do
   task :load_config do
-    ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+    ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
     ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
 
@@ -12,13 +12,9 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all databases in the config)'
+  desc 'Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV it defaults to creating the development and test databases.'
   task :create => [:load_config] do
-    if ENV['DATABASE_URL']
-      ActiveRecord::Tasks::DatabaseTasks.create_database_url
-    else
-      ActiveRecord::Tasks::DatabaseTasks.create_current
-    end
+    ActiveRecord::Tasks::DatabaseTasks.create_current
   end
 
   namespace :drop do
@@ -27,13 +23,9 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Drops the database using DATABASE_URL or the current Rails.env (use db:drop:all to drop all databases)'
+  desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV it defaults to dropping the development and test databases.'
   task :drop => [:load_config] do
-    if ENV['DATABASE_URL']
-      ActiveRecord::Tasks::DatabaseTasks.drop_database_url
-    else
-      ActiveRecord::Tasks::DatabaseTasks.drop_current
-    end
+    ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
@@ -42,7 +34,7 @@ db_namespace = namespace :db do
     ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil) do |migration|
       ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
     end
-    db_namespace['_dump'].invoke
+    db_namespace['_dump'].invoke if ActiveRecord::Base.dump_schema_after_migration
   end
 
   task :_dump do
@@ -83,7 +75,7 @@ db_namespace = namespace :db do
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
+      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
@@ -187,9 +179,6 @@ db_namespace = namespace :db do
       require 'active_record/fixtures'
 
       base_dir = if ENV['FIXTURES_PATH']
-        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
-                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
-                    "instead."
         File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
       else
         ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -212,9 +201,6 @@ db_namespace = namespace :db do
       puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.identify(label)}.) if label
 
       base_dir = if ENV['FIXTURES_PATH']
-        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
-                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
-                    "instead."
         File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
       else
         ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -248,9 +234,7 @@ db_namespace = namespace :db do
 
     desc 'Load a schema.rb file into the database'
     task :load => [:environment, :load_config] do
-      file = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
-      ActiveRecord::Tasks::DatabaseTasks.check_schema_file(file)
-      load(file)
+      ActiveRecord::Tasks::DatabaseTasks.load_schema(:ruby, ENV['SCHEMA'])
     end
 
     task :load_if_ruby => ['db:create', :environment] do
@@ -295,10 +279,7 @@ db_namespace = namespace :db do
 
     # desc "Recreate the databases from the structure.sql file"
     task :load => [:environment, :load_config] do
-      filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
-      ActiveRecord::Tasks::DatabaseTasks.check_schema_file(filename)
-      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
-      ActiveRecord::Tasks::DatabaseTasks.structure_load(current_config, filename)
+      ActiveRecord::Tasks::DatabaseTasks.load_schema(:sql, ENV['DB_STRUCTURE'])
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -308,8 +289,15 @@ db_namespace = namespace :db do
 
   namespace :test do
 
+    task :deprecated do
+      Rake.application.top_level_tasks.grep(/^db:test:/).each do |task|
+        $stderr.puts "WARNING: #{task} is deprecated. The Rails test helper now maintains " \
+                     "your test schema automatically, see the release notes for details."
+      end
+    end
+
     # desc "Recreate the test database from the current schema"
-    task :load => 'db:test:purge' do
+    task :load => %w(db:test:deprecated db:test:purge) do
       case ActiveRecord::Base.schema_format
         when :ruby
           db_namespace["test:load_schema"].invoke
@@ -319,7 +307,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent schema.rb file"
-    task :load_schema => 'db:test:purge' do
+    task :load_schema => %w(db:test:deprecated db:test:purge) do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
         ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
@@ -333,7 +321,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent structure.sql file"
-    task :load_structure => 'db:test:purge' do
+    task :load_structure => %w(db:test:deprecated db:test:purge) do
       begin
         ActiveRecord::Tasks::DatabaseTasks.current_config(:config => ActiveRecord::Base.configurations['test'])
         db_namespace["structure:load"].invoke
@@ -343,7 +331,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from a fresh schema"
-    task :clone => :environment do
+    task :clone => %w(db:test:deprecated environment) do
       case ActiveRecord::Base.schema_format
         when :ruby
           db_namespace["test:clone_schema"].invoke
@@ -353,18 +341,18 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from a fresh schema.rb file"
-    task :clone_schema => ["db:schema:dump", "db:test:load_schema"]
+    task :clone_schema => %w(db:test:deprecated db:schema:dump db:test:load_schema)
 
     # desc "Recreate the test database from a fresh structure.sql file"
-    task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
+    task :clone_structure => %w(db:test:deprecated db:structure:dump db:test:load_structure)
 
     # desc "Empty the test database"
-    task :purge => [:environment, :load_config] do
+    task :purge => %w(db:test:deprecated environment load_config) do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 
     # desc 'Check for pending migrations and load the test schema'
-    task :prepare => [:environment, :load_config] do
+    task :prepare => %w(db:test:deprecated environment load_config) do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
       end
@@ -399,5 +387,3 @@ namespace :railties do
     end
   end
 end
-
-task 'test:prepare' => ['db:test:prepare', 'db:test:load', 'db:abort_if_pending_migrations']

data/lib/active_record/relation.rb

@@ -24,6 +24,7 @@ module ActiveRecord
       @klass  = klass
       @table  = table
       @values = values
+      @offsets = {}
       @loaded = false
     end
 
@@ -495,9 +496,10 @@ module ActiveRecord
     end
 
     def reset
-      @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
+      @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
       @should_eager_load = @join_dependency = nil
       @records = []
+      @offsets = {}
       self
     end
 
@@ -533,7 +535,6 @@ module ActiveRecord
       }
 
       binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
-      binds.merge!(Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }])
 
       Hash[equalities.map { |where|
         name = where.left.name

data/lib/active_record/relation/batches.rb

@@ -52,7 +52,9 @@ module ActiveRecord
           records.each { |record| yield record }
         end
       else
-        enum_for :find_each, options
+        enum_for :find_each, options do
+          options[:start] ? where(table[primary_key].gteq(options[:start])).size : size
+        end
       end
     end
 
@@ -64,6 +66,16 @@ module ActiveRecord
     #     group.each { |person| person.party_all_night! }
     #   end
     #
+    # If you do not provide a block to #find_in_batches, it will return an Enumerator
+    # for chaining with other methods:
+    #
+    #   Person.find_in_batches.with_index do |group, batch|
+    #     puts "Processing group ##{batch}"
+    #     group.each(&:recover_from_last_night!)
+    #   end
+    #
+    # To be yielded each record one by one, use #find_each instead.
+    #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
     # * <tt>:start</tt> - Specifies the starting point for the batch processing.
@@ -88,30 +100,33 @@ module ActiveRecord
       options.assert_valid_keys(:start, :batch_size)
 
       relation = self
+      start = options[:start]
+      batch_size = options[:batch_size] || 1000
+
+      unless block_given?
+        return to_enum(:find_in_batches, options) do
+          total = start ? where(table[primary_key].gteq(start)).size : size
+          (total - 1).div(batch_size) + 1
+        end
+      end
 
       if logger && (arel.orders.present? || arel.taken.present?)
         logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
-      start = options.delete(:start)
-      batch_size = options.delete(:batch_size) || 1000
-
       relation = relation.reorder(batch_order).limit(batch_size)
       records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
 
       while records.any?
         records_size = records.size
         primary_key_offset = records.last.id
+        raise "Primary key not included in the custom select clause" unless primary_key_offset
 
         yield records
 
         break if records_size < batch_size
 
-        if primary_key_offset
-          records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
-        else
-          raise "Primary key not included in the custom select clause"
-        end
+        records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
       end
     end
 

data/lib/active_record/relation/finder_methods.rb

@@ -127,9 +127,9 @@ module ActiveRecord
     #
     def first(limit = nil)
       if limit
-        find_first_with_limit(limit)
+        find_nth_with_limit(offset_value, limit)
       else
-        find_first
+        find_nth(:first, offset_value)
       end
     end
 
@@ -172,6 +172,86 @@ module ActiveRecord
       last or raise RecordNotFound
     end
 
+    # Find the second record.
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.second # returns the second object fetched by SELECT * FROM people
+    #   Person.offset(3).second # returns the second object from OFFSET 3 (which is OFFSET 4)
+    #   Person.where(["user_name = :u", { u: user_name }]).second
+    def second
+      find_nth(:second, offset_value ? offset_value + 1 : 1)
+    end
+
+    # Same as +second+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found.
+    def second!
+      second or raise RecordNotFound
+    end
+
+    # Find the third record.
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.third # returns the third object fetched by SELECT * FROM people
+    #   Person.offset(3).third # returns the third object from OFFSET 3 (which is OFFSET 5)
+    #   Person.where(["user_name = :u", { u: user_name }]).third
+    def third
+      find_nth(:third, offset_value ? offset_value + 2 : 2)
+    end
+
+    # Same as +third+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found.
+    def third!
+      third or raise RecordNotFound
+    end
+
+    # Find the fourth record.
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.fourth # returns the fourth object fetched by SELECT * FROM people
+    #   Person.offset(3).fourth # returns the fourth object from OFFSET 3 (which is OFFSET 6)
+    #   Person.where(["user_name = :u", { u: user_name }]).fourth
+    def fourth
+      find_nth(:fourth, offset_value ? offset_value + 3 : 3)
+    end
+
+    # Same as +fourth+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found.
+    def fourth!
+      fourth or raise RecordNotFound
+    end
+
+    # Find the fifth record.
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.fifth # returns the fifth object fetched by SELECT * FROM people
+    #   Person.offset(3).fifth # returns the fifth object from OFFSET 3 (which is OFFSET 7)
+    #   Person.where(["user_name = :u", { u: user_name }]).fifth
+    def fifth
+      find_nth(:fifth, offset_value ? offset_value + 4 : 4)
+    end
+
+    # Same as +fifth+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found.
+    def fifth!
+      fifth or raise RecordNotFound
+    end
+
+    # Find the forty-second record. Also known as accessing "the reddit".
+    # If no order is defined it will order by primary key.
+    #
+    #   Person.forty_two # returns the forty-second object fetched by SELECT * FROM people
+    #   Person.offset(3).forty_two # returns the fifth object from OFFSET 3 (which is OFFSET 44)
+    #   Person.where(["user_name = :u", { u: user_name }]).forty_two
+    def forty_two
+      find_nth(:forty_two, offset_value ? offset_value + 41 : 41)
+    end
+
+    # Same as +forty_two+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found.
+    def forty_two!
+      forty_two or raise RecordNotFound
+    end
+
     # Returns +true+ if a record exists in the table that matches the +id+ or
     # conditions given, or +false+ otherwise. The argument can take six forms:
     #
@@ -195,6 +275,7 @@ module ActiveRecord
     #   Person.exists?(5)
     #   Person.exists?('5')
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
+    #   Person.exists?(id: [1, 4, 8])
     #   Person.exists?(name: 'David')
     #   Person.exists?(false)
     #   Person.exists?
@@ -230,9 +311,9 @@ module ActiveRecord
       conditions = " [#{conditions}]" if conditions
 
       if Array(ids).size == 1
-        error = "Couldn't find #{@klass.name} with #{primary_key}=#{ids}#{conditions}"
+        error = "Couldn't find #{@klass.name} with '#{primary_key}'=#{ids}#{conditions}"
       else
-        error = "Couldn't find all #{@klass.name.pluralize} with IDs "
+        error = "Couldn't find all #{@klass.name.pluralize} with '#{primary_key}': "
         error << "(#{ids.join(", ")})#{conditions} (found #{result_size} results, but was looking for #{expected_size})"
       end
 
@@ -266,7 +347,15 @@ module ActiveRecord
     end
 
     def construct_relation_for_association_calculations
-      apply_join_dependency(self, construct_join_dependency(arel.froms.first))
+      from = arel.froms.first
+      if Arel::Table === from
+        apply_join_dependency(self, construct_join_dependency)
+      else
+        # FIXME: as far as I can tell, `from` will always be an Arel::Table.
+        # There are no tests that test this branch, but presumably it's
+        # possible for `from` to be a list?
+        apply_join_dependency(self, construct_join_dependency(from))
+      end
     end
 
     def apply_join_dependency(relation, join_dependency)
@@ -363,19 +452,19 @@ module ActiveRecord
       end
     end
 
-    def find_first
+    def find_nth(ordinal, offset)
       if loaded?
-        @records.first
+        @records.send(ordinal)
       else
-        @first ||= find_first_with_limit(1).first
+        @offsets[offset] ||= find_nth_with_limit(offset, 1).first
       end
     end
 
-    def find_first_with_limit(limit)
+    def find_nth_with_limit(offset, limit)
       if order_values.empty? && primary_key
-        order(arel_table[primary_key].asc).limit(limit).to_a
+        order(arel_table[primary_key].asc).limit(limit).offset(offset).to_a
       else
-        limit(limit).to_a
+        limit(limit).offset(offset).to_a
       end
     end