mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-migrations-0.9.7/lib/migration.rb

@@ -0,0 +1,215 @@
+require 'rubygems'
+gem 'dm-core', '~>0.9.7'
+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
+      result = nil
+      if needs_up?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+          say_with_time "== Performing Up Migration ##{position}: #{name}", 0 do
+            result = @up_action.call
+          end
+          update_migration_info(:up)
+        # end
+      end
+      result
+    end
+
+    # un-do the migration by running the code in the #down block
+    def perform_down
+      result = nil
+      if needs_down?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+          say_with_time "== Performing Down Migration ##{position}: #{name}", 0 do
+            result = @down_action.call
+          end
+          update_migration_info(:down)
+        # end
+      end
+      result
+    end
+
+    # execute raw SQL
+    def execute(sql, *bind_values)
+      say_with_time(sql) do
+        @adapter.execute(sql, *bind_values)
+      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
+
+    def create_index(table_name, *columns_and_options)
+      if columns_and_options.last.is_a?(Hash)
+        opts = columns_and_options.pop
+      else
+        opts = {}
+      end
+      columns = columns_and_options.flatten
+
+      opts[:name] ||= "#{opts[:unique] ? 'unique_' : ''}index_#{table_name}_#{columns.join('_')}"
+
+      execute <<-SQL.compress_lines
+        CREATE #{opts[:unique] ? 'UNIQUE ' : '' }INDEX #{quote_column_name(opts[:name])} ON
+        #{quote_table_name(table_name)} (#{columns.map { |c| quote_column_name(c) }.join(', ') })
+      SQL
+    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
+
+    # 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, 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?
+      return true unless migration_info_table_exists?
+      migration_record.empty?
+    end
+
+    # True if the migration has already been run
+    def needs_down?
+      return false unless migration_info_table_exists?
+      ! 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
+
+    def quote_table_name(table_name)
+      @adapter.send(:quote_table_name, table_name.to_s)
+    end
+
+    def quote_column_name(column_name)
+      @adapter.send(:quote_column_name, column_name.to_s)
+    end
+  end
+end

data/lib/gems/dm-migrations-0.9.7/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/gems/dm-migrations-0.9.7/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

data/lib/gems/dm-migrations-0.9.7/lib/spec/matchers/migration_matchers.rb

@@ -0,0 +1,107 @@
+
+module Spec
+  module Matchers
+    module Migration
+
+      def have_table(table_name)
+        HaveTableMatcher.new(table_name)
+      end
+
+      def have_column(column_name)
+        HaveColumnMatcher.new(column_name)
+      end
+
+      def permit_null
+        NullableColumnMatcher.new
+      end
+
+      def be_primary_key
+        PrimaryKeyMatcher.new
+      end
+
+      class HaveTableMatcher
+
+        attr_accessor :table_name, :repository
+
+        def initialize(table_name)
+          @table_name = table_name
+        end
+
+        def matches?(repository)
+          repository.adapter.storage_exists?(table_name)
+        end
+
+        def failure_message
+          %(expected #{repository} to have table '#{table_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{repository} to not have table '#{table_name}')
+        end
+
+      end
+
+      class HaveColumnMatcher
+
+        attr_accessor :table, :column_name
+
+        def initialize(column_name)
+          @column_name = column_name
+        end
+
+        def matches?(table)
+          @table = table
+          table.columns.map { |c| c.name }.include?(column_name.to_s)
+        end
+
+        def failure_message
+          %(expected #{table} to have column '#{column_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{table} to not have column '#{column_name}')
+        end
+
+      end
+
+      class NullableColumnMatcher
+
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          ! column.not_null
+        end
+
+        def failure_message
+          %(expected #{column.name} to permit NULL)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to be NOT NULL)
+        end
+
+      end
+
+      class PrimaryKeyMatcher
+
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          column.primary_key
+        end
+
+        def failure_message
+          %(expected #{column.name} to be PRIMARY KEY)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to not be PRIMARY KEY)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/column.rb

@@ -0,0 +1,9 @@
+module SQL
+
+  class Column
+
+    attr_accessor :name, :type, :not_null, :default_value, :primary_key, :unique
+
+  end
+
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/mysql.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/table'
+
+module SQL
+  module Mysql
+
+    def supports_schema_transactions?
+      false
+    end
+
+    def table(table_name)
+      SQL::Mysql::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute "DROP DATABASE #{db_name}"
+      execute "CREATE DATABASE #{db_name}"
+      execute "USE #{db_name}"
+    end
+
+    def supports_serial?
+      true
+    end
+
+    # TODO: move to dm-more/dm-migrations
+    def property_schema_statement(schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} serial PRIMARY KEY"
+      else
+        super
+      end
+    end
+
+    class Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Mysql::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+
+
+  end
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/postgresql.rb

@@ -0,0 +1,78 @@
+module SQL
+  module Postgresql
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Postgresql::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute "DROP SCHEMA IF EXISTS test CASCADE"
+      execute "CREATE SCHEMA test"
+      execute "SET search_path TO test"
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def property_schema_statement(schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} serial PRIMARY KEY"
+      else
+        statement = super
+        if schema.has_key?(:sequence_name)
+          statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
+        end
+        statement
+      end
+      statement
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @adapter, @name = adapter, table_name
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Postgresql::Column.new(col_struct)
+        end
+
+        query_column_constraints
+      end
+
+      def query_column_constraints
+        @adapter.query(
+          "SELECT * FROM information_schema.table_constraints WHERE table_name='#{@name}' AND table_schema=current_schema()"
+        ).each do |table_constraint|
+          @adapter.query(
+            "SELECT * FROM information_schema.constraint_column_usage WHERE constraint_name='#{table_constraint.constraint_name}' AND table_schema=current_schema()"
+          ).each do |constrained_column|
+            @columns.each do |column|
+              if column.name == constrained_column.column_name
+                case table_constraint.constraint_type
+                when "UNIQUE"       then column.unique = true
+                when "PRIMARY KEY"  then column.primary_key = true
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value = col_struct.column_name, col_struct.data_type, col_struct.column_default
+
+        @not_null = col_struct.is_nullable != "YES"
+      end
+
+    end
+
+  end
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/sqlite3.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/table'
+
+module SQL
+  module Sqlite3
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Sqlite3::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      DataMapper.logger.info "Dropping #{@uri.path}"
+      system "rm #{@uri.path}"
+      # do nothing, sqlite will automatically create the database file
+    end
+
+    def supports_serial?
+      true
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Sqlite3::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+
+
+  end
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/table.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/column'
+
+module SQL
+
+  class Table
+
+    attr_accessor :name, :columns
+
+    def to_s
+      name
+    end
+
+    def column(column_name)
+      @columns.select { |c| c.name == column_name.to_s }.first
+    end
+
+  end
+
+end