standalone_migrations 0.4.11 → 1.0.0

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'rake'
+gem 'activerecord', ENV['AR'] || '>=3'
+
+group :dev do
+  gem 'sqlite3'
+  gem 'rspec', '~>2'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,47 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.0.rc4)
+      activesupport (= 3.1.0.rc4)
+      bcrypt-ruby (~> 2.1.4)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.0.rc4)
+      activemodel (= 3.1.0.rc4)
+      activesupport (= 3.1.0.rc4)
+      arel (~> 2.1.1)
+      tzinfo (~> 0.3.27)
+    activesupport (3.1.0.rc4)
+      multi_json (~> 1.0)
+    arel (2.1.1)
+    bcrypt-ruby (2.1.4)
+    builder (3.0.0)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    i18n (0.6.0)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    multi_json (1.0.3)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sqlite3 (1.3.3)
+    tzinfo (0.3.27)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3)
+  jeweler
+  rake
+  rspec (~> 2)
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Todd Huss
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -1,5 +1,13 @@
 Rails migrations in non-Rails (and non Ruby) projects.  
 
+WHAT'S NEW
+==========
+In the 1.0 release we have moved to using Rails 3 migrations instead of maintaining our own migration related code. Just about anything you can do with Rails 3 migrations you can now do with [Standalone Migrations](https://github.com/thuss/standalone-migrations) too! This removed 95% of the code we have to maintain. Big thanks to [Michael Grosser](http://pragmatig.wordpress.com) for undertaking this major rewrite!
+
+CONTRIBUTE
+==========
+[Standalone Migrations](https://github.com/thuss/standalone-migrations) relies on the contributions of the open-source community! To submit a fix or an enhancement fork the repository, checkout the *develop* branch, make your changes, add your name to the *Contributors* section in README.markdown, and send us a pull request! If you're active and do good work we'll add you as a collaborator!
+
 USAGE
 =====
 Install Ruby, RubyGems and a ruby-database driver (e.g. `gem install mysql`) then:
@@ -10,15 +18,6 @@ Add to `Rakefile` in your projects base directory:
 
     begin
       require 'tasks/standalone_migrations'
-      MigratorTasks.new do |t|
-        # t.migrations = "db/migrations"
-        # t.config = "db/config.yml"
-        # t.schema = "db/schema.rb"
-        # t.sub_namespace = "dbname"
-        # t.env = "DB"
-        # t.verbose = true
-        # t.log_level = Logger::ERROR
-      end
     rescue LoadError => e
       puts "gem install standalone_migrations to get db:migrate:* tasks! (Error: #{e})"
     end
@@ -50,7 +49,7 @@ Add database configuration to `db/config.yml` in your projects base directory e.
 ### To create a new database migration:
 
     rake db:new_migration name=FooBarMigration
-    edit db/migrations/20081220234130_foo_bar_migration.rb
+    edit db/migrate/20081220234130_foo_bar_migration.rb
 
 ... and fill in the up and down migrations [Cheatsheet](http://dizzy.co.uk/ruby_on_rails/cheatsheets/rails-migrations).
 
@@ -76,7 +75,7 @@ An example to create a Person table with 3 columns (and it will automatically ad
 
     rake db:generate model="Person" fields="string:first_name string:last_name integer:age"
 
-This will create a migration in db/migrations/
+This will create a migration in db/migrate/
 
     class CreatePerson < ActiveRecord::Migration
       def self.up
@@ -103,40 +102,20 @@ This will create a migration in db/migrations/
 
 ### To migrate a specific database (for example your "testing" database)
 
-    rake db:migrate DB=test
+    rake db:migrate DB=test ... or ...
+    rake db:migrate RAILS_ENV=test
 
 ### To execute a specific up/down of one single migration
 
     rake db:migrate:up VERSION=20081220234130
-
+    
 ### To revert your last migration
 
     rake db:rollback
 
 ### To revert your last 3 migrations
 
-    rake db:rollback STEP=3
-
-## Sub-namespacing
-
-When working with multiple databases in a single application it is convenient
-to have separate sets of tasks for each database. This is accomplished with
-sub_namespace parameter - for example, given the following declaration:
-
-    MigratorTasks.new do |t|
-      t.migrations = "db/migrate/widgets"
-      t.sub_namespace = "widgets"
-      ...
-    end
-
-The following tasks will be created:
-
-    db:widgets:new_migration
-    db:widgets:migrate
-    ...
-
-And migrations for this database would be created in db/migrate/widgets
-subdirectory.
+    rake db:rollback STEP=3    
 
 Contributors
 ============

data/Rakefile

@@ -1,17 +1,10 @@
-task :default => :spec
+task :default do
+  sh "rspec spec"
+end
 
-begin
-  require 'rspec/core/rake_task'
-rescue LoadError => e
-  $stderr.puts "RSpec 2, or one of its dependencies, is not available:"
-  $stderr.puts "#{e.class}: #{e.message}"
-  $stderr.puts "Install it with: sudo gem install rspec"
-  $stderr.puts "Test-related tasks will not be available."
-  $stderr.puts "If you have RSpec 1 installed you can try running the tests with:"
-  $stderr.puts "  spec spec"
-  $stderr.puts "However, RSpec 1 is not officially supported."
-else
-  RSpec::Core::RakeTask.new {|t| t.rspec_opts = ['--color']}
+task :all do
+  sh "AR='~>3.0.0' bundle update activerecord && bundle exec rake"
+  sh "AR='~>3.1.0.rc4' bundle update activerecord && bundle exec rake"
 end
 
 # rake install -> install gem locally (for tests)
@@ -30,8 +23,6 @@ else
     gem.email = "thuss@gabrito.com"
     gem.homepage = "http://github.com/thuss/standalone-migrations"
     gem.authors = ["Todd Huss", "Michael Grosser"]
-    gem.files += ["lib/tasks/*"]
-    %w[rake activerecord].each{|d| gem.add_dependency d}
   end
 
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.4.11
+1.0.0

data/lib/tasks/standalone_migrations.rb

@@ -1,350 +1,62 @@
-require 'rake'
-require 'rake/tasklib'
-require 'logger'
+require 'active_support/all'
+require 'active_record'
+require 'pathname'
 
-class MigratorTasks < ::Rake::TaskLib
-  DefaultEnv = 'development'
-
-  attr_accessor :name, :base, :vendor, :config, :schema, :env, :current_env
-  attr_accessor :verbose, :log_level, :logger, :sub_namespace
-  attr_reader :migrations
+# earlier versions used migrations from db/migrations, so warn users about the change
+if File.directory?('db/migrations')
+  puts "DEPRECATED move your migrations into db/migrate"
+end
 
-  def initialize(name = :migrator)
-    @name = name
-    base = File.expand_path('.')
-    here = File.expand_path(File.dirname(File.dirname(File.dirname((__FILE__)))))
-    @base = base
-    @vendor = "#{here}/vendor"
-    @migrations = ["#{base}/db/migrations"]
-    @config = "#{base}/db/config.yml"
-    @schema = "#{base}/db/schema.rb"
-    @env = 'DB'
-    @verbose = true
-    @log_level = Logger::ERROR
-    yield self if block_given?
-    # Add to load_path every "lib/" directory in vendor
-    Dir["#{vendor}/**/lib"].each { |p| $LOAD_PATH << p }
-    define
-  end
+DB_CONFIG = YAML.load_file('db/config.yml').with_indifferent_access
 
-  def migrations=(*value)
-    @migrations = value.flatten
+module Rails
+  def self.env
+    s = (ENV['RAILS_ENV'] || ENV['DB'] || 'development').dup # env is frozen -> dup
+    def s.development?; self == 'development';end
+    s
   end
 
-  def define
-    namespace :db do
-      if sub_namespace
-        namespace sub_namespace do
-          define_tasks
-        end
-      else
-        define_tasks
-      end
-    end
+  def self.root
+    Pathname.new Dir.pwd
   end
 
-  def define_tasks
-    sub_namespace_with_separator = sub_namespace ? "#{sub_namespace}:" : ''
-
-    def ar_init(connect = true)
-      require 'active_record'
-      self.current_env = ENV[@env] || DefaultEnv
-
-      if @config.is_a?(Hash)
-        ActiveRecord::Base.configurations = @config
-      else
-        require 'erb'
-        ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(@config)).result)
-      end
-      ActiveRecord::Base.establish_connection(current_env) if connect
-      if @logger
-        logger = @logger
-      else
-        logger = Logger.new($stderr)
-        logger.level = @log_level
-      end
-      ActiveRecord::Base.logger = logger
-    end
-
-    task :ar_init do
-      ar_init
-    end
-
-    desc "Migrate the database using the scripts in the migrations directory. Target specific version with VERSION=x. Turn off output with VERBOSE=false."
-    task :migrate => :ar_init do
-      begin
-        require 'migration_helpers'
-      rescue LoadError
-        require "#{@vendor}/migration_helpers/init"
-      end
-      ActiveRecord::Migration.verbose = ENV['VERBOSE'] || @verbose
-      @migrations.each do |path|
-        ActiveRecord::Migrator.migrate(path, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-      end
-      Rake::Task["db:#{sub_namespace_with_separator}schema:dump"].execute
-    end
-    
-    desc "Revert the last migration applied. Revert multiple migrations with STEP=x."
-    task :rollback => :ar_init do
-      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-      @migrations.each do |path|
-        ActiveRecord::Migrator.rollback(path, step)
-      end
-      Rake::Task["db:#{sub_namespace_with_separator}schema:dump"].execute
-    end
-
-    desc "Retrieves the current schema version number"
-    task :version => :ar_init do
-      puts "Current version: #{ActiveRecord::Migrator.current_version}"
-    end
-
-
-    def create_database(config)
-      begin
-        if config['adapter'] =~ /sqlite/
-          if File.exist?(config['database'])
-            $stderr.puts "#{config['database']} already exists"
-          else
-            begin
-              # Create the SQLite database
-              ActiveRecord::Base.establish_connection(config)
-              ActiveRecord::Base.connection
-            rescue Exception => e
-              $stderr.puts e, *(e.backtrace)
-              $stderr.puts "Couldn't create database for #{config.inspect}"
-            end
-          end
-          return # Skip the else clause of begin/rescue
-        else
-          ActiveRecord::Base.establish_connection(config)
-          ActiveRecord::Base.connection
-        end
-      rescue
-        case config['adapter']
-          when /mysql/
-            @charset = ENV['CHARSET'] || 'utf8'
-            @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
-            creation_options = {:charset => (config['charset'] || @charset), :collation => (config['collation'] || @collation)}
-            error_class = config['adapter'] =~ /mysql2/ ? Mysql2::Error : Mysql::Error
-            access_denied_error = 1045
-            begin
-              ActiveRecord::Base.establish_connection(config.merge('database' => nil))
-              ActiveRecord::Base.connection.create_database(config['database'], creation_options)
-              ActiveRecord::Base.establish_connection(config)
-            rescue error_class => sqlerr
-              if sqlerr.errno == access_denied_error
-                print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
-                root_password = $stdin.gets.strip
-                grant_statement = "GRANT ALL PRIVILEGES ON #{config['database']}.* " \
-            "TO '#{config['username']}'@'localhost' " \
-            "IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;"
-                ActiveRecord::Base.establish_connection(config.merge(
-                                                            'database' => nil, 'username' => 'root', 'password' => root_password))
-                ActiveRecord::Base.connection.create_database(config['database'], creation_options)
-                ActiveRecord::Base.connection.execute grant_statement
-                ActiveRecord::Base.establish_connection(config)
-              else
-                $stderr.puts sqlerr.error
-                $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config['charset'] || @charset}, collation: #{config['collation'] || @collation}"
-                $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['charset']
-              end
-            end
-          when 'postgresql'
-            @encoding = config['encoding'] || ENV['CHARSET'] || 'utf8'
-            begin
-              ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-              ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => @encoding))
-              ActiveRecord::Base.establish_connection(config)
-            rescue Exception => e
-              $stderr.puts e, *(e.backtrace)
-              $stderr.puts "Couldn't create database for #{config.inspect}"
-            end
-        end
-      else
-        $stderr.puts "#{config['database']} already exists" unless config['adapter'] =~ /sqlite/
-      end
-    end
-
-    desc 'Create the database from config/database.yml for the current DB'
-    task :create do
-      ar_init(false)
-      config = ActiveRecord::Base.configurations[self.current_env]
-      raise ArgumentError, "#{self.current_env} database is not configured" unless config
-      create_database config
-    end
-
-    def drop_database(config)
-      case config['adapter']
-        when /mysql/
-          ActiveRecord::Base.establish_connection(config)
-          ActiveRecord::Base.connection.drop_database config['database']
-        when /^sqlite/
-          require 'pathname'
-          path = Pathname.new(config['database'])
-          file = path.absolute? ? path.to_s : File.join(@base, path)
-          FileUtils.rm(file)
-        when 'postgresql'
-          ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-          ActiveRecord::Base.connection.drop_database config['database']
-      end
-    end
-
-    desc 'Drops the database for the current DB'
-    task :drop => :ar_init do
-      config = ActiveRecord::Base.configurations[current_env]
-      drop_database(config)
-    end
-
-    namespace :migrate do
-      [:up, :down].each do |direction|
-        desc "Runs the '#{direction}' for a given migration VERSION."
-        task direction => :ar_init do
-          ActiveRecord::Migration.verbose = @verbose
-          version = ENV["VERSION"].to_i
-          raise "VERSION is required (must be a number)" if version == 0
-          migration_path = nil
-          if @migrations.length == 1
-            migration_path = @migrations.first
-          else
-            @migrations.each do |path|
-              Dir[File.join(path, '*.rb')].each do |file|
-                if File.basename(file).match(/^\d+/)[0] == version.to_s
-                  migration_path = path
-                  break
-                end
-              end
-            end
-            raise "Migration #{version} wasn't found on paths #{@migrations.join(', ')}" if migration_path.nil?
-          end
-          ActiveRecord::Migrator.run(direction, migration_path, version)
-          Rake::Task["db:#{sub_namespace_with_separator}schema:dump"].execute
-        end
-      end
-    end
-
-    desc "Raises an error if there are pending migrations"
-    task :abort_if_pending_migrations => :ar_init do
-      @migrations.each do |path|
-        pending_migrations = ActiveRecord::Migrator.new(:up, path).pending_migrations
-
-        if pending_migrations.any?
-          puts "You have #{pending_migrations.size} pending migrations:"
-          pending_migrations.each do |pending_migration|
-            puts '  %4d %s' % [pending_migration.version, pending_migration.name]
-          end
-          abort %{Run "rake db:migrate" to update your database then try again.}
-        end
-      end
-    end
+  def self.application
+    s = "fake_app"
 
-    namespace :schema do
-      desc "Create schema.rb file that can be portably used against any DB supported by AR"
-      task :dump => :ar_init do
-        if schema_file = ENV['SCHEMA'] || @schema
-          require 'active_record/schema_dumper'
-          File.open(schema_file, "w") do |file|
-            ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
-          end
-        end
-      end
-
-      desc "Load a ar_schema.rb file into the database"
-      task :load => :ar_init do
-        file = ENV['SCHEMA'] || @schema
-        load(file)
-      end
+    def s.paths
+      Dir.glob('db/*').inject({}){|hash,x|hash[x]=[x]; hash}
     end
 
-    namespace :test do
-      desc "Recreate the test database from the current schema.rb"
-      task :load => ["db:#{sub_namespace_with_separator}ar_init", "db:#{sub_namespace_with_separator}test:purge"] do
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Schema.verbose = false
-        Rake::Task["db:#{sub_namespace_with_separator}schema:load"].invoke
+    def s.config
+      s = "fake_config"
+      def s.database_configuration
+        DB_CONFIG
       end
-
-      desc "Empty the test database"
-      task :purge => "db:#{sub_namespace_with_separator}ar_init" do
-        config = ActiveRecord::Base.configurations['test']
-        case config["adapter"]
-          when *["mysql", "mysql2"]
-            ActiveRecord::Base.establish_connection(:test)
-            ActiveRecord::Base.connection.recreate_database(config["database"], config)
-          when "postgresql" #TODO i doubt this will work <-> methods are not defined
-            ActiveRecord::Base.clear_active_connections!
-            drop_database(config)
-            create_database(config)
-          when "sqlite", "sqlite3"
-            db_file = config["database"] || config["dbfile"]
-            File.delete(db_file) if File.exist?(db_file)
-          when "sqlserver"
-            drop_script = "#{config["host"]}.#{config["database"]}.DP1".gsub(/\\/, '-')
-            `osql -E -S #{config["host"]} -d #{config["database"]} -i db\\#{drop_script}`
-            `osql -E -S #{config["host"]} -d #{config["database"]} -i db\\test_structure.sql`
-          when "oci", "oracle"
-            ActiveRecord::Base.establish_connection(:test)
-            ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-              ActiveRecord::Base.connection.execute(ddl)
-            end
-          when "firebird"
-            ActiveRecord::Base.establish_connection(:test)
-            ActiveRecord::Base.connection.recreate_database!
-          else
-            raise "Task not supported by #{config["adapter"].inspect}"
-        end
-      end
-
-      desc 'Check for pending migrations and load the test schema'
-      task :prepare => ["db:#{sub_namespace_with_separator}abort_if_pending_migrations", "db:#{sub_namespace_with_separator}test:load"]
+      s
     end
+    s
+  end
+end
 
-    desc 'generate a model=name field="type:column_name0 type:column_name1 ... type:column_namen"'
-    task :generate do
-      ts = Time.now.strftime '%Y%m%d%H%%M%S'
-
-      if ENV['model']
-        table_name = ENV['model']
-      else
-        print 'model name> '
-        table_name = $stdin.gets.strip
-      end
-
-      raise ArgumentError, 'must provide a name for the model to generate' if table_name.empty?
-
-      create_table_str = "create_table :#{table_name} do |t|"
-
-      fields = ENV['fields'] if ENV['fields']
-
-      columns = ENV.has_key?('fields') ? ENV['fields'].split.map { |v| "t.#{v.sub(/:/, ' :')}" }.join("\n#{' '*6}") : nil
-
-      create_table_str << "\n      #{columns}" if columns
+task(:rails_env){}
 
-      contents = <<-MIGRATION
-class Create#{class_name table_name} < ActiveRecord::Migration
-  def self.up
-    #{create_table_str}   
-      t.timestamps
-    end
-  end
-           
-  def self.down
-    drop_table :#{table_name}
-  end
+task(:environment) do
+  ActiveRecord::Base.configurations = DB_CONFIG
+  ActiveRecord::Base.establish_connection DB_CONFIG[Rails.env]
 end
-        MIGRATION
 
-      create_file @migrations.first, file_name("create_#{table_name}"), contents
-    end
+load 'active_record/railties/databases.rake'
 
-    desc "Create a new migration"
-    task :new_migration do |t|
-      unless migration = ENV['name']
-        puts "Error: must provide name of migration to generate."
-        puts "For example: rake #{t.name} name=add_field_to_form"
-        abort
-      end
+namespace :db do
+  desc "Create a new migration"
+  task :new_migration do |t|
+    unless migration = ENV['name']
+      puts "Error: must provide name of migration to generate."
+      puts "For example: rake #{t.name} name=add_field_to_form"
+      abort
+    end
 
-      file_contents = <<eof
+    file_contents = <<eof
 class #{class_name migration} < ActiveRecord::Migration
   def self.up
   end
@@ -354,23 +66,21 @@ class #{class_name migration} < ActiveRecord::Migration
   end
 end
 eof
-
-      create_file @migrations.first, file_name(migration), file_contents
-
-      puts "Created migration #{file_name migration}"
-    end
-  end
-
-  def class_name str
-    str.split('_').map { |s| s.capitalize }.join
+    create_file file_name(migration), file_contents
+    puts "Created migration #{file_name migration}"
   end
 
-  def create_file path, file, contents
+  def create_file file, contents
+    path = File.dirname(file)
     FileUtils.mkdir_p path unless File.exists? path
     File.open(file, 'w') { |f| f.write contents }
   end
 
   def file_name migration
-    File.join @migrations.first, "#{Time.now.utc.strftime '%Y%m%d%H%M%S'}_#{migration}.rb"
+    File.join 'db/migrate', "#{Time.now.utc.strftime '%Y%m%d%H%M%S'}_#{migration}.rb"
+  end
+
+  def class_name str
+    str.split('_').map { |s| s.capitalize }.join
   end
 end

data/spec/standalone_migrations_spec.rb

@@ -12,8 +12,8 @@ describe 'Standalone migrations' do
   end
 
   def migration(name)
-    m = `cd spec/tmp/db/migrations && ls`.split("\n").detect { |m| m =~ name }
-    m ? "db/migrations/#{m}" : m
+    m = `cd spec/tmp/db/migrate && ls`.split("\n").detect { |m| m =~ name }
+    m ? "db/migrate/#{m}" : m
   end
 
   def tmp_file(file)
@@ -21,16 +21,14 @@ describe 'Standalone migrations' do
   end
 
   def run(cmd)
-    `cd spec/tmp && #{cmd} 2>&1 && echo SUCCESS`
-  end
-
-  def run_with_output(cmd)
-    `cd spec/tmp && #{cmd} 2>&1`
+    result = `cd spec/tmp && #{cmd} 2>&1`
+    raise result unless $?.success?
+    result
   end
 
   def make_migration(name, options={})
     task_name = options[:task_name] || 'db:new_migration'
-    migration = run("rake #{task_name} name=#{name}").match(%r{db/migrations/\d+.*.rb})[0]
+    migration = run("rake #{task_name} name=#{name}").match(%r{db/migrate/\d+.*.rb})[0]
     content = read(migration)
     content.sub!(/def self.down.*?\send/m, "def self.down;puts 'DOWN-#{name}';end")
     content.sub!(/def self.up.*?\send/m, "def self.up;puts 'UP-#{name}';end")
@@ -38,62 +36,39 @@ describe 'Standalone migrations' do
     migration.match(/\d{14}/)[0]
   end
 
-  def make_sub_namespaced_migration(namespace, name)
-    # specify complete task name here to avoid conditionals in make_migration
-    make_migration(name, :task_name => "db:#{namespace}:new_migration")
-  end
-
   def write_rakefile(config=nil)
     write 'Rakefile', <<-TXT
-      $LOAD_PATH.unshift '#{File.expand_path('lib')}'
-      begin
-        require 'tasks/standalone_migrations'
-        MigratorTasks.new do |t|
-          t.log_level = Logger::INFO
-          #{config}
-        end
-      rescue LoadError => e
-        puts "gem install standalone_migrations to get db:migrate:* tasks! (Error: \#{e})"
-      end
-    TXT
-  end
-  
-  def write_reversible_migration
-    write "db/migrations/20110703102233_create_tests.rb", <<-TXT
-class CreateTests < ActiveRecord::Migration
-def self.up
-  puts "UP-CreateTests"
-end
-
-def self.down
-  puts "DOWN-CreateTests"
-end
+$LOAD_PATH.unshift '#{File.expand_path('lib')}'
+begin
+  require 'tasks/standalone_migrations'
+rescue LoadError => e
+  puts "gem install standalone_migrations to get db:migrate:* tasks! (Error: \#{e})"
 end
     TXT
   end
 
   def write_multiple_migrations
     write_rakefile %{t.migrations = "db/migrations", "db/migrations2"}
-    write "db/migrations/20100509095815_create_tests.rb", <<-TXT
+    write "db/migrate/20100509095815_create_tests.rb", <<-TXT
 class CreateTests < ActiveRecord::Migration
-def self.up
-  puts "UP-CreateTests"
-end
+  def self.up
+    puts "UP-CreateTests"
+  end
 
-def self.down
-  puts "DOWN-CreateTests"
-end
+  def self.down
+    puts "DOWN-CreateTests"
+  end
 end
     TXT
-    write "db/migrations2/20100509095816_create_tests2.rb", <<-TXT
+    write "db/migrate/20100509095816_create_tests2.rb", <<-TXT
 class CreateTests2 < ActiveRecord::Migration
-def self.up
-  puts "UP-CreateTests2"
-end
+  def self.up
+    puts "UP-CreateTests2"
+  end
 
-def self.down
-  puts "DOWN-CreateTests2"
-end
+  def self.down
+    puts "DOWN-CreateTests2"
+  end
 end
     TXT
   end
@@ -103,65 +78,37 @@ end
     `mkdir spec/tmp`
     write_rakefile
     write 'db/config.yml', <<-TXT
-      development:
-        adapter: sqlite3
-        database: db/development.sql
-      test:
-        adapter: sqlite3
-        database: db/test.sql
+development:
+  adapter: sqlite3
+  database: db/development.sql
+test:
+  adapter: sqlite3
+  database: db/test.sql
     TXT
   end
 
-  describe 'db:create and drop' do
-    it "should create the database and drop the database that was created" do
-      run_with_output("rake db:create").should match /spec\/tmp\)$/
-      run_with_output("rake db:drop").should match /spec\/tmp\)$/
-    end
+  it "warns of deprecated folder structure" do
+    warning = /DEPRECATED.* db\/migrate/
+    run("rake db:create").should_not =~ warning
+    write('db/migrations/fooo.rb', 'xxx')
+    run("rake db:create").should =~ warning
   end
 
-  describe 'db:create when nonexistent environment is specified' do
-    it "should provide an informative error message" do
-      run_with_output("rake db:create DB=nonexistent").should match /nonexistent database is not configured/
+  describe 'db:create and drop' do
+    it "should create the database and drop the database that was created" do
+      run "rake db:create"
+      run "rake db:drop"
     end
   end
 
   describe 'db:new_migration' do
-    context "single migration path" do
-      it "fails if i do not add a name" do
-        run("rake db:new_migration").should_not =~ /SUCCESS/
-      end
-
-      it "generates a new migration with this name and timestamp" do
-        run("rake db:new_migration name=test_abc").should =~ %r{Created migration .*spec/tmp/db/migrations/\d+_test_abc\.rb}
-        run("ls db/migrations").should =~ /^\d+_test_abc.rb$/
-      end
-    end
-
-    context "multiple migration paths" do
-      before do
-        write_rakefile %{t.migrations = "db/migrations", "db/migrations2"}
-      end
-      it "chooses the first path" do
-        run("rake db:new_migration name=test_abc").should =~ %r{Created migration .*db/migrations/\d+_test_abc\.rb}
-      end
+    it "fails if i do not add a name" do
+      lambda{ run("rake db:new_migration") }.should raise_error(/name=/)
     end
 
-    context 'sub-namespaced task' do
-      before do
-        write_rakefile %{t.sub_namespace = "widgets"}
-      end
-      it "fails if i do not add a name" do
-        run("rake db:widgets:new_migration").should_not =~ /SUCCESS/
-      end
-
-      it "generates a new migration with this name and timestamp" do
-        run("rake db:widgets:new_migration name=test_widget").should =~ %r{Created migration .*spec/tmp/db/migrations/\d+_test_widget\.rb}
-        run("ls db/migrations").should =~ /^\d+_test_widget.rb$/
-      end
-
-      it 'does not create top level db:new_migration task' do
-        run('rake db:new_migration').should =~ /Don't know how to build task 'db:new_migration'/
-      end
+    it "generates a new migration with this name and timestamp" do
+      run("rake db:new_migration name=test_abc").should =~ %r{Created migration db/migrate/\d+_test_abc\.rb}
+      run("ls db/migrate").should =~ /^\d+_test_abc.rb$/
     end
   end
 
@@ -169,192 +116,88 @@ end
     it "should start with a new database version" do
       run("rake db:version").should =~ /Current version: 0/
     end
+
+    it "should display the current version" do
+      run("rake db:new_migration name=test_abc")
+      run("rake --trace db:migrate")
+      run("rake db:version").should =~ /Current version: #{Time.now.year}/
+    end
   end
 
   describe 'db:migrate' do
-    context "single migration path" do
-      it "does nothing when no migrations are present" do
-        run("rake db:migrate").should =~ /SUCCESS/
-      end
+    it "does nothing when no migrations are present" do
+      run("rake db:migrate").should_not =~ /Migrating/
+    end
 
-      it "migrates if i add a migration" do
-        run("rake db:new_migration name=xxx")
-        result = run("rake db:migrate")
-        result.should =~ /SUCCESS/
-        result.should =~ /Migrating to Xxx \(#{Time.now.year}/
-      end
+    it "migrates if i add a migration" do
+      run("rake db:new_migration name=xxx")
+      run("rake db:migrate").should =~ /Xxx: Migrating/i
     end
+  end
 
-    context "multiple migration paths" do
-      before do
-        write_multiple_migrations
-      end
-      it "runs the migrator on each migration path" do
-        result = run("rake db:migrate")
-        result.should =~ /Migrating to CreateTests \(2010/
-        result.should =~ /Migrating to CreateTests2 \(2010/
-      end
+  describe 'db:migrate:down' do
+    it "migrates down" do
+      make_migration('xxx')
+      sleep 1
+      version = make_migration('yyy')
+      run 'rake db:migrate'
+
+      result = run("rake db:migrate:down VERSION=#{version}")
+      result.should_not =~ /DOWN-xxx/
+      result.should =~ /DOWN-yyy/
     end
 
-    context 'sub-namespaced task' do
-      before do
-        write_rakefile %{t.sub_namespace = "widgets"}
-      end
-      it 'runs the migrations' do
-        run("rake db:widgets:new_migration name=new_widget")
-        result = run("rake db:widgets:migrate")
-        result.should =~ /SUCCESS/
-        result.should =~ /Migrating to NewWidget \(#{Time.now.year}/
-      end
+    it "fails without version" do
+      make_migration('yyy')
+      lambda{ run("rake db:migrate:down") }.should raise_error(/VERSION/)
+    end
+  end
 
-      it 'does not create top level db:new_migration task' do
-        run('rake db:migrate').should =~ /Don't know how to build task 'db:migrate'/
-      end
+  describe 'db:migrate:up' do
+    it "migrates up" do
+      make_migration('xxx')
+      run 'rake db:migrate'
+      sleep 1
+      version = make_migration('yyy')
+      result = run("rake db:migrate:up VERSION=#{version}")
+      result.should_not =~ /UP-xxx/
+      result.should =~ /UP-yyy/
+    end
+
+    it "fails without version" do
+      make_migration('yyy')
+      lambda{ run("rake db:migrate:up") }.should raise_error(/VERSION/)
     end
   end
   
   describe 'db:rollback' do
     it "does nothing when no migrations have been run" do
-      run("rake db:rollback").should =~ /SUCCESS/
+      run("rake db:version").should =~ /version: 0/
+      run("rake db:rollback").should == ''
+      run("rake db:version").should =~ /version: 0/      
     end
     
-    it "rolls back the last migration if one has been applied" do
-      write_reversible_migration
-      run("rake db:migrate")
-      
-      result = run("rake db:rollback")
-      result.should =~ /SUCCESS/
-      result.should =~ /reverted/
+    it "rolls back the last migration if one has been applied" do     
+      write_multiple_migrations      
+      run("rake db:migrate")      
+      run("rake db:version").should =~ /version: 20100509095816/
+      run("rake db:rollback").should =~ /revert/
+      run("rake db:version").should =~ /version: 20100509095815/
     end
     
     it "rolls back multiple migrations if the STEP argument is given" do
-      write_multiple_migrations
-      run("rake db:migrate")
-      
-      result = run("rake db:rollback STEP=2")
-      result.should =~ /SUCCESS/
-      result.should =~ /reverted/
-    end
-  end
-
-  describe 'db:migrate:down' do
-    context "single migration path" do
-      it "migrates down" do
-        make_migration('xxx')
-        sleep 1
-        version = make_migration('yyy')
-        run 'rake db:migrate'
-
-        result = run("rake db:migrate:down VERSION=#{version}")
-        result.should =~ /SUCCESS/
-        result.should_not =~ /DOWN-xxx/
-        result.should =~ /DOWN-yyy/
-      end
-
-      it "fails without version" do
-        make_migration('yyy')
-        result = run("rake db:migrate:down")
-        result.should_not =~ /SUCCESS/
-      end
+      write_multiple_migrations      
+      run("rake db:migrate")      
+      run("rake db:version").should =~ /version: 20100509095816/
+      run("rake db:rollback STEP=2") =~ /revert/
+      run("rake db:version").should =~ /version: 0/
     end
-
-    context "multiple migration paths" do
-      before do
-        write_multiple_migrations
-      end
-
-      it "runs down on the correct path" do
-        run 'rake db:migrate'
-        result = run 'rake db:migrate:down VERSION=20100509095815'
-        result.should =~ /DOWN-CreateTests/
-        result.should_not =~ /DOWN-CreateTests2/
-      end
-
-      it "fails if migration number isn't found" do
-        run 'rake db:migrate'
-        result = run 'rake db:migrate:down VERSION=20100509095820'
-        result.should_not =~ /SUCCESS/
-        result.should =~ /wasn't found on path/
-      end
-    end
-
-    context 'sub-namespaced task' do
-      before do
-        write_rakefile %{t.sub_namespace = "widgets"}
-      end
-      it 'migrates down' do
-        make_sub_namespaced_migration('widgets', 'widget_xxx')
-        sleep 1
-        version = make_sub_namespaced_migration('widgets', 'widget_yyy')
-        run 'rake db:widgets:migrate'
-
-        result = run("rake db:widgets:migrate:down VERSION=#{version}")
-        result.should =~ /SUCCESS/
-        result.should_not =~ /DOWN-widget_xxx/
-        result.should =~ /DOWN-widget_yyy/
-      end
-    end
-  end
-
-  describe 'db:migrate:up' do
-    context "single migration path" do
-      it "migrates up" do
-        make_migration('xxx')
-        run 'rake db:migrate'
-        sleep 1
-        version = make_migration('yyy')
-        result = run("rake db:migrate:up VERSION=#{version}")
-        result.should =~ /SUCCESS/
-        result.should_not =~ /UP-xxx/
-        result.should =~ /UP-yyy/
-      end
-
-      it "fails without version" do
-        make_migration('yyy')
-        result = run("rake db:migrate:up")
-        result.should_not =~ /SUCCESS/
-      end
-    end
-
-    context "multiple migration paths" do
-      before do
-        write_multiple_migrations
-      end
-
-      it "runs down on the correct path" do
-        result = run 'rake db:migrate:up VERSION=20100509095815'
-        result.should =~ /UP-CreateTests/
-        result.should_not =~ /UP-CreateTests2/
-      end
-
-      it "fails if migration number isn't found" do
-        result = run 'rake db:migrate:up VERSION=20100509095820'
-        result.should_not =~ /SUCCESS/
-        result.should =~ /wasn't found on path/
-      end
-    end
-
-    context 'sub-namespaced task' do
-      before do
-        write_rakefile %{t.sub_namespace = "widgets"}
-      end
-      it 'migrates up' do
-        make_sub_namespaced_migration('widgets', 'widget_xxx')
-        run 'rake db:widgets:migrate'
-        sleep 1
-        version = make_sub_namespaced_migration('widgets', 'widget_yyy')
-        result = run("rake db:widgets:migrate:up VERSION=#{version}")
-        result.should =~ /SUCCESS/
-        result.should_not =~ /UP-widget_xxx/
-        result.should =~ /UP-widget_yyy/
-      end
-    end
-  end
+  end  
 
   describe 'schema:dump' do
     it "dumps the schema" do
-      result = run('rake db:schema:dump')
-      result.should =~ /SUCCESS/
+      write('db/schema.rb', '')
+      run('rake db:schema:dump')
       read('db/schema.rb').should =~ /ActiveRecord/
     end
   end
@@ -365,38 +208,57 @@ end
       schema = "db/schema.rb"
       write(schema, read(schema)+"\nputs 'LOADEDDD'")
       result = run('rake db:schema:load')
-      result.should =~ /SUCCESS/
       result.should =~ /LOADEDDD/
     end
+
+    it "loads all migrations" do
+      make_migration('yyy')
+      run "rake db:migrate"
+      run "rake db:drop"
+      run "rake db:create"
+      run "rake db:schema:load"
+      run( "rake db:migrate").strip.should == ''
+    end
   end
 
   describe 'db:abort_if_pending_migrations' do
     it "passes when no migrations are pending" do
-      run("rake db:abort_if_pending_migrations").should_not =~ /try again/
+      run("rake db:abort_if_pending_migrations").strip.should == ''
     end
 
     it "fails when migrations are pending" do
       make_migration('yyy')
-      result = run("rake db:abort_if_pending_migrations")
-      result.should =~ /try again/
-      result.should =~ /1 pending migration/
+      lambda{ run("rake db:abort_if_pending_migrations") }.should raise_error(/1 pending migration/)
     end
   end
 
   describe 'db:test:load' do
     it 'loads' do
       write("db/schema.rb", "puts 'LOADEDDD'")
-      run("rake db:test:load").should =~ /LOADEDDD.*SUCCESS/m
+      run("rake db:test:load").should =~ /LOADEDDD/
     end
 
     it "fails without schema" do
-      run("rake db:test:load").should =~ /no such file to load/
+      lambda{ run("rake db:test:load") }.should raise_error(/try again/)
     end
   end
 
   describe 'db:test:purge' do
     it "runs" do
-      run('rake db:test:purge').should =~ /SUCCESS/
+      run('rake db:test:purge')
     end
   end
+  
+  describe 'db:migrate when environment is specified' do
+    it "runs when using the DB environment variable" do
+      make_migration('yyy')
+      run('rake db:migrate DB=test')
+      run('rake db:version DB=test').should_not =~ /version: 0/
+      run('rake db:version').should =~ /version: 0/
+    end
+    
+    it "should error on an invalid database" do
+      lambda{ run("rake db:create DB=nonexistent")}.should raise_error(/rake aborted/)
+    end    
+  end
 end

data/standalone_migrations.gemspec

@@ -5,16 +5,19 @@
 
 Gem::Specification.new do |s|
   s.name = %q{standalone_migrations}
-  s.version = "0.4.11"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Todd Huss", "Michael Grosser"]
-  s.date = %q{2011-07-07}
+  s.date = %q{2011-07-10}
   s.email = %q{thuss@gabrito.com}
   s.extra_rdoc_files = [
     "README.markdown"
   ]
   s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
     "README.markdown",
     "Rakefile",
     "VERSION",
@@ -37,14 +40,14 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rake>, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3"])
     else
       s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 3"])
     end
   else
     s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 3"])
   end
 end
 

metadata

@@ -3,10 +3,10 @@ name: standalone_migrations
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 4
-  - 11
-  version: 0.4.11
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Todd Huss
@@ -15,12 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-07 00:00:00 -07:00
+date: 2011-07-10 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -30,19 +29,20 @@ dependencies:
         - 0
         version: "0"
   type: :runtime
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: activerecord
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 0
-        version: "0"
+        - 3
+        version: "3"
   type: :runtime
+  prerelease: false
   version_requirements: *id002
 description: 
 email: thuss@gabrito.com
@@ -53,6 +53,9 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
 - README.markdown
 - Rakefile
 - VERSION