dbmule 0.1.0

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,83 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.11)
+      activesupport (= 3.2.11)
+      builder (~> 3.0.0)
+    activerecord (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.11)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.4)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.1)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    journey (1.0.4)
+    json (1.7.6)
+    multi_json (1.5.0)
+    rack (1.4.4)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    railties (3.2.11)
+      actionpack (= 3.2.11)
+      activesupport (= 3.2.11)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.6)
+    thor (0.17.0)
+    tilt (1.3.3)
+    tzinfo (0.3.35)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.2.11)
+  jeweler
+  railties (~> 3.2.11)
+  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

@@ -0,0 +1,200 @@
+Rails migrations in non-Rails (and non Ruby) projects.
+
+WHAT'S NEW
+==========
+In the 2.x 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 [Ricardo Valeriano](http://ricardovaleriano.com/) and [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:
+
+    $ gem install standalone_migrations
+
+Add to `Rakefile` in your projects base directory:
+
+```ruby
+require 'standalone_migrations'
+StandaloneMigrations::Tasks.load_tasks
+```
+
+Add database configuration to `db/config.yml` in your projects base directory e.g.:
+
+    development:
+      adapter: sqlite3
+      database: db/development.sqlite3
+      pool: 5
+      timeout: 5000
+
+    production:
+      adapter: mysql
+      encoding: utf8
+      reconnect: false
+      database: somedatabase_dev
+      pool: 5
+      username: root
+      password:
+      socket: /var/run/mysqld/mysqld.sock
+
+    test: &test
+      adapter: sqlite3
+      database: db/test.sqlite3
+      pool: 5
+      timeout: 5000
+
+### To create a new database migration:
+
+    rake db:new_migration name=foo_bar_migration
+    edit db/migrate/20081220234130_foo_bar_migration.rb
+
+#### If you really want to, you can just execute raw SQL:
+
+```ruby
+def up
+  execute "insert into foo values (123,'something');"
+end
+
+def down
+  execute "delete from foo where field='something';"
+end
+```
+
+### To apply your newest migration:
+
+    rake db:migrate
+
+### To migrate to a specific version (for example to rollback)
+
+    rake db:migrate VERSION=20081220234130
+
+### To migrate a specific database (for example your "testing" database)
+
+    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
+
+### Custom configuration
+
+By default, Standalone Migrations will assume there exists a "db/"
+directory in your project. But if for some reason you need a specific
+directory structure to work with, you can use a configuration file
+named .standalone_migrations in the root of your project containing
+the following:
+
+```yaml
+db:
+    seeds: db/seeds.rb
+    migrate: db/migrate
+    schema: db/schema.rb
+config:
+    database: db/config.yml
+```
+
+These are the configurable options available. You can omit any of
+the keys and Standalone Migrations will assume the default values. 
+
+#### Changing environment config in runtime
+
+If you are using Heroku or have to create or change your connection
+configuration based on runtime aspects (maybe environment variables),
+you can use the `StandaloneMigrations::Configurator.environments_config`
+method. Check the usage example:
+
+```ruby
+require 'tasks/standalone_migrations'
+
+StandaloneMigrations::Configurator.environments_config do |env|
+
+  env.on "production" do
+
+    if (ENV['DATABASE_URL'])
+      db = URI.parse(ENV['DATABASE_URL'])
+      return {
+        :adapter  => db.scheme == 'postgres' ? 'postgresql' : db.scheme,
+        :host     => db.host,
+        :username => db.user,
+        :password => db.password,
+        :database => db.path[1..-1],
+        :encoding => 'utf8'
+      }
+    end
+
+    nil
+  end
+
+end
+```
+
+You have to put this anywhere on your `Rakefile`. If you want to
+change some configuration, call the #on method on the object
+received as argument in your block passed to ::environments_config
+method call. The #on method receives the key to the configuration
+that you want to change within the block. The block should return
+your new configuration hash or nil if you want the configuration
+to stay the same.
+
+Your logic to decide the new configuration need to access some data
+in your current configuration? Then you should receive the configuration
+in your block, like this:
+
+```ruby
+require 'tasks/standalone_migrations'
+
+StandaloneMigrations::Configurator.environments_config do |env|
+
+  env.on "my_custom_config" do |current_custom_config|
+    p current_custom_config
+    # => the values on your current "my_custom_config" environment
+    nil
+  end
+
+end
+```
+
+#### Exporting Generated SQL
+
+If instead of the database-agnostic `schema.rb` file you'd like to
+save the database-specific SQL generated by the migrations, simply
+add this to your `Rakefile`.
+
+```ruby
+require 'tasks/standalone_migrations'
+ActiveRecord::Base.schema_format = :sql
+```
+
+You should see a `db/structure.sql` file the next time you run a
+migration.
+
+Contributors
+============
+ - [Todd Huss](http://gabrito.com/)
+ - [Michael Grosser](http://pragmatig.wordpress.com)
+ - [Ricardo Valeriano](http://ricardovaleriano.com/)
+ - [Two Bit Labs](http://twobitlabs.com/)
+ - [ClassMonkeys](http://www.classmonkeys.com/) 
+ - [Windandtides](http://windandtides.com/)
+ - [Eric Lindvall](http://bitmonkey.net)
+ - [Steve Hodgkiss](http://stevehodgkiss.com/)
+ - [Rich Meyers](https://github.com/richmeyers)
+ - [Wes Bailey](http://exposinggotchas.blogspot.com/)
+ - [Robert J. Berger](http://blog.ibd.com/)
+ - [Federico Builes](http://mheroin.com/)
+ - [Gazler](http://blog.gazler.com/)
+ - [Yuu Yamashita](https://github.com/yyuu)
+ - [Koen Punt](http://www.koen.pt/)
+
+This work is originally based on [Lincoln Stoll's blog post](http://lstoll.net/2008/04/stand-alone-activerecord-migrations/) and [David Welton's post](http://journal.dedasys.com/2007/01/28/using-migrations-outside-of-rails).

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'bundler/setup'
+
+task :default do
+  sh "rspec spec"
+end
+
+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
+
+task :specs => ["specs:nodb"]
+namespace :specs do
+  require 'rspec/core/rake_task'
+
+  desc "only specs that don't use database connection"
+  RSpec::Core::RakeTask.new "nodb" do |t|
+  end
+
+  desc "run alls sepcs including those which uses database"
+  task :all => [:default, :nodb]
+end
+
+begin
+  require 'jeweler'
+rescue LoadError => e
+  $stderr.puts "Jeweler, or one of its dependencies, is not available:"
+  $stderr.puts "#{e.class}: #{e.message}"
+  $stderr.puts "Install it with: sudo gem install jeweler"
+else
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'dbmule'
+    gem.summary = "Mule is a database migration tool based upon a stand-alone version of Rails Migrations. It is customized to be used in environments with multiple existing databases and to use SQL scripts by default instead of Migrations DSL."
+    gem.email = "willstepp@gmail.com"
+    gem.homepage = "http://github.com/willstepp/dbmule"
+    gem.authors = ["Daniel Stepp"]
+  end
+
+  Jeweler::GemcutterTasks.new
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/dbmule.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "dbmule"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Stepp"]
+  s.date = "2013-01-28"
+  s.email = "willstepp@gmail.com"
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "dbmule.gemspec",
+    "lib/mule_migrations.rb",
+    "lib/mule_migrations/configurator.rb",
+    "lib/mule_migrations/generator.rb",
+    "lib/mule_migrations/minimal_railtie_config.rb",
+    "lib/mule_migrations/tasks.rb",
+    "lib/mule_migrations/tasks/connection.rake",
+    "lib/mule_migrations/tasks/environment.rake",
+    "lib/mule_migrations/tasks/mule.rake",
+    "lib/tasks/mule_migrations.rb",
+    "vendor/migration_helpers/MIT-LICENSE",
+    "vendor/migration_helpers/README.markdown",
+    "vendor/migration_helpers/init.rb",
+    "vendor/migration_helpers/lib/migration_helper.rb"
+  ]
+  s.homepage = "http://github.com/willstepp/dbmule"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Mule is a database migration tool based upon a stand-alone version of Rails Migrations. It is customized to be used in environments with multiple existing databases and to use SQL scripts by default instead of Migrations DSL."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    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>, ["~> 3.2.11"])
+      s.add_runtime_dependency(%q<railties>, ["~> 3.2.11"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<activerecord>, ["~> 3.2.11"])
+      s.add_dependency(%q<railties>, ["~> 3.2.11"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<activerecord>, ["~> 3.2.11"])
+    s.add_dependency(%q<railties>, ["~> 3.2.11"])
+  end
+end
+

data/lib/mule_migrations.rb

@@ -0,0 +1,19 @@
+lib_path = File.expand_path("../", __FILE__)
+$:.unshift lib_path unless $:.include?(lib_path)
+
+require "rubygems"
+require "rails"
+require "active_record"
+
+require "mule_migrations/configurator"
+require "mule_migrations/generator"
+
+railtie_app_path = "#{lib_path}/mule_migrations/minimal_railtie_config"
+APP_PATH = File.expand_path(railtie_app_path,  __FILE__)
+
+require "mule_migrations/minimal_railtie_config"
+require "mule_migrations/tasks"
+
+if !ENV["RAILS_ENV"]
+  ENV["RAILS_ENV"] = ENV["DB"] || ENV["RACK_ENV"] || Rails.env || "development"
+end

data/lib/mule_migrations/configurator.rb

@@ -0,0 +1,85 @@
+require 'active_support/all'
+
+module MuleMigrations
+
+  class InternalConfigurationsProxy
+
+    def initialize(configurations)
+      @configurations = configurations
+    end
+
+    def on(config_key)
+      if @configurations[config_key] && block_given?
+        @configurations[config_key] = yield(@configurations[config_key]) || @configurations[config_key]
+      end
+      @configurations[config_key]
+    end
+
+  end
+
+  class Configurator
+    def self.load_configurations
+      @mule_configs ||= Configurator.new.config
+      @environments_config ||= YAML.load(ERB.new(File.read(@mule_configs)).result).with_indifferent_access
+    end
+
+    def self.environments_config
+      proxy = InternalConfigurationsProxy.new(load_configurations)
+      yield(proxy) if block_given?
+    end
+
+    def initialize(options = {})
+
+      defaults = {
+        :config       => "#{ENV["DB_NAME"]}db/config.yml",
+        :migrate_dir  => "#{ENV["DB_NAME"]}db/migrate",
+        :seeds        => "#{ENV["DB_NAME"]}db/seeds.rb",
+        :schema       => "#{ENV["DB_NAME"]}db/schema.rb"
+      }
+      @options = load_from_file(defaults.dup) || defaults.merge(options)
+      ENV['SCHEMA'] = File.expand_path(schema)
+    end
+
+    def config
+      @options[:config]
+    end
+
+    def migrate_dir
+      @options[:migrate_dir]
+    end
+
+    def seeds
+      @options[:seeds]
+    end
+
+    def schema
+      @options[:schema]
+    end
+
+    def config_for_all
+      Configurator.load_configurations.dup
+    end
+
+    def config_for(environment)
+      config_for_all[environment]
+    end
+
+    private
+
+    def configuration_file
+      ".mule_migrations"
+    end
+
+    def load_from_file(defaults)   
+      return nil unless File.exists? configuration_file
+      config = YAML.load( IO.read(configuration_file) ) 
+      {
+        :config       => config["config"] ? config["config"]["database"] : defaults[:config],
+        :migrate_dir  => config["db"] ? config["db"]["migrate"] : defaults[:migrate_dir],
+        :seeds        => config["db"] ? config["db"]["seeds"] : defaults[:seeds],
+        :schema       => config["db"] ? config["db"]["schema"] : defaults[:schema]
+      }
+    end
+
+  end
+end

data/lib/mule_migrations/generator.rb

@@ -0,0 +1,83 @@
+# these generators are backed by rails' generators
+require "rails/generators"
+
+module MuleMigrations
+
+  class Generator
+    def self.migration(name, db, type, options="")
+      generator_params = [name] + options.split(" ")
+
+      migration_path = Rails.root.join(db, "db/migrate")
+
+      old_files = Dir.glob(File.join(migration_path, "*"))
+
+      Rails::Generators.invoke "active_record:migration", generator_params,
+        :destination_root => Rails.root.join(db)
+      new_files = Dir.glob(File.join(migration_path, "*"))
+
+      new_migration_file = get_new_migration_file(old_files, new_files)
+
+      if new_migration_file and type == 'sql'
+        filename = File.basename(new_migration_file, ".rb")
+
+        sql_scripts = create_sql_scripts(db, filename)
+
+        #update migration file contents with sql execution code
+        nmf = File.open(new_migration_file, "r") {|f| f.read}
+        updated_nmf = inject_sql_execution_code_into_migration(nmf, filename, sql_scripts)
+        File.open(new_migration_file, 'w') {|f| f.write(updated_nmf)}
+      end
+    end
+
+    def self.get_new_migration_file(old_files, new_files)
+      nf = []
+      new_files.each do |f|
+        if !old_files.include? f
+          nf << f
+        end
+      end
+      nf.count > 0 ? nf.first : nil
+    end
+
+    private
+
+    def self.create_sql_scripts(db, filename)
+      sql_path = Rails.root.join(db, "db/sql")
+      up_script = File.join(sql_path, "#{filename}_up.sql")
+      down_script = File.join(sql_path, "#{filename}_down.sql")
+
+      File.open(up_script, 'w') {|f| f.write("--SQL up code for migration (#{filename}) goes here")}
+      puts ""
+      puts "Mule created: #{filename}_up.sql"
+      File.open(down_script, 'w') {|f| f.write("--SQL down code for migration (#{filename}) goes here")}
+      puts "Mule created: #{filename}_down.sql"
+
+      puts "Mule put the scripts here: #{File.join(db, "db/sql")}"
+      puts ""
+
+      { :up => up_script, :down => down_script }
+    end
+
+    def self.inject_sql_execution_code_into_migration(nmf, filename, sql_scripts)
+
+      ci = nmf.index('class')+5
+      lti = nmf.index('<')-1
+      length = (lti - ci)
+      classname = nmf.slice(ci, length).strip
+
+<<-eos
+class #{classname} < ActiveRecord::Migration
+  def up
+    sql = File.open('#{sql_scripts[:up]}', 'r') {|f| f.read}
+    execute(sql)
+  end
+
+  def down
+    sql = File.open('#{sql_scripts[:down]}', 'r') {|f| f.read}
+    execute(sql)
+  end
+end
+eos
+    end
+  end
+end

data/lib/mule_migrations/minimal_railtie_config.rb

@@ -0,0 +1,10 @@
+module MuleMigrations
+  class MuleMigrations::MinimalRailtieConfig < Rails::Application
+    config.generators.options[:rails] = {:orm => :active_record}
+
+    config.generators.options[:active_record] = {
+      :migration => true,
+      :timestamps => true
+    }
+  end
+end

data/lib/mule_migrations/tasks.rb

@@ -0,0 +1,35 @@
+module MuleMigrations
+  class Tasks
+    class << self
+      def configure
+        Deprecations.new.call
+        config_database_file = Configurator.new.config
+
+        paths = Rails.application.config.paths
+        paths.add "config/database", :with => config_database_file
+      end
+
+      def load_tasks
+        configure
+
+        load "active_record/railties/databases.rake"
+        MinimalRailtieConfig.load_tasks
+        %w(
+          connection
+          environment
+          mule
+        ).each do
+          |task| load "mule_migrations/tasks/#{task}.rake"
+        end
+      end
+    end
+  end
+
+  class Tasks::Deprecations
+    def call
+      if File.directory?('db/migrations')
+        puts "DEPRECATED move your migrations into db/migrate"
+      end
+    end
+  end
+end

data/lib/mule_migrations/tasks/connection.rake

@@ -0,0 +1,7 @@
+require File.expand_path("../../../mule_migrations", __FILE__)
+namespace :mule do
+  task :connection do
+    configurator = MuleMigrations::Configurator.new
+    ActiveRecord::Base.establish_connection configurator.config_for(Rails.env)
+  end
+end

data/lib/mule_migrations/tasks/environment.rake

@@ -0,0 +1,3 @@
+require File.expand_path("../../../mule_migrations", __FILE__)
+task :environment => ["mule:connection"] do
+end

data/lib/mule_migrations/tasks/mule.rake

@@ -0,0 +1,331 @@
+require File.expand_path("../../../mule_migrations", __FILE__)
+require 'fileutils'
+require 'yaml'
+
+#these tasks reference rails migration tasks located here:
+#https://github.com/rails/rails/blob/master/activerecord/lib/active_record/railties/databases.rake
+
+namespace :mule do
+
+  task :new_project, :db do |t, args|
+
+    def config_template(db)
+<<-eos
+development:
+  adapter: postgresql
+  encoding: unicode
+  database: #{db}_development
+  pool: 5
+  username:
+  password:
+  host:
+
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: #{db}_test
+  pool: 5
+  username:
+  password:
+  host:
+
+production:
+  adapter: postgresql
+  encoding: unicode
+  database: #{db}_production
+  pool: 5
+  username:
+  password:
+  host:
+eos
+    end
+
+    def seeds_template(db)
+<<-eos
+#run all sql scripts from #{db}/db/seeds
+connection = ActiveRecord::Base.connection();
+sql_seed_files = Dir.glob(Rails.root.join("#{db}/db/seeds", "*.sql"))
+sql_seed_files.each do |ssf|
+  sql = File.open(ssf, "r") {|f| f.read}
+  connection.execute(sql)
+end
+eos
+    end
+
+    db = args[:db] || ENV['db']
+    unless db
+      puts ""
+      puts "Mule Error: must provide name of database to generate project for."
+      puts "example: rake #{t.name} db=my_cool_database"
+      puts ""
+      abort
+    end
+
+    project_dir = Rails.root.join(db)
+
+    exists = File.exists? project_dir
+    if !exists
+      puts ""
+      puts "Mule started creating database project for #{db}"
+
+      FileUtils.mkdir(project_dir)
+      puts "Mule created directory: #{db}"
+      db_dir = File.join(project_dir, "db")
+      FileUtils.mkdir(db_dir)
+      puts "Mule created directory: #{File.join(db, "db")}"
+      migrate_dir = File.join(db_dir, "migrate")
+      FileUtils.mkdir(migrate_dir)
+      puts "Mule created directory: #{File.join(db, "db", "migrate")}"
+      sql_dir = File.join(db_dir, "sql")
+      FileUtils.mkdir(sql_dir)
+      puts "Mule created directory: #{File.join(db, "db", "sql")}"
+      seeds_dir = File.join(db_dir, "seeds")
+      FileUtils.mkdir(seeds_dir)
+      puts "Mule created directory: #{File.join(db, "db", "seeds")}"
+      config_file = File.join(db_dir, "config.yml")
+      File.open(config_file, 'w') {|f| f.write(config_template(db))}
+      puts "Mule created file: #{File.join(db, "db", "config.yml")}"
+      seeds_file = File.join(db_dir, "seeds.rb")
+      File.open(seeds_file, 'w') {|f| f.write(seeds_template(db))}
+      puts "Mule created file: #{File.join(db, "db", "seeds.rb")}"
+
+      puts "Mule finished creating database project for #{db}"
+      puts ""
+    else
+      puts ""
+      puts "This database project already exists. Please choose another name."
+      puts ""
+      abort
+    end
+  end
+
+  task :configure_existing_database, :db do |t, args|
+    db = args[:db] || ENV['db']
+
+    unless db
+      puts ""
+      puts "Mule Error: must provide name of database"
+      puts "Example: rake #{current_task.name} db=my_cool_database"
+      puts ""
+      abort
+    end
+
+    puts ""
+    puts "Mule configuring migrations on existing database"
+
+    #create backup file of existing database schema
+    begin
+      Rake::Task["mule:structure:dump"].invoke(db)
+    rescue => e
+      #the above raises an exception in this scenario becuase it expects a
+      #schema_migrations table to exist, which it does not yet since there are 
+      #no migrations, but the dump completes successfully anyway, so we just
+      #catch it here
+    end
+    
+    schema = Rails.root.join(db, "db/structure_#{ENV['RAILS_ENV']}.sql")
+
+    #run mule:new_migration init_from_existing_schema
+    migration_path = Rails.root.join(db, "db/migrate")
+    old_files = Dir.glob(File.join(migration_path, "*"))
+    Rake::Task["mule:new_migration"].invoke("init_from_existing_db", db)
+    new_files = Dir.glob(File.join(migration_path, "*"))
+
+    new_migration_file = MuleMigrations::Generator.get_new_migration_file(old_files, new_files)
+    filename = File.basename(new_migration_file, ".rb")
+
+    #run the new empty migration in order to insert an initial version into database
+    Rake::Task["mule:migrate"].invoke(db)
+
+    #copy schema dump into generated sql up file
+    s = File.open(schema, "r") {|f| f.read}
+    File.open(Rails.root.join(db, "db/sql/#{filename}_up.sql"), 'w') {|f| f.write(s)}
+
+    puts ""
+    puts "Mule finished"
+    puts ""
+  end
+
+  task :new_migration, :name, :db, :type, :options do |t, args|
+    name = args[:name] || ENV['name']
+    db = args[:db] || ENV['db']
+
+    type = args[:type] || ENV['type']
+    if type.nil? then type = "sql" end
+
+    options = args[:options] || ENV['options']
+
+    unless db
+      puts ""
+      puts "Mule Error: must provide name of database to generate migration for."
+      puts "Example: rake #{t.name} db=my_cool_database name=add_field_to_form"
+      puts ""
+      abort
+    end
+    
+    unless name
+      puts ""
+      puts "Mule Error: must provide name of migration to generate."
+      puts "Example: rake #{t.name} name=add_field_to_form"
+      puts ""
+      abort
+    end
+
+    set_rails_config_for(db)
+    
+    if options
+      MuleMigrations::Generator.migration name, db, type, options.gsub('/', ' ')
+    else
+      MuleMigrations::Generator.migration name, db, type
+    end
+  end
+
+  task :migrate, :db do |t, args|
+    invoke_task_for(args[:db] || ENV['db'], t, "db:migrate")
+  end
+
+  namespace :migrate do
+    task :up, :db do |t, args|
+      invoke_task_for(args[:db] || ENV['db'], t, "db:migrate:up")
+    end
+
+    task :down, :db, :confirm do |t, args|
+      if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+      invoke_task_for(args[:db] || ENV['db'], t, "db:migrate:down")
+    end
+
+    task :redo, :db do |t, args|
+      invoke_task_for(args[:db] || ENV['db'], t, "db:migrate:redo")
+    end
+
+    task :reset, :db, :confirm do |t, args|
+      if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+      invoke_task_for(args[:db] || ENV['db'], t, "db:migrate:reset")
+    end
+
+    task :status, :db do |t, args|
+      invoke_task_for(args[:db] || ENV['db'], t, "db:migrate:status")
+    end
+
+  end
+
+  task :rollback, :db, :confirm do |t, args|
+    if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+    invoke_task_for(args[:db] || ENV['db'], t, "db:rollback")
+  end
+
+  task :create, :db do |t, args|
+    invoke_task_for(args[:db] || ENV['db'], t, "db:create")
+  end
+
+  task :drop, :db, :confirm do |t, args|
+    if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+    invoke_task_for(args[:db] || ENV['db'], t, "db:drop")
+  end
+
+  task :reset, :db, :confirm do |t, args|
+    if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+    invoke_task_for(args[:db] || ENV['db'], t, "db:reset")
+  end
+
+  task :redo, :db do |t, args|
+    invoke_task_for(args[:db] || ENV['db'], t, "db:redo")
+  end
+
+  namespace :schema do
+    task :dump, :db do |t, args|
+      invoke_task_for(args[:db] || ENV['db'], t, "db:schema:dump")
+    end
+
+    task :load, :db do |t, args|
+      invoke_task_for(args[:db] || ENV['db'], t, "db:schema:load")
+    end
+  end
+
+  namespace :structure do
+    task :dump, :db do |t, args|
+      invoke_task_for(db = args[:db] || ENV['db'], t, "db:structure:dump")
+    end
+
+    task :load, :db do |t, args|
+      invoke_task_for(db = args[:db] || ENV['db'], t, "db:structure:load")
+    end
+  end
+
+  task :drop, :db, :confirm do |t, args|
+    if ENV['RAILS_ENV'] and ENV['RAILS_ENV'].include? "production"
+      ensure_confirmation(t, args[:confirm] || ENV['confirm'], args[:db] || ENV['db'])
+    end
+    invoke_task_for(db = args[:db] || ENV['db'], t, "db:drop")
+  end
+
+  task :setup, :db do |t, args|
+    invoke_task_for(db = args[:db] || ENV['db'], t, "db:setup")
+  end
+
+  task :seed, :db do |t, args|
+    invoke_task_for(db = args[:db] || ENV['db'], t, "db:seed")
+  end
+
+  namespace :fixtures do
+    task :load, :db do |t, args|
+      invoke_task_for(db = args[:db] || ENV['db'], t, "db:fixtures:load")
+    end
+
+    task :identify, :db do |t, args|
+      invoke_task_for(db = args[:db] || ENV['db'], t, "db:fixtures:identify")
+    end
+  end
+
+  task :version, :db do |t, args|
+    invoke_task_for(db = args[:db] || ENV['db'], t, "db:version")
+  end
+end
+
+def invoke_task_for(db, current_task, task_to_invoke)
+  unless db
+    puts ""
+    puts "Mule Error: must provide name of database"
+    puts "Example: rake #{current_task.name} db=my_cool_database"
+    puts ""
+    abort
+  end
+
+  set_rails_config_for(db)
+  Rake::Task[task_to_invoke].invoke
+end
+
+def set_rails_config_for(db)
+  paths = Rails.application.config.paths
+  paths.add "config/database", :with => File.join(db, "db/config.yml")
+  paths.add "db/migrate", :with => File.join(db, "db/migrate")
+  paths.add "db/seeds", :with => File.join(db, "db/seeds.rb")
+  paths.add "db/schema", :with => File.join(db, "db/schema.rb")
+  ENV['DB_STRUCTURE'] = File.join(db, "db/structure_#{ENV['RAILS_ENV']}.sql")
+
+  #for use in configurator initialize
+  ENV["DB_NAME"] = db + "/"
+end
+
+def ensure_confirmation(current_task, confirm, db)
+  if !confirm.nil? and !db.nil?
+    if confirm.downcase == db.downcase
+      return true
+    end
+  end
+  puts ""
+  puts "Mule Error: destructive operations on the production database requires a confirmation argument"
+  puts "Usage: rake #{current_task.name} confirm=<database_name> ...other arguments"
+  puts ""
+  abort
+end

data/lib/tasks/mule_migrations.rb

@@ -0,0 +1,2 @@
+require File.expand_path("../../mule_migrations", __FILE__)
+MuleMigrations::Tasks.load_tasks

data/vendor/migration_helpers/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jesús García Sáez
+
+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/vendor/migration_helpers/README.markdown

@@ -0,0 +1,92 @@
+
+DESCRIPTION
+===========
+
+Helpers for migrations of ActiveRecord for dealing with foreign keys and primary keys.
+
+FEATURES
+========
+
+ * **foreign keys**
+    * foreign_key(table, field, referenced_table, referenced_field, on_cascade)
+    * drop_foreign_key(table, field)
+ * **primary keys**
+    * primary_key(table, field)
+
+Examples
+========
+
+Typical use:
+
+    def self.up
+      create_table :profiles do |t|
+        t.string  :first_name
+        t.string  :last_name
+        t.string  :email
+        t.boolean :is_disabled
+      end
+      create_table :users do |t|
+        t.string  :login
+        t.string  :crypted_password
+        t.string  :salt
+        t.integer :profile_id
+      end
+
+      foreign_key :users, :profile_id, :profiles
+    end
+
+    def self.down
+      drop_foreign_key :users, :profile_id
+      drop_table       :users
+      drop_table       :profiles
+    end
+
+
+Also, if we don't defined a common :id (exactly it's rails who define it), we should create a primary key:
+
+    def self.up
+      create_table :foo, :id => false do |t|
+         t.string :foo, :bar
+      end
+
+      primary_key :foo, [ :foo, :bar ]
+    end
+
+In the parameter where a field is required (like the second parameter in *primary_key*) you can specified and symbol (or string) or an array of symbols (or strings).
+
+
+REQUIREMENTS
+============
+
+ * It's been tested with Mysql adapter and Jdbcmysql adapter
+
+INSTALL
+=======
+
+ * script/plugin install git://github.com/blaxter/migration_helpers.git
+
+LICENSE
+=======
+
+(The MIT License)
+
+Copyright (c) 2008 Jesús García Sáez <jgarcia@warp.es>
+
+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/vendor/migration_helpers/init.rb

@@ -0,0 +1,4 @@
+require 'migration_helper'
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.
+  send :include, MigrationConstraintHelpers

data/vendor/migration_helpers/lib/migration_helper.rb

@@ -0,0 +1,51 @@
+module MigrationConstraintHelpers
+
+   # Creates a foreign key from +table+.+field+ against referenced_table.referenced_field
+   #
+   # table: The tablename
+   # field: A field of the table
+   # referenced_table: The table which contains the field referenced
+   # referenced_field: The field (which should be part of the primary key) of the referenced table
+   # cascade: delete & update on cascade?
+   def foreign_key(table, field, referenced_table, referenced_field = :id, cascade = true)
+      execute "ALTER TABLE #{table} ADD CONSTRAINT #{constraint_name(table, field)}
+               FOREIGN KEY #{constraint_name(table, field)} (#{field_list(field)})
+               REFERENCES #{referenced_table}(#{field_list(referenced_field)})
+               #{(cascade ? 'ON DELETE CASCADE ON UPDATE CASCADE' : '')}"
+   end
+
+   # Drops a foreign key from +table+.+field+ that has been created before with
+   # foreign_key method
+   #
+   # table: The table name
+   # field: A field (or array of fields) of the table
+   def drop_foreign_key(table, field)
+      execute "ALTER TABLE #{table} DROP FOREIGN KEY #{constraint_name(table, field)}"
+   end
+
+   # Creates a primary key for +table+, which right now HAS NOT primary key defined
+   #
+   # table: The table name
+   # field: A field (or array of fields) of the table that will be part of the primary key
+   def primary_key(table, field)
+      execute "ALTER TABLE #{table} ADD PRIMARY KEY(#{field_list(field)})"
+   end
+
+   private
+
+   # Creates a constraint name for table and field given as parameters
+   #
+   # table: The table name
+   # field: A field of the table
+   def constraint_name(table, field)
+      "fk_#{table}_#{field_list_name(field)}"
+   end
+
+   def field_list(fields)
+      fields.is_a?(Array) ? fields.join(',') : fields
+   end
+
+   def field_list_name(fields)
+      fields.is_a?(Array) ? fields.join('_') : fields
+   end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: dbmule
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Stepp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+description: 
+email: willstepp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- dbmule.gemspec
+- lib/mule_migrations.rb
+- lib/mule_migrations/configurator.rb
+- lib/mule_migrations/generator.rb
+- lib/mule_migrations/minimal_railtie_config.rb
+- lib/mule_migrations/tasks.rb
+- lib/mule_migrations/tasks/connection.rake
+- lib/mule_migrations/tasks/environment.rake
+- lib/mule_migrations/tasks/mule.rake
+- lib/tasks/mule_migrations.rb
+- vendor/migration_helpers/MIT-LICENSE
+- vendor/migration_helpers/README.markdown
+- vendor/migration_helpers/init.rb
+- vendor/migration_helpers/lib/migration_helper.rb
+homepage: http://github.com/willstepp/dbmule
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Mule is a database migration tool based upon a stand-alone version of Rails
+  Migrations. It is customized to be used in environments with multiple existing databases
+  and to use SQL scripts by default instead of Migrations DSL.
+test_files: []