dm-migrations 0.9.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Paul Sadauskas
+
+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

@@ -0,0 +1,4 @@
+dm-migrations
+=============
+
+DataMapper plugin for writing and specing migrations.

data/Rakefile

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'spec'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'pathname'
+
+CLEAN.include '{log,pkg}/'
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'dm-migrations'
+  s.version          = '0.9.2'
+  s.platform         = Gem::Platform::RUBY
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README LICENSE TODO ]
+  s.summary          = 'DataMapper plugin for writing and specing migrations'
+  s.description      = s.summary
+  s.author           = 'Paul Sadauskas'
+  s.email            = 'psadauskas@gmail.com'
+  s.homepage         = 'http://github.com/sam/dm-more/tree/master/dm-migrations'
+  s.require_path     = 'lib'
+  s.files            = FileList[ '{lib,spec}/**/*.rb', 'spec/spec.opts', 'Rakefile', *s.extra_rdoc_files ]
+  s.add_dependency('dm-core', "=#{s.version}")
+end
+
+task :default => [ :spec ]
+
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install #{spec.name} #{spec.version} (default ruby)"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources", :verbose => false
+end
+
+desc "Uninstall #{spec.name} #{spec.version} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{spec.name} -v#{spec.version} -I -x", :verbose => false
+end
+
+namespace :jruby do
+  desc "Install #{spec.name} #{spec.version} with JRuby"
+  task :install => [ :package ] do
+    sh %{#{SUDO} jruby -S gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources}, :verbose => false
+  end
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end
+
+namespace :db do
+
+  # pass the relative path to the migrations directory by MIGRATION_DIR
+  task :setup_migration_dir do
+    unless defined?(MIGRATION_DIR)
+      migration_dir = ENV["MIGRATION_DIR"] || File.join("db", "migrations")
+      MIGRATION_DIR = File.expand_path(File.join(File.dirname(__FILE__), migration_dir))
+    end
+    FileUtils.mkdir_p MIGRATION_DIR
+  end
+
+  # set DIRECTION to migrate down
+  desc "Run your system's migrations"
+  task :migrate => [:setup_migration_dir] do
+    require File.expand_path(File.join(File.dirname(__FILE__), "lib", "migration_runner.rb"))
+    require File.expand_path(File.join(MIGRATION_DIR, "config.rb"))
+
+    Dir[File.join(MIGRATION_DIR, "*.rb")].each { |file| require file }
+
+    ENV["DIRECTION"] != "down" ? migrate_up! : migrate_down!
+  end
+end

data/TODO

@@ -0,0 +1,8 @@
+TODO
+====
+
+
+
+---
+TODO tickets may also be found in the DataMapper Issue Tracker:
+http://wm.lighthouseapp.com/projects/4819-datamapper/overview

data/lib/dm-migrations.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/migration'

data/lib/migration.rb

@@ -0,0 +1,192 @@
+require 'rubygems'
+gem 'dm-core', '=0.9.2'
+require 'dm-core'
+require 'benchmark'
+require File.dirname(__FILE__) + '/sql'
+
+module DataMapper
+  class DuplicateMigrationNameError < StandardError
+    def initialize(migration)
+      super("Duplicate Migration Name: '#{migration.name}', version: #{migration.position}")
+    end
+  end
+
+  class Migration
+    include SQL
+
+    attr_accessor :position, :name, :database, :adapter
+
+    def initialize( position, name, opts = {}, &block )
+      @position, @name = position, name
+      @options = opts
+
+      @database = DataMapper.repository(@options[:database] || :default)
+      @adapter = @database.adapter
+
+      case @adapter.class.to_s
+      when /Sqlite3/  then @adapter.extend(SQL::Sqlite3)
+      when /Mysql/    then @adapter.extend(SQL::Mysql)
+      when /Postgres/ then @adapter.extend(SQL::Postgresql)
+      else
+        raise "Unsupported Migration Adapter #{@adapter.class}"
+      end
+
+      @verbose = @options.has_key?(:verbose) ? @options[:verbose] : true
+
+      @up_action   = lambda {}
+      @down_action = lambda {}
+
+      instance_eval &block
+    end
+
+    # define the actions that should be performed on an up migration
+    def up(&block)
+      @up_action = block
+    end
+
+    # define the actions that should be performed on a down migration
+    def down(&block)
+      @down_action = block
+    end
+
+    # perform the migration by running the code in the #up block
+    def perform_up
+      res = nil
+      if needs_up?
+        # DataMapper.database.adapter.transaction do
+        say_with_time "== Performing Up Migration ##{position}: #{name}", 0 do
+          res = @up_action.call
+        end
+        update_migration_info(:up)
+        # end
+      end
+      res
+    end
+
+    # un-do the migration by running the code in the #down block
+    def perform_down
+      res = nil
+      if needs_down?
+        # DataMapper.database.adapter.transaction do
+        say_with_time "== Performing Down Migration ##{position}: #{name}", 0 do
+          res = @down_action.call
+        end
+        update_migration_info(:down)
+        # end
+      end
+      res
+    end
+
+    # execute raw SQL
+    def execute(sql)
+      say_with_time(sql) do
+        @adapter.execute(sql)
+      end
+    end
+
+    def create_table(table_name, opts = {}, &block)
+      execute TableCreator.new(@adapter, table_name, opts, &block).to_sql
+    end
+
+    def drop_table(table_name, opts = {})
+      execute "DROP TABLE #{@adapter.send(:quote_table_name, table_name.to_s)}"
+    end
+
+    def modify_table(table_name, opts = {}, &block)
+      TableModifier.new(@adapter, table_name, opts, &block).statements.each do |sql|
+        execute(sql)
+      end
+    end
+
+    # Orders migrations by position, so we know what order to run them in.
+    # First order by postition, then by name, so at least the order is predictable.
+    def <=> other
+      if self.position == other.position
+        self.name.to_s <=> other.name.to_s
+      else
+        self.position <=> other.position
+      end
+    end
+
+    # Output some text. Optional indent level
+    def say(message, indent = 4)
+      write "#{" " * indent} #{message}"
+    end
+
+    # Time how long the block takes to run, and output it with the message.
+    def say_with_time(message, indent = 2)
+      say(message, indent)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say("-> %.4fs" % time.real, indent)
+      result
+    end
+
+    # output the given text, but only if verbose mode is on
+    def write(text="")
+      puts text if @verbose
+    end
+
+    protected
+
+    # Inserts or removes a row into the `migration_info` table, so we can mark this migration as run, or un-done
+    def update_migration_info(direction)
+      save, @verbose = @verbose, false
+
+      create_migration_info_table_if_needed
+
+      if direction.to_sym == :up
+        execute("INSERT INTO #{migration_info_table} (#{migration_name_column}) VALUES (#{quoted_name})")
+      elsif direction.to_sym == :down
+        execute("DELETE FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+      end
+      @verbose = save
+    end
+
+    def create_migration_info_table_if_needed
+      save, @verbose = @verbose, true # false
+      unless migration_info_table_exists?
+        execute("CREATE TABLE #{migration_info_table} (#{migration_name_column} VARCHAR(255) UNIQUE)")
+      end
+      @verbose = save
+    end
+
+    # Quote the name of the migration for use in SQL
+    def quoted_name
+      "'#{name}'"
+    end
+
+    def migration_info_table_exists?
+      adapter.storage_exists?('migration_info')
+    end
+
+    # Fetch the record for this migration out of the migration_info table
+    def migration_record
+      return [] unless migration_info_table_exists?
+      @adapter.query("SELECT #{migration_name_column} FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+    end
+
+    # True if the migration needs to be run
+    def needs_up?
+      create_migration_info_table_if_needed
+      migration_record.empty?
+    end
+
+    # True if the migration has already been run
+    def needs_down?
+      create_migration_info_table_if_needed
+      ! migration_record.empty?
+    end
+
+    # Quoted table name, for the adapter
+    def migration_info_table
+      @migration_info_table ||= @adapter.send(:quote_table_name, 'migration_info')
+    end
+
+    # Quoted `migration_name` column, for the adapter
+    def migration_name_column
+      @migration_name_column ||= @adapter.send(:quote_column_name, 'migration_name')
+    end
+
+  end
+end

data/lib/migration_runner.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/migration'
+
+module DataMapper
+  module MigrationRunner
+    @@migrations ||= []
+
+    # Creates a new migration, and adds it to the list of migrations to be run.
+    # Migrations can be defined in any order, they will be sorted and run in the
+    # correct order.
+    #
+    # The order that migrations are run in is set by the first argument. It is not
+    # neccessary that this be unique; migrations with the same version number are
+    # expected to be able to be run in any order.
+    #
+    # The second argument is the name of the migration. This name is used internally
+    # to track if the migration has been run. It is required that this name be unique
+    # across all migrations.
+    #
+    # Addtionally, it accepts a number of options:
+    # * <tt>:database</tt> If you defined several DataMapper::database instances use this
+    #   to choose which one to run the migration gagainst. Defaults to <tt>:default</tt>.
+    #   Migrations are tracked individually per database.
+    # * <tt>:verbose</tt> true/false, defaults to true. Determines if the migration should
+    #   output its status messages when it runs.
+    #
+    # Example of a simple migration:
+    #
+    #   migration( 1, :create_people_table ) do
+    #     up do
+    #       create_table :people do
+    #         column :id,     Integer, :serial => true
+    #         column :name,   String, :size => 50
+    #         column :age,    Integer
+    #       end
+    #     end
+    #     down do
+    #       drop_table :people
+    #     end
+    #   end
+    #
+    # Its recommended that you stick with raw SQL for migrations that manipulate data. If
+    # you write a migration using a model, then later change the model, there's a
+    # possibility the migration will no longer work. Using SQL will always work.
+    def migration( number, name, opts = {}, &block )
+      @@migrations ||= []
+      raise "Migration name conflict: '#{name}'" if @@migrations.map { |m| m.name }.include?(name.to_s)
+
+      @@migrations << DataMapper::Migration.new( number, name.to_s, opts, &block )
+    end
+
+    # Run all migrations that need to be run. In most cases, this would be called by a
+    # rake task as part of a larger project, but this provides the ability to run them
+    # in a script or test.
+    #
+    # has an optional argument 'level' which if supplied, only performs the migrations
+    # with a position less than or equal to the level.
+    def migrate_up!(level = nil)
+      @@migrations.sort.each do |migration|
+        if level.nil?
+          migration.perform_up()
+        else
+          migration.perform_up() if migration.position <= level.to_i
+        end
+      end
+    end
+
+    # Run all the down steps for the migrations that have already been run.
+    #
+    # has an optional argument 'level' which, if supplied, only performs the
+    # down migrations with a postion greater than the level.
+    def migrate_down!(level = nil)
+      @@migrations.sort.reverse.each do |migration|
+        if level.nil?
+          migration.perform_down()
+        else
+          migration.perform_down() if migration.position > level.to_i
+        end
+      end
+    end
+
+    def migrations
+      @@migrations
+    end
+
+  end
+end
+
+include DataMapper::MigrationRunner

data/lib/spec/example/migration_example_group.rb

@@ -0,0 +1,73 @@
+require 'spec'
+
+require File.dirname(__FILE__) + '/../matchers/migration_matchers'
+
+module Spec
+  module Example
+    class MigrationExampleGroup < Spec::Example::ExampleGroup
+      include Spec::Matchers::Migration
+
+      before(:all) do
+        if this_migration.adapter.supports_schema_transactions?
+          run_prereq_migrations
+        end
+      end
+
+      before(:each) do
+        if ! this_migration.adapter.supports_schema_transactions?
+          run_prereq_migrations
+        else
+          this_migration.adapter.begin_transaction
+        end
+      end
+
+      after(:each) do
+        if this_migration.adapter.supports_schema_transactions?
+          this_migration.adapter.rollback_transaction
+        end
+      end
+
+      after(:all) do
+        this_migration.adapter.recreate_database
+      end
+
+      def run_prereq_migrations
+        "running n-1 migrations"
+        all_databases.each do |db|
+          db.adapter.recreate_database
+        end
+        @@migrations.sort.each do |migration|
+          break if migration.name.to_s == migration_name.to_s
+          migration.perform_up
+        end
+      end
+
+      def run_migration
+        this_migration.perform_up
+      end
+
+      def migration_name
+        @migration_name ||= self.class.instance_variable_get("@description_text").to_s
+      end
+
+      def all_databases
+        @@migrations.map { |m| m.database }.uniq
+      end
+
+      def this_migration
+        @@migrations.select { |m| m.name.to_s == migration_name }.first
+      end
+
+      def query(sql)
+        this_migration.adapter.query(sql)
+      end
+
+      def table(table_name)
+        this_migration.adapter.table(table_name)
+      end
+
+      Spec::Example::ExampleGroupFactory.register(:migration, self)
+
+    end
+  end
+end