usesguid_migrations 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+.* # Ignore all dotfiles...
+!.gitignore # except for .gitignore
+*.svn
+pkg/*

data/History.txt

@@ -0,0 +1,3 @@
+= 1.0.0 2009-11-113
+
+* Ported from a plugin to Gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 C. Jason Harrelson (midas)
+
+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.rdoc

@@ -0,0 +1,130 @@
+= usesguid_migrations
+
+http://github.com/midas/usesguid_migrations/tree/master
+
+
+== DESCRIPTION
+
+To be used with http://github.com/BMorearty/usesguid/tree/master.  It can be a pain to explicitly declare the correct
+column types, etc. for your usesguid migrations.  For instance:
+
+  create_table :users, :id => false, :force => true do |t|
+    t.binary :id, :limit => 22, :null => false
+    ...
+    t.binary :account_id, :limit => 22, :null => false
+  end
+
+  execute "ALTER TABLE `users` MODIFY COLUMN `id` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;"
+  execute "ALTER TABLE `users` ADD PRIMARY KEY (id)"
+  execute "ALTER TABLE `users` MODIFY COLUMN `account_id` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;"
+
+In addition, this technique will fail to keep you schema.rb file correctly up to date.  The binary varchar(22) fields will actually be
+output as:
+
+  t.string   "id",         :limit => 22, :null => false
+  t.string   "account_id", :limit => 22
+
+This will include no:
+
+  execute "ALTER TABLE `users` MODIFY COLUMN `id` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;"
+  execute "ALTER TABLE `users` ADD PRIMARY KEY (id)"
+  execute "ALTER TABLE `users` MODIFY COLUMN `account_id` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;"
+
+So you will end up getting unique id collisions due to the non-case sensitivity of the string field in MySQL without a latin1_bin
+collation.
+
+Enter usesguid_migrations.  This plugin will automatically create an id field (just as migrations currently do), but it will be of the
+type necessary for usesguid to work correctly.
+
+
+== FEATURES
+
+* Automatically generate an id field with correct typing for usesguid
+* Migration associated method for generating foreign keys with correct typing for usesguid
+* Schema dumper will create schema.rb files with the correct typing for usesguid
+
+
+== TO DO
+
+* Add ability for the add_column and change_column methods to accept an option turning them into guids
+* Tests, tests and more tests (if anyone has any ideas of how to accomplish this please let me know, I am currently at a loss of how to test something like this)
+
+
+== REQUIREMENTS
+
+* Rails 2.0 or above
+* usesguid Gem (http://github.com/midas/usesguid)
+
+
+== USAGE
+
+Simply create a normal create table migration and an id field with correct typing for usesguid will be generated.
+
+In addition, if you would like to declare a foreign key field that needs to be of the
+correct type to use usesguid, just use the associated method:
+
+  create_table :whatevers, :force => true do |t|
+    t.references_with_guid :account
+  end
+
+This will create a field named account_id that is of the correct type for usesguid.  It will also assume that the column
+is not nullable as it is more than likely a foreign key.  to Make it nullable you must use th e:null => true option:
+
+  t.references_with_guid :account
+
+or
+
+  t.references_with_guid :account, :null => true
+
+If you need a table with a standard Rails id field just use the :guid option of the crate_table method.
+
+  create_table :users, :guid => false do |t|
+    ...
+    t.references_with_guid :account # will still use a guid regardless of the :guid => false option in the create_table params above
+  end
+
+If you need a table with no id at all, just use the normal :primary_key option of the create_table method and
+you will have no id field automatically generated.
+
+  create_table :users, :primary_key => false do |t|
+    ...
+  end
+
+If you run into any issues with running tests or specs, it could be something strange happening in your schema.rb file.  This
+file is used to prepare the database for testing.  To override this and make migrations be used to prepare the database, copy 
+and rename the testdb.rake.txt file to {project root}/lib/tasks/testdb.rake.
+
+
+== INSTALL
+
+From the command line:
+
+  sudo gem install usesguid_migrations
+
+In Rails environment.rb:
+
+  config.gem "usesguid_migrations"
+
+
+== LICENSE
+
+Copyright (c) 2009 C. Jason Harrelson (midas)
+
+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/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "usesguid_migrations"
+    gem.summary = %Q{Makes your migrations work with usesguid plugin without explicitly defining the keys migrations.}
+    gem.description = %Q{Makes your migrations work with usesguid plugin without explicitly defining the primary key id or foreign keys in migrations.}
+    gem.email = "jason@lookforwardenterprises.com"
+    gem.homepage = "http://github.com/midas/usesguid_migrations"
+    gem.authors = ["Jason Harrelson"]
+    gem.add_development_dependency "rspec"
+    gem.add_dependency "activerecord", ">= 2.3"
+    gem.add_dependency "usesguid"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "usesguid_migrations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/usesguid_migrations/active_record_extensions/base.rb

@@ -0,0 +1,31 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module Base
+    
+      def self.included( base )
+        base.extend( ClassMethods )
+      end
+
+      module ClassMethods
+        def self.extended( base )
+          class << base
+            alias_method_chain :abstract_class?, :lfe_usesguid_migrations
+          end
+        end
+      
+        def abstract_class_with_lfe_usesguid_migrations?
+           abstract_class_without_lfe_usesguid_migrations? || !(name =~ /^Abstract/).nil?
+         end
+      
+        def base_class?
+          self == base_class
+        end
+      
+        def pluralized_table_name( table_name )
+          ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
+        end
+      end
+    
+    end
+  end
+end

data/lib/usesguid_migrations/active_record_extensions/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,46 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module ConnectionAdapters
+      module MysqlAdapter
+
+        def primary_key_name( table_name, name=nil )
+          results = execute( "SHOW CREATE TABLE `#{table_name}`", name )
+          keys = []
+          primary_key = nil
+
+          results.each do |row|
+            row[1].each do |line|
+              keys << $1 if line =~ /^  [`"](.+?)[`"] varchar\(22\) character set latin1 collate latin1_bin NOT NULL?,?$/
+              primary_key = $1 if line =~ /^  PRIMARY KEY  \([`"](.+?)[`"]\)$/
+              primary_key = $1 if line =~ /^  PRIMARY KEY  \([`"](.+?)[`"]\),$/
+              primary_key = $1 if line =~ /^  PRIMARY KEY  \([`"](.+?)[`"]\), $/
+            end
+          end
+
+          return keys.include?( primary_key ) ? primary_key : nil
+        end
+
+        def foreign_keys( table_name, name=nil )
+          results = execute( "SHOW CREATE TABLE `#{table_name}`", name )
+
+          null_foreign_keys = []
+          not_null_foreign_keys = []
+          primary_keys = []
+
+          results.each do |row|
+            row[1].each do |line|
+              null_foreign_keys << $1 if line =~ /^  [`"](.+?)[`"] varchar\(22\) character set latin1 collate latin1_bin default NULL?,?$/
+              not_null_foreign_keys << $1 if line =~ /^  [`"](.+?)[`"] varchar\(22\) character set latin1 collate latin1_bin NOT NULL?,?$/
+              primary_keys << $1 if line =~ /^  PRIMARY KEY  \([`"](.+?)[`"]\)$/
+              primary_keys << $1 if line =~ /^  PRIMARY KEY  \([`"](.+?)[`"]\),$/
+            end
+          end
+
+
+          return null_foreign_keys - primary_keys, not_null_foreign_keys - primary_keys
+        end
+      
+      end
+    end
+  end
+end

data/lib/usesguid_migrations/active_record_extensions/connection_adapters/schema_statements.rb

@@ -0,0 +1,60 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module ConnectionAdapters
+      module SchemaStatements
+      
+        def self.included( base )
+          base.module_eval do
+            alias_method_chain :create_table, :lfe_usesguid_migrations
+          end
+        end
+
+        def create_table_with_lfe_usesguid_migrations( table_name, options={} )
+          table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new( self )
+          #table_definition = TableDefinition.new( self )
+
+          if options[:guid] == false
+            table_definition.primary_key( options[:primary_key] || ActiveRecord::Base.get_primary_key( table_name ) ) unless options[:id] == false
+          else
+            table_definition.guid_primary_key( options[:primary_key] || ActiveRecord::Base.get_primary_key( table_name ) ) unless options[:id] == false
+          end
+
+          yield table_definition
+
+          if options[:force] && table_exists?( table_name )
+            drop_table( table_name, options )
+          end
+
+          create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+          create_sql << "#{quote_table_name( table_name )} ("
+          create_sql << table_definition.to_sql
+          create_sql << ") #{options[:options]}"
+          execute create_sql
+
+          # TODO this needs to be different for each adapter
+          unless table_name == "schema_migrations"
+            unless options[:id] == false || options[:guid] == false
+              execute "ALTER TABLE `#{table_name}` MODIFY COLUMN `#{table_definition.primary_key_name}` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;"
+              execute "ALTER TABLE `#{table_name}` ADD PRIMARY KEY (#{table_definition.primary_key_name})"
+            end
+
+            return if table_definition.associative_keys.nil?
+
+            table_definition.associative_keys.each do |assoc|
+              key = assoc.name
+              opts = assoc.options
+              sql = "ALTER TABLE `#{table_name}` MODIFY COLUMN `#{key}` VARCHAR(#{opts[:limit] || 22}) BINARY CHARACTER SET latin1 COLLATE latin1_bin"
+              if opts[:null] == false || opts[:null].nil?
+                sql << " NOT NULL;"
+              else
+                sql << ";"
+              end
+              execute( sql )
+            end
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/usesguid_migrations/active_record_extensions/connection_adapters/table_definition.rb

@@ -0,0 +1,38 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module ConnectionAdapters
+      module TableDefinition
+      
+        def self.included( base )
+          base.class_eval do
+            include InstanceMethods
+            attr_accessor :primary_key_name
+            attr_accessor :associative_keys
+          end
+        end
+
+        module InstanceMethods
+          def guid_primary_key( name )
+            @primary_key_name = name
+            column( name, :binary, :limit => 22, :null => false )
+          end
+
+          def references_with_guid( name, options={} )
+            name = name.to_s
+            name = "#{name}_id" unless name.end_with?( "_id" )
+            guid( name, options )
+          end
+
+          def guid( name, options={} )
+            @associative_keys = [] if @associative_keys.nil?
+            options.merge!( :limit => 22 )
+            options.merge!( :null => false ) unless options[:null] == true # make not nullable the default for a guid column as it is likely a foreign key
+            @associative_keys << OpenStruct.new( :name => name, :options => options )
+            column( name, :binary, options )
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/usesguid_migrations/active_record_extensions/schema.rb

@@ -0,0 +1,29 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module Schema
+  
+      def self.included( base )
+        base.extend( ClassMethods )
+      end
+
+      module ClassMethods
+        def self.extended( base )
+          class << base
+            attr_accessor :defining
+            alias :defining? :defining
+
+            alias_method_chain :define, :lfe_usesguid_migrations
+          end
+        end
+
+        def define_with_lfe_usesguid_migrations( info={}, &block )
+          self.defining = true
+          define_without_lfe_usesguid_migrations( info, &block )
+        ensure
+          self.defining = false
+        end
+      end
+  
+    end
+  end
+end

data/lib/usesguid_migrations/active_record_extensions/schema_dumper.rb

@@ -0,0 +1,138 @@
+module UsesguidMigrations
+  module ActiveRecordExtensions
+    module SchemaDumper
+      
+      def self.included( base )
+        base.class_eval do
+          private
+          alias_method_chain :table, :lfe_usesguid_migrations
+          alias_method_chain :indexes, :lfe_usesguid_migrations
+        end
+      end
+
+      private
+
+      def table_with_lfe_usesguid_migrations( table, stream )
+        #table_without_lfe_usesguid_migrations( table, stream )
+        columns = @connection.columns( table )
+        begin
+          tbl = StringIO.new
+
+          guid_pk = @connection.primary_key_name( table )
+          guid_fks = @connection.foreign_keys( table )
+
+          if @connection.respond_to?( :pk_and_sequence_for )
+            pk, pk_seq = @connection.pk_and_sequence_for( table )
+          end
+          pk ||= 'id'
+
+          tbl.print "  create_table #{table.inspect}"
+          if col = columns.detect { |c| c.name == pk }
+            tbl.print %Q(, :primary_key => "#{pk}") if pk != 'id'
+            if col.type == :string
+              tbl.print ", :id => false"
+            elsif col.type == :integer
+              tbl.print ", :guid => false"
+            end
+          else
+            tbl.print ", :id => false"
+          end
+          tbl.print ", :force => true"
+          tbl.puts " do |t|"
+
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            next if column.name == pk
+            spec = {}
+            spec[:name]      = column.name.inspect
+            spec[:type]      = column.type.to_s
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+            spec[:precision] = column.precision.inspect if !column.precision.nil?
+            spec[:scale]     = column.scale.inspect if !column.scale.nil?
+            spec[:null]      = 'false' if !column.null
+            spec[:default]   = default_string(column.default) if column.has_default?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ") }
+            spec
+          end.compact
+
+          unless guid_pk.nil? || guid_pk.empty?
+            column_specs.insert( 0, { :name => "\"#{guid_pk}\"", :type => 'binary', :limit => ':limit => 22', :null => ':null => false' } )
+          end
+
+          names = column_specs.map { |h| h[:name] }
+
+          unless guid_fks.nil?
+            guid_fks.each do |fk|
+              pos = names.index( "\"#{fk}\"" )
+              if pos
+                spec = column_specs[pos]
+                spec[:type] = "binary"
+              end
+            end
+          end
+
+          # find all migration keys used in this table
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+
+        stream
+      end
+
+      def indexes_with_lfe_usesguid_migrations( table, stream )
+        pk = @connection.primary_key_name( table )
+        null_foreign_keys, not_null_foreign_keys = @connection.foreign_keys( table )
+
+        unless pk.nil? || pk.empty?
+          stream.puts "  execute \"ALTER TABLE `#{table}` MODIFY COLUMN `#{pk}` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;\""
+          stream.puts "  execute \"ALTER TABLE `#{table}` ADD PRIMARY KEY (#{pk})\""
+        end
+        stream.puts if (null_foreign_keys.nil? || null_foreign_keys.empty?) && (not_null_foreign_keys.nil? || not_null_foreign_keys.empty?)
+
+        null_foreign_keys.each do |key|
+          stream.puts "  execute \"ALTER TABLE `#{table}` MODIFY COLUMN `#{key}` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NULL;\""
+        end
+      
+        not_null_foreign_keys.each do |key|
+          stream.puts "  execute \"ALTER TABLE `#{table}` MODIFY COLUMN `#{key}` VARCHAR(22) BINARY CHARACTER SET latin1 COLLATE latin1_bin NOT NULL;\""
+        end
+
+        stream.puts unless (null_foreign_keys.nil? || null_foreign_keys.empty?) && (not_null_foreign_keys.nil? || not_null_foreign_keys.empty?)
+      
+        indexes_without_lfe_usesguid_migrations( table, stream )
+      end
+    end
+  end
+end

data/lib/usesguid_migrations.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'usesguid_migrations/active_record_extensions/base'
+require 'usesguid_migrations/active_record_extensions/schema'
+require 'usesguid_migrations/active_record_extensions/schema_dumper'
+require 'usesguid_migrations/active_record_extensions/connection_adapters/mysql_adapter'
+require 'usesguid_migrations/active_record_extensions/connection_adapters/schema_statements'
+require 'usesguid_migrations/active_record_extensions/connection_adapters/table_definition'
+  
+module UsesguidMigrations
+  VERSION = '1.0.0'
+end
+
+ActiveRecord::Base.send( :include, UsesguidMigrations::ActiveRecordExtensions::Base ) if defined?( ActiveRecord::Base )
+ActiveRecord::Schema.send( :include, UsesguidMigrations::ActiveRecordExtensions::Schema ) if defined?( ActiveRecord::Schema )
+ActiveRecord::SchemaDumper.send( :include, UsesguidMigrations::ActiveRecordExtensions::SchemaDumper ) if defined?( ActiveRecord::SchemaDumper )
+if defined?( ActiveRecord::ConnectionAdapters::SchemaStatements )
+  ActiveRecord::ConnectionAdapters::SchemaStatements.send( :include, UsesguidMigrations::ActiveRecordExtensions::ConnectionAdapters::SchemaStatements )
+end
+if defined?( ActiveRecord::ConnectionAdapters::TableDefinition )
+  ActiveRecord::ConnectionAdapters::TableDefinition.send( :include, UsesguidMigrations::ActiveRecordExtensions::ConnectionAdapters::TableDefinition )
+end
+if defined?( ActiveRecord::ConnectionAdapters::MysqlAdapter )
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.send( :include, UsesguidMigrations::ActiveRecordExtensions::ConnectionAdapters::MysqlAdapter )
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/usesguid_migrations.rb'}"
+puts "Loading usesguid_migrations gem"
+exec "#{irb} #{libs} --simple-prompt"

data/testdb.rake.txt

@@ -0,0 +1,44 @@
+module Rake
+  module TaskManager
+    def redefine_task(task_class, *args, &block)
+      task_name, deps = resolve_args(args)
+      task_name = task_class.scope_name(@scope, task_name)
+      deps = [deps] unless deps.respond_to?(:to_ary)
+      deps = deps.collect {|d| d.to_s }
+      task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+      task.application = self
+      #task.add_comment(@last_comment)
+      @last_comment = nil
+      task.enhance(deps, &block)
+      task
+    end
+  end
+  class Task
+    class << self
+      def redefine_task(args, &block)
+        Rake.application.redefine_task(self, args, &block)
+      end
+    end
+  end
+end
+
+def redefine_task(args, &block)
+  Rake::Task.redefine_task(args, &block)
+end
+
+namespace :db do
+  namespace :test do
+
+    desc 'Prepare the test database and migrate schema'
+    redefine_task :prepare => :environment do
+      Rake::Task['db:test:migrate_schema'].invoke
+    end
+
+    desc 'Use the migrations to create the test database'
+    task :migrate_schema => 'db:test:purge' do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Migrator.migrate("db/migrate/")
+    end
+
+  end
+end

data/usesguid_migrations.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{usesguid_migrations}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jason Harrelson"]
+  s.date = %q{2009-11-13}
+  s.description = %q{Makes your migrations work with usesguid plugin without explicitly defining the primary key id or foreign keys in migrations.}
+  s.email = %q{jason@lookforwardenterprises.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/usesguid_migrations.rb",
+     "lib/usesguid_migrations/active_record_extensions/base.rb",
+     "lib/usesguid_migrations/active_record_extensions/connection_adapters/mysql_adapter.rb",
+     "lib/usesguid_migrations/active_record_extensions/connection_adapters/schema_statements.rb",
+     "lib/usesguid_migrations/active_record_extensions/connection_adapters/table_definition.rb",
+     "lib/usesguid_migrations/active_record_extensions/schema.rb",
+     "lib/usesguid_migrations/active_record_extensions/schema_dumper.rb",
+     "script/console",
+     "testdb.rake.txt",
+     "usesguid_migrations.gemspec"
+  ]
+  s.homepage = %q{http://github.com/midas/usesguid_migrations}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Makes your migrations work with usesguid plugin without explicitly defining the keys migrations.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.3"])
+      s.add_runtime_dependency(%q<usesguid>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 2.3"])
+      s.add_dependency(%q<usesguid>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 2.3"])
+    s.add_dependency(%q<usesguid>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: usesguid_migrations
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jason Harrelson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-13 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.3"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: usesguid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Makes your migrations work with usesguid plugin without explicitly defining the primary key id or foreign keys in migrations.
+email: jason@lookforwardenterprises.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- History.txt
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/usesguid_migrations.rb
+- lib/usesguid_migrations/active_record_extensions/base.rb
+- lib/usesguid_migrations/active_record_extensions/connection_adapters/mysql_adapter.rb
+- lib/usesguid_migrations/active_record_extensions/connection_adapters/schema_statements.rb
+- lib/usesguid_migrations/active_record_extensions/connection_adapters/table_definition.rb
+- lib/usesguid_migrations/active_record_extensions/schema.rb
+- lib/usesguid_migrations/active_record_extensions/schema_dumper.rb
+- script/console
+- testdb.rake.txt
+- usesguid_migrations.gemspec
+has_rdoc: true
+homepage: http://github.com/midas/usesguid_migrations
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Makes your migrations work with usesguid plugin without explicitly defining the keys migrations.
+test_files: []
+