From d0467e08e54a84fc4672c508716615aa0177994a Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Fri, 3 Dec 2010 13:12:59 +0100
Subject: Allow to run migrations from more than one directory

---
 .../abstract/schema_statements.rb                  |  6 ++-
 activerecord/lib/active_record/migration.rb        | 57 +++++++++++++---------
 activerecord/lib/active_record/schema.rb           |  6 +--
 activerecord/test/cases/migration_test.rb          | 12 +++++
 4 files changed, 52 insertions(+), 29 deletions(-)

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index 4e770c37da..3eb81b0dfa 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -442,12 +442,14 @@ module ActiveRecord
         end
       end
 
-      def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
+      def assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths)
+        migrations_paths = [migrations_paths] unless migrations_paths.kind_of?(Array)
         version = version.to_i
         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
         migrated = select_values("SELECT version FROM #{sm_table}").map { |v| v.to_i }
-        versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
+        paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
+        versions = Dir[*paths].map do |filename|
           filename.split('/').last.split('_').first.to_i
         end
 
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 4dc67a0905..130b43cc15 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -511,39 +511,40 @@ module ActiveRecord
 
   class Migrator#:nodoc:
     class << self
-      attr_writer :migrations_path
+      attr_writer :migrations_paths
+      alias :migrations_path= :migrations_paths=
 
-      def migrate(migrations_path, target_version = nil)
+      def migrate(migrations_paths, target_version = nil)
         case
           when target_version.nil?
-            up(migrations_path, target_version)
+            up(migrations_paths, target_version)
           when current_version == 0 && target_version == 0
             []
           when current_version > target_version
-            down(migrations_path, target_version)
+            down(migrations_paths, target_version)
           else
-            up(migrations_path, target_version)
+            up(migrations_paths, target_version)
         end
       end
 
-      def rollback(migrations_path, steps=1)
-        move(:down, migrations_path, steps)
+      def rollback(migrations_paths, steps=1)
+        move(:down, migrations_paths, steps)
       end
 
-      def forward(migrations_path, steps=1)
-        move(:up, migrations_path, steps)
+      def forward(migrations_paths, steps=1)
+        move(:up, migrations_paths, steps)
       end
 
-      def up(migrations_path, target_version = nil)
-        self.new(:up, migrations_path, target_version).migrate
+      def up(migrations_paths, target_version = nil)
+        self.new(:up, migrations_paths, target_version).migrate
       end
 
-      def down(migrations_path, target_version = nil)
-        self.new(:down, migrations_path, target_version).migrate
+      def down(migrations_paths, target_version = nil)
+        self.new(:down, migrations_paths, target_version).migrate
       end
 
-      def run(direction, migrations_path, target_version)
-        self.new(direction, migrations_path, target_version).run
+      def run(direction, migrations_paths, target_version)
+        self.new(direction, migrations_paths, target_version).run
       end
 
       def schema_migrations_table_name
@@ -569,12 +570,20 @@ module ActiveRecord
         name.table_name rescue "#{ActiveRecord::Base.table_name_prefix}#{name}#{ActiveRecord::Base.table_name_suffix}"
       end
 
+      def migrations_paths
+        @migrations_paths ||= ['db/migrate']
+        # just to not break things if someone uses: migration_path = some_string
+        @migrations_paths.kind_of?(Array) ? @migrations_paths : [@migrations_paths]
+      end
+
       def migrations_path
-        @migrations_path ||= 'db/migrate'
+        migrations_paths.first
       end
 
-      def migrations(path)
-        files = Dir["#{path}/[0-9]*_*.rb"]
+      def migrations(paths)
+        paths = [paths] unless paths.kind_of?(Array)
+
+        files = Dir[*paths.map { |p| "#{p}/[0-9]*_*.rb" }]
 
         seen = Hash.new false
 
@@ -598,22 +607,22 @@ module ActiveRecord
 
       private
 
-      def move(direction, migrations_path, steps)
-        migrator = self.new(direction, migrations_path)
+      def move(direction, migrations_paths, steps)
+        migrator = self.new(direction, migrations_paths)
         start_index = migrator.migrations.index(migrator.current_migration)
 
         if start_index
           finish = migrator.migrations[start_index + steps]
           version = finish ? finish.version : 0
-          send(direction, migrations_path, version)
+          send(direction, migrations_paths, version)
         end
       end
     end
 
-    def initialize(direction, migrations_path, target_version = nil)
+    def initialize(direction, migrations_paths, target_version = nil)
       raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
       Base.connection.initialize_schema_migrations_table
-      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+      @direction, @migrations_paths, @target_version = direction, migrations_paths, target_version
     end
 
     def current_version
@@ -679,7 +688,7 @@ module ActiveRecord
 
     def migrations
       @migrations ||= begin
-        migrations = self.class.migrations(@migrations_path)
+        migrations = self.class.migrations(@migrations_paths)
         down? ? migrations.reverse : migrations
       end
     end
diff --git a/activerecord/lib/active_record/schema.rb b/activerecord/lib/active_record/schema.rb
index c6bb5c1961..d815ab05ac 100644
--- a/activerecord/lib/active_record/schema.rb
+++ b/activerecord/lib/active_record/schema.rb
@@ -30,8 +30,8 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration
-    def migrations_path
-      ActiveRecord::Migrator.migrations_path
+    def migrations_paths
+      ActiveRecord::Migrator.migrations_paths
     end
 
     # Eval the given block. All methods available to the current connection
@@ -51,7 +51,7 @@ module ActiveRecord
 
       unless info[:version].blank?
         initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], schema.migrations_path)
+        assume_migrated_upto_version(info[:version], schema.migrations_paths)
       end
     end
   end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 96da3be655..95b7ce9f34 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -1275,6 +1275,18 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_finds_migrations_from_two_directories
+      directories = [MIGRATIONS_ROOT + '/valid_with_timestamps', MIGRATIONS_ROOT + '/to_copy_with_timestamps']
+      migrations = ActiveRecord::Migrator.new(:up, directories).migrations
+
+      [[20090101010101, "PeopleHaveHobbies"], [20090101010202, "PeopleHaveDescriptions"], 
+       [20100101010101, "PeopleHaveLastNames"], [20100201010101, "WeNeedReminders"], 
+       [20100301010101, "InnocentJointable"]].each_with_index do |pair, i|
+        assert_equal migrations[i].version, pair.first
+        assert_equal migrations[i].name, pair.last
+      end
+    end
+
     def test_finds_pending_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_2", 1)
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/interleaved/pass_2").pending_migrations
-- 
cgit v1.2.3


From c9d23214aefcf0bcebb56fce53eefa4598cbb64d Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Fri, 3 Dec 2010 13:41:51 +0100
Subject: Allow to run migrations from more than one directory in rake tasks

---
 activerecord/lib/active_record/railties/databases.rake | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 1fbc8a1d32..316e0d9a3b 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -2,7 +2,7 @@ namespace :db do
   task :load_config => :rails_env do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-    ActiveRecord::Migrator.migrations_path = Rails.application.paths["db/migrate"].first
+    ActiveRecord::Migrator.migrations_paths = Rails.application.paths["db/migrate"].to_a
   end
 
   namespace :create do
@@ -140,7 +140,7 @@ namespace :db do
   desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
   task :migrate => :environment do
     ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_path, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
@@ -163,7 +163,7 @@ namespace :db do
     task :up => :environment do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_path, version)
+      ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
       Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
@@ -171,7 +171,7 @@ namespace :db do
     task :down => :environment do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_path, version)
+      ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
       Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
@@ -209,14 +209,14 @@ namespace :db do
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
   task :rollback => :environment do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_path, step)
+    ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
   task :forward => :environment do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_path, step)
+    ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
@@ -261,7 +261,7 @@ namespace :db do
   # desc "Raises an error if there are pending migrations"
   task :abort_if_pending_migrations => :environment do
     if defined? ActiveRecord
-      pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_path).pending_migrations
+      pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_paths).pending_migrations
 
       if pending_migrations.any?
         puts "You have #{pending_migrations.size} pending migrations:"
@@ -501,7 +501,7 @@ namespace :railties do
         puts "Copied migration #{migration.basename} from #{name}"
       end
 
-      ActiveRecord::Migration.copy( ActiveRecord::Migrator.migrations_path, railties,
+      ActiveRecord::Migration.copy( ActiveRecord::Migrator.migrations_paths.first, railties,
                                     :on_skip => on_skip, :on_copy => on_copy)
     end
   end
-- 
cgit v1.2.3


From 23ba7e456dd0302aeaddb50d14e1f595c82ca6c8 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Sat, 4 Dec 2010 08:33:06 +0100
Subject: properly load database config in database rake tasks, to properly set
 migrations_paths

---
 activerecord/lib/active_record/railties/databases.rake | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 316e0d9a3b..f1e21bea3f 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -138,7 +138,7 @@ namespace :db do
 
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
-  task :migrate => :environment do
+  task :migrate => [:environment, :load_config] do
     ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
     ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
@@ -146,7 +146,7 @@ namespace :db do
 
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task :redo => :environment do
+    task :redo => [:environment, :load_config] do
       if ENV["VERSION"]
         Rake::Task["db:migrate:down"].invoke
         Rake::Task["db:migrate:up"].invoke
@@ -160,7 +160,7 @@ namespace :db do
     task :reset => ["db:drop", "db:create", "db:migrate"]
 
     # desc 'Runs the "up" for a given migration VERSION.'
-    task :up => :environment do
+    task :up => [:environment, :load_config] do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
@@ -168,7 +168,7 @@ namespace :db do
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
-    task :down => :environment do
+    task :down => [:environment, :load_config] do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
@@ -176,7 +176,7 @@ namespace :db do
     end
 
     desc "Display status of migrations"
-    task :status => :environment do
+    task :status => [:environment, :load_config] do
       config = ActiveRecord::Base.configurations[Rails.env || 'development']
       ActiveRecord::Base.establish_connection(config)
       unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
@@ -207,14 +207,14 @@ namespace :db do
   end
 
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
-  task :rollback => :environment do
+  task :rollback => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
-  task :forward => :environment do
+  task :forward => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
-- 
cgit v1.2.3


From 2dc3342f75577fa521d9d0c54260da75450126a2 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Thu, 9 Dec 2010 01:58:58 +0100
Subject: Do not require fixtures in example integration test in engine if
 active record is skipeed

---
 .../rails/plugin_new/templates/test/integration/navigation_test.rb      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/railties/lib/rails/generators/rails/plugin_new/templates/test/integration/navigation_test.rb b/railties/lib/rails/generators/rails/plugin_new/templates/test/integration/navigation_test.rb
index d06fe7cbd0..dd4d2da4eb 100644
--- a/railties/lib/rails/generators/rails/plugin_new/templates/test/integration/navigation_test.rb
+++ b/railties/lib/rails/generators/rails/plugin_new/templates/test/integration/navigation_test.rb
@@ -1,7 +1,9 @@
 require 'test_helper'
 
 class NavigationTest < ActionDispatch::IntegrationTest
+<% unless options[:skip_active_record] -%>
   fixtures :all
+<% end -%>
 
   # Replace this with your real tests.
   test "the truth" do
-- 
cgit v1.2.3


From 5df72a238e9fcb18daf6ab6e6dc9051c9106d7bb Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Sat, 4 Dec 2010 17:12:57 +0100
Subject: Rake tasks for managing database while development and testing of
 engines

Some of the engines needs database. As engine needs to be run inside
Rails application, migrations and other database operations are run
from dummy application. To make that process simple I changed db
tasks to look for migrations in both engine's and application's
db/migrate directory. You can run all of the database tasks from
test/dummy or directly from engine with prefix app, like:

  rake app:db:migrate
  rake app:db:migrate:redo
---
 .../lib/active_record/railties/databases.rake      | 28 +++++++++++-----------
 .../rails/plugin_new/plugin_new_generator.rb       | 10 ++++++++
 .../generators/rails/plugin_new/templates/Rakefile | 12 ++++++++++
 .../rails/plugin_new/templates/test/test_helper.rb |  5 ----
 .../test/generators/plugin_new_generator_test.rb   |  2 +-
 5 files changed, 37 insertions(+), 20 deletions(-)

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index f1e21bea3f..2e73cd4f1d 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -1,4 +1,4 @@
-namespace :db do
+db_namespace = namespace :db do
   task :load_config => :rails_env do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
@@ -141,18 +141,18 @@ namespace :db do
   task :migrate => [:environment, :load_config] do
     ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
     ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
       if ENV["VERSION"]
-        Rake::Task["db:migrate:down"].invoke
-        Rake::Task["db:migrate:up"].invoke
+        db_namespace["migrate:down"].invoke
+        db_namespace["migrate:up"].invoke
       else
-        Rake::Task["db:rollback"].invoke
-        Rake::Task["db:migrate"].invoke
+        db_namespace["rollback"].invoke
+        db_namespace["migrate"].invoke
       end
     end
 
@@ -164,7 +164,7 @@ namespace :db do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
-      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
@@ -172,7 +172,7 @@ namespace :db do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
-      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
     desc "Display status of migrations"
@@ -210,14 +210,14 @@ namespace :db do
   task :rollback => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
   task :forward => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
@@ -321,12 +321,12 @@ namespace :db do
 
   namespace :schema do
     desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
-    task :dump => :environment do
+    task :dump => :load_config do
       require 'active_record/schema_dumper'
       File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
-      Rake::Task["db:schema:dump"].reenable
+      db_namespace["schema:dump"].reenable
     end
 
     desc "Load a schema.rb file into the database"
@@ -383,7 +383,7 @@ namespace :db do
     task :load => 'db:test:purge' do
       ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
       ActiveRecord::Schema.verbose = false
-      Rake::Task["db:schema:load"].invoke
+      db_namespace["schema:load"].invoke
     end
 
     # desc "Recreate the test database from the current environment's database schema"
@@ -457,7 +457,7 @@ namespace :db do
     # desc 'Check for pending migrations and load the test schema'
     task :prepare => 'db:abort_if_pending_migrations' do
       if defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
-        Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:load" }[ActiveRecord::Base.schema_format]].invoke
+        db_namespace[{ :sql  => "test:clone_structure", :ruby => "test:load" }[ActiveRecord::Base.schema_format]].invoke
       end
     end
   end
diff --git a/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb b/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
index 9c54b98238..77497f9e44 100644
--- a/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
+++ b/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
@@ -70,6 +70,16 @@ task :default => :test
       if mountable?
         template "rails/routes.rb", "#{dummy_path}/config/routes.rb", :force => true
       end
+
+      if full? && !options[:skip_active_record]
+        append_file "#{dummy_path}/Rakefile", <<-EOF
+
+task :"db:load_config" do
+  ActiveRecord::Migrator.migrations_paths = Rails.application.config.paths["db/migrate"].to_a +
+                                            <%= camelized %>::Engine.config.paths["db/migrate"].to_a
+end
+        EOF
+      end
     end
 
     def test_dummy_clean
diff --git a/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile b/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
index 12350309bf..b7cab3859a 100755
--- a/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
+++ b/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
@@ -14,3 +14,15 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+<% if full? && !options[:skip_active_record] -%>
+namespace :app do
+  load File.expand_path("../<%= dummy_path -%>/Rakefile", __FILE__)
+
+  task :"db:load_config" do
+    ActiveRecord::Migrator.migrations_paths = Rails.application.config.paths["db/migrate"].to_a +
+                                              <%= camelized %>::Engine.config.paths["db/migrate"].to_a
+  end
+end
+<% end -%>
+
diff --git a/railties/lib/rails/generators/rails/plugin_new/templates/test/test_helper.rb b/railties/lib/rails/generators/rails/plugin_new/templates/test/test_helper.rb
index 7b61047e77..791b901593 100644
--- a/railties/lib/rails/generators/rails/plugin_new/templates/test/test_helper.rb
+++ b/railties/lib/rails/generators/rails/plugin_new/templates/test/test_helper.rb
@@ -6,10 +6,5 @@ require "rails/test_help"
 
 Rails.backtrace_cleaner.remove_silencers!
 
-<% if full? && !options[:skip_active_record] -%>
-# Run any available migration from application
-ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
-<% end -%>
-
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
diff --git a/railties/test/generators/plugin_new_generator_test.rb b/railties/test/generators/plugin_new_generator_test.rb
index 2105585272..0d24821ff6 100644
--- a/railties/test/generators/plugin_new_generator_test.rb
+++ b/railties/test/generators/plugin_new_generator_test.rb
@@ -114,7 +114,7 @@ class PluginNewGeneratorTest < Rails::Generators::TestCase
   end
 
   def test_ensure_that_tests_works_in_full_mode
-    run_generator [destination_root, "--full"]
+    run_generator [destination_root, "--full", "--skip_active_record"]
     FileUtils.cd destination_root
     `bundle install`
     assert_match /2 tests, 2 assertions, 0 failures, 0 errors/, `bundle exec rake test`
-- 
cgit v1.2.3


From 051127d4d38329238bb0b3587ef128f131174786 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Wed, 8 Dec 2010 23:15:13 +0100
Subject: Rails::Engine.find(path) - method to find engine by path

---
 railties/lib/rails/application/railties.rb |  8 --------
 railties/lib/rails/engine.rb               |  5 +++++
 railties/lib/rails/engine/railties.rb      | 10 ++++++++++
 railties/test/railties/engine_test.rb      | 19 +++++++++++++++++++
 4 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/railties/lib/rails/application/railties.rb b/railties/lib/rails/application/railties.rb
index c1d2de571f..4fc5e92837 100644
--- a/railties/lib/rails/application/railties.rb
+++ b/railties/lib/rails/application/railties.rb
@@ -8,14 +8,6 @@ module Rails
         @all.each(&block) if block
         @all
       end
-
-      def railties
-        @railties ||= ::Rails::Railtie.subclasses.map(&:instance)
-      end
-
-      def engines
-        @engines ||= ::Rails::Engine.subclasses.map(&:instance)
-      end
     end
   end
 end
diff --git a/railties/lib/rails/engine.rb b/railties/lib/rails/engine.rb
index 85fa4424c4..b188fdfca1 100644
--- a/railties/lib/rails/engine.rb
+++ b/railties/lib/rails/engine.rb
@@ -371,6 +371,11 @@ module Rails
          end
         end
       end
+
+      # Finds engine with given path
+      def find(path)
+        Rails::Engine::Railties.engines.find { |r| File.expand_path(r.root.to_s) == File.expand_path(path.to_s) }
+      end
     end
 
     delegate :middleware, :root, :paths, :to => :config
diff --git a/railties/lib/rails/engine/railties.rb b/railties/lib/rails/engine/railties.rb
index e91bdbf1e5..d5ecd2e48d 100644
--- a/railties/lib/rails/engine/railties.rb
+++ b/railties/lib/rails/engine/railties.rb
@@ -18,6 +18,16 @@ module Rails
           Plugin.all(plugin_names, @config.paths["vendor/plugins"].existent)
         end
       end
+
+      def self.railties
+        @railties ||= ::Rails::Railtie.subclasses.map(&:instance)
+      end
+
+      def self.engines
+        @engines ||= ::Rails::Engine.subclasses.map(&:instance)
+      end
+
+      delegate :railties, :engines, :to => "self.class"
     end
   end
 end
diff --git a/railties/test/railties/engine_test.rb b/railties/test/railties/engine_test.rb
index 7548c6318e..05bd0c36cd 100644
--- a/railties/test/railties/engine_test.rb
+++ b/railties/test/railties/engine_test.rb
@@ -702,5 +702,24 @@ module RailtiesTest
 
       assert_equal "foo", Bukkits.table_name_prefix
     end
+
+    test "fetching engine by path" do
+      @plugin.write "lib/bukkits.rb", <<-RUBY
+        module Bukkits
+          class Engine < ::Rails::Engine
+          end
+        end
+      RUBY
+
+      boot_rails
+      require "#{rails_root}/config/environment"
+
+      assert_equal Bukkits::Engine.instance, Rails::Engine.find(@plugin.path)
+
+      # check expanding paths
+      engine_dir = @plugin.path.chomp("/").split("/").last
+      engine_path = File.join(@plugin.path, '..', engine_dir)
+      assert_equal Bukkits::Engine.instance, Rails::Engine.find(engine_path)
+    end
   end
 end
-- 
cgit v1.2.3


From 843130dbe7fb0545db13bdfc163b919cfd0e128f Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Wed, 8 Dec 2010 23:25:39 +0100
Subject: Use Rails::Engine.find in commands.rb

---
 railties/lib/rails/commands.rb | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/railties/lib/rails/commands.rb b/railties/lib/rails/commands.rb
index 338565247f..46363d7921 100644
--- a/railties/lib/rails/commands.rb
+++ b/railties/lib/rails/commands.rb
@@ -18,8 +18,7 @@ when 'generate', 'destroy', 'plugin'
     require APP_PATH
     Rails.application.require_environment!
 
-    if defined?(ENGINE_PATH)
-      engine = Rails.application.railties.engines.find { |r| r.root.to_s == ENGINE_PATH }
+    if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
       Rails.application = engine
     end
 
-- 
cgit v1.2.3


From 7b9f634e15bfc3f92f4ac7e18537443a55306c10 Mon Sep 17 00:00:00 2001
From: Piotr Sarnacki <drogus@gmail.com>
Date: Wed, 8 Dec 2010 23:29:25 +0100
Subject: Refactor db:load:config to automatically pick additional migrations
 if ENGINE_PATH is available

---
 activerecord/lib/active_record/railties/databases.rake         |  6 ++++++
 .../rails/generators/rails/plugin_new/plugin_new_generator.rb  | 10 ----------
 .../lib/rails/generators/rails/plugin_new/templates/Rakefile   |  6 +-----
 3 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index 2e73cd4f1d..a4fc18148e 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -3,6 +3,12 @@ db_namespace = namespace :db do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
     ActiveRecord::Migrator.migrations_paths = Rails.application.paths["db/migrate"].to_a
+
+    if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
+      if engine.paths["db/migrate"].existent
+        ActiveRecord::Migrator.migrations_paths += engine.paths["db/migrate"].to_a
+      end
+    end
   end
 
   namespace :create do
diff --git a/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb b/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
index 77497f9e44..9c54b98238 100644
--- a/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
+++ b/railties/lib/rails/generators/rails/plugin_new/plugin_new_generator.rb
@@ -70,16 +70,6 @@ task :default => :test
       if mountable?
         template "rails/routes.rb", "#{dummy_path}/config/routes.rb", :force => true
       end
-
-      if full? && !options[:skip_active_record]
-        append_file "#{dummy_path}/Rakefile", <<-EOF
-
-task :"db:load_config" do
-  ActiveRecord::Migrator.migrations_paths = Rails.application.config.paths["db/migrate"].to_a +
-                                            <%= camelized %>::Engine.config.paths["db/migrate"].to_a
-end
-        EOF
-      end
     end
 
     def test_dummy_clean
diff --git a/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile b/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
index b7cab3859a..25292f59ad 100755
--- a/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
+++ b/railties/lib/rails/generators/rails/plugin_new/templates/Rakefile
@@ -17,12 +17,8 @@ end
 
 <% if full? && !options[:skip_active_record] -%>
 namespace :app do
+  ENGINE_PATH = File.expand_path("..", __FILE__)
   load File.expand_path("../<%= dummy_path -%>/Rakefile", __FILE__)
-
-  task :"db:load_config" do
-    ActiveRecord::Migrator.migrations_paths = Rails.application.config.paths["db/migrate"].to_a +
-                                              <%= camelized %>::Engine.config.paths["db/migrate"].to_a
-  end
 end
 <% end -%>
 
-- 
cgit v1.2.3