tableflip 0.1.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'mysql2'
+gem 'eventmachine'
+gem 'em-synchrony'
+
+group :development do
+  gem 'bundler', '>= 1.0.0'
+  gem 'jeweler', '>= 1.8.4'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Scott Tadman, The Working Group Inc.
+
+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.md

@@ -0,0 +1,26 @@
+# tableflip
+
+MySQL Table Migration Tool
+
+## Background
+
+Maybe you have a number of large tables that need to be packed up and moved
+somewhere else. Maybe you've tried other methods that almost work but don't
+quite. This might be your only hope.
+
+## Inspiration
+
+(╯°□°）╯︵ ┻━┻
+
+## Caveats
+
+This tool makes an extraordinary number of assumptions about how your data
+is structured and what gems you have available. By some small miracle it might
+work on your project, but it has an equally large chance of not working at all.
+
+Needless to say, this is not a fully functional, battle-tested tool. Yet.
+
+## Copyright
+
+Copyright (c) 2013 Scott Tadman, The Working Group Inc.
+See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "tableflip"
+  gem.homepage = "http://github.com/twg/tableflip"
+  gem.license = "MIT"
+  gem.summary = %Q{MySQL Table Flipping System}
+  gem.description = %Q{Flips tables from one database to another}
+  gem.email = "scott@twg.ca"
+  gem.authors = [ "Scott Tadman" ]
+  # dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/tableflip

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../lib', File.dirname(File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__))
+
+ENV['TZ'] = 'UTC'
+
+require 'tableflip'
+
+strategy = Tableflip::ArgumentParser.new.parse(ARGV)
+
+Tableflip::Executor.new(strategy).execute!

data/lib/tableflip.rb

@@ -0,0 +1,6 @@
+module Tableflip
+  autoload(:ArgumentParser, 'tableflip/argument_parser')
+  autoload(:DatabaseHandle, 'tableflip/database_handle')
+  autoload(:Executor, 'tableflip/executor')
+  autoload(:Strategy, 'tableflip/strategy')
+end

data/lib/tableflip/argument_parser.rb

@@ -0,0 +1,110 @@
+require 'optparse'
+
+class Tableflip::ArgumentParser
+  # == Constants ============================================================
+
+  # == Class Methods ========================================================
+
+  def self.default_env(env = nil)
+    (env || ENV)['RAILS_ENV'] || 'development'
+  end
+  
+  # == Instance Methods =====================================================
+
+  def initialize
+  end
+
+  def parse(args, env = nil)
+    strategy = Tableflip::Strategy.new
+
+    strategy.source_env = self.class.default_env(env)
+
+    _parser = parser(strategy)
+
+    tables = _parser.parse!(args)
+
+    tables.each do |table|
+      strategy.tables << table
+    end
+
+    if (strategy.tables.empty? or strategy.actions.empty?)
+      strategy.message = _parser.to_s
+    end
+
+    strategy
+  end
+
+  def parser(strategy)
+    OptionParser.new do |parser|
+      parser.banner = "Usage: tableflip [options] [table_name [table_name [...]]]"
+
+      parser.separator("")
+      parser.separator("Options:")
+
+      parser.on("-a", "--all", "Track all tables") do |s|
+        strategy.tables << :__all__
+      end
+
+      parser.on("-b", "--block=s", "Transfer data in blocks of N rows") do |s|
+        strategy.block_size = s.to_i
+      end
+      parser.on("-f", "--config=s") do |path|
+        strategy.config_path = path
+      end
+      parser.on("-t", "--track", "Add tracking triggers on tables") do
+        strategy.actions << :tracking_add
+      end
+      parser.on("-d", "--seed", "Seed the tracking table with entries from the source table") do
+        strategy.actions << :tracking_seed
+      end
+      parser.on("-r", "--remove", "Remove tracking triggers from tables") do
+        strategy.actions << :tracking_remove
+      end
+      parser.on("-o", "--target=s", "Set target environment") do |s|
+        strategy.target_env = s
+      end
+      parser.on("-m", "--migrate", "Migrate tables to environment") do
+        strategy.actions << :table_migrate
+      end
+      parser.on("-c", "--count", "Count number of records in source table") do
+        strategy.actions << :table_count
+      end
+      parser.on("-s", "--status", "Show current status") do
+        strategy.actions << :table_report_status
+      end
+      parser.on("-e", "--env=s", "Establish primary environment") do |s|
+        strategy.source_env = s
+      end
+      parser.on("-x", "--exclude=s", "Exclude column(s) from migration") do |s|
+        s.split(/,/).each do |column|
+          strategy.exclude_columns << column
+        end
+      end
+      parser.on("-n", "--encoding=s", "Set connection encoding") do |s|
+        strategy.encoding = s
+      end
+      parser.on("-k", "--create-test", "Creates a test table") do
+        strategy.actions << :table_create_test
+      end
+      parser.on("-z", "--fuzz[=d]", "Inserts and alters records on test table") do |d|
+        strategy.actions << :table_fuzz
+
+        if (d)
+          strategy.fuzz_intensity = d.to_i
+        end
+      end
+      parser.on("-p", "--persist", "Keep running perpetually") do
+        strategy.persist = true
+      end
+      parser.on("-w","--where=s", "Add conditions to selecting") do |s|
+        strategy.where = s
+      end
+      parser.on("-q", "--debug", "Show the queries as they're executed") do
+        strategy.debug_queries = true
+      end
+      parser.on("-h", "--help", "Display this help") do
+        strategy.message = parser.to_s
+      end
+    end
+  end
+end

data/lib/tableflip/database_handle.rb

@@ -0,0 +1,85 @@
+require 'mysql2'
+require 'mysql2/em'
+require 'yaml'
+
+class Tableflip::DatabaseHandle
+  # == Constants ============================================================
+  
+  DATABASE_CONFIG_FILE = 'database.yml'
+
+  DEFAULT_OPTIONS = {
+    :symbolize_keys => true,
+    :encoding => 'utf-8'
+  }.freeze
+
+  PARAM_MAP = Hash.new do |h, k|
+    k.to_sym
+  end
+
+  # == Class Methods ========================================================
+
+  def self.config_path
+    path = Dir.pwd
+    last_path = nil
+
+    while (path != last_path)
+      config_path = File.expand_path("config/#{DATABASE_CONFIG_FILE}", path)
+
+      if (File.exist?(config_path))
+        return config_path
+      end
+
+      last_path = path
+      path = File.expand_path('..', path)
+    end
+
+    nil
+  end
+
+  def self.config
+    @config ||= begin
+      _config_path = self.config_path
+
+      if (!_config_path)
+        STDERR.puts("Could not find #{DATABASE_CONFIG_FILE}")
+        exit(-1)
+      elsif (File.exists?(_config_path))
+        File.open(_config_path) do |f|
+          YAML.load(f)
+        end
+      else
+        STDERR.puts "Could not open #{_config_path}"
+        exit(-1)
+      end
+    end
+  end
+
+  def self.runtime_environment
+    DAEMON_ENV or 'development'
+  end
+
+  def self.environment_config(env)
+    _config = self.config[env]
+
+    unless (_config)
+      raise "No environment #{env} defined in #{self.config_path}"
+    end
+
+    options = DEFAULT_OPTIONS.dup
+
+    _config.each do |k, v|
+      options[PARAM_MAP[k]] = v
+    end
+
+    options[:loggers] = [ ]
+
+    options
+  end
+
+  def self.connect(env, options)
+    Mysql2::EM::Client.new(self.environment_config(env).merge(options))
+  end
+
+  # == Instance Methods =====================================================
+
+end

data/lib/tableflip/executor.rb

@@ -0,0 +1,427 @@
+class Tableflip::Executor
+  class BinaryString < String
+  end
+
+  # == Instance Methods =====================================================
+
+  def initialize(strategy)
+    @strategy = strategy
+
+    @time_format = '%Y-%m-%d %H:%M:%S'
+  end
+
+  def log(message)
+    puts "[%s] %s" % [ Time.now.strftime(@time_format), message ]
+  end
+
+  def await
+    @await ||= Hash.new { |h, k| h[k] = [ ] }
+
+    fibers = @await[Fiber.current]
+
+    fibers << Fiber.current
+
+    yield if (block_given?)
+
+    fibers.delete(Fiber.current)
+
+    while (fibers.any?)
+      Fiber.yield
+    end
+  end
+
+  def defer
+    parent_fiber = Fiber.current
+
+    fibers = @await[parent_fiber]
+
+    fiber = Fiber.new do
+      yield if (block_given?)
+
+      fibers.delete(Fiber.current)
+
+      parent_fiber.resume
+    end
+
+    fibers << fiber
+
+    EventMachine.next_tick do
+      fiber.resume
+    end
+  end
+
+  def execute!
+    require 'eventmachine'
+    require 'em-synchrony'
+
+    if (@strategy.message)
+      puts @strategy.message
+      exit(0)
+    end
+
+    tables = { }
+
+    EventMachine.synchrony do
+      if (@strategy.tables.include?(:__all__))
+        source_db = Tableflip::DatabaseHandle.connect(
+          @strategy.source_env,
+          :encoding => @strategy.encoding
+        )
+
+        @strategy.tables.delete(:__all__)
+
+        result = do_query(source_db, "SHOW TABLES")
+
+        result.each do |row|
+          table_name = row.first[1]
+
+          case (table_name)
+          when 'schema_migrations', /__changes/
+            next
+          end
+
+          @strategy.tables << table_name
+        end
+      end
+
+      await do
+        @strategy.tables.each do |table|
+          defer do
+            queue = @strategy.actions.dup
+
+            table_config = tables[table] = {
+              :table => table,
+              :queue => queue
+            }
+                
+            while (action = queue.shift)
+              log("#{table} [#{action}]")
+
+              source_db = Tableflip::DatabaseHandle.connect(
+                @strategy.source_env,
+                :encoding => @strategy.encoding
+              )
+
+              case (action)
+              when :tracking_add
+                tracking_add(source_db, table_config)
+              when :tracking_remove
+                tracking_remove(source_db, table_config)
+              when :tracking_seed
+                tracking_seed(source_db, table_config)
+              when :table_migrate
+                @strategy.complete = false
+
+                target_db = Tableflip::DatabaseHandle.connect(
+                  @strategy.target_env,
+                  :encoding => @strategy.encoding
+                )
+                table_migrate(source_db, target_db, table_config)
+              when :table_report_status
+                target_db = Tableflip::DatabaseHandle.connect(
+                  @strategy.target_env,
+                  :encoding => @strategy.encoding
+                )
+                table_report_status(source_db, target_db, table_config)
+              when :table_count
+                table_count(source_db, target_db, table_config)
+              when :table_create_test
+                table_create_test(source_db, table_config)
+              when :table_fuzz
+                table_fuzz(source_db, table_config, @strategy.fuzz_intensity)
+              end
+            end
+          end
+        end
+      end
+
+      EventMachine.stop_event_loop
+    end
+  end
+
+  def escaper(db, value)
+    case (value)
+    when nil
+      'NULL'
+    when BinaryString
+      "0x%s" % value.unpack("H*")
+    when Fixnum
+      value
+    when Date
+      '"' + db.escape(value.strftime('%Y-%m-%d')) + '"'
+    when DateTime, Time
+      '"' + db.escape(value.utc.strftime('%Y-%m-%d %H:%M:%S')) + '"'
+    when Array
+      value.collect { |v| escaper(db, v) }.join(',')
+    else
+      '"' + db.escape(value.to_s) + '"'
+    end
+  end
+
+  def do_query(db, query, *values)
+    fiber = Fiber.current
+    query = query.gsub('?') do |s|
+      escaper(db, values.shift)
+    end
+
+    if (@strategy.debug_queries?)
+      puts "SQL> #{query}"
+    end
+
+    completed = false
+
+    while (!completed)
+      begin
+        deferred = db.query(query)
+
+        deferred.callback do |result|
+          EventMachine.next_tick do
+            completed = true
+
+            fiber.resume(result)
+          end
+        end
+
+        deferred.errback do |err|
+          EventMachine.next_tick do
+            completed = true
+
+            fiber.resume(err)
+          end
+        end
+
+        case (response = Fiber.yield)
+        when Exception
+          raise response
+        else
+          return response
+        end
+
+      rescue Mysql2::Error => e
+        if (e.to_s.match(/MySQL server has gone away/))
+          # Ignore
+        else
+          raise e
+        end
+      end
+    end
+  end
+
+  def table_exists?(db, table)
+    do_query(db, "SHOW FIELDS FROM `#{table}`")
+
+    true
+
+  rescue Mysql2::Error
+    false
+  end
+
+  def tracking_add(db, table_config)
+    table = table_config[:table]
+    changes_table = "#{table}__changes"
+
+    if (table_exists?(db, changes_table))
+      STDERR.puts("Table #{changes_table} already exists. Not recreated.")
+    else
+      do_query(db, "CREATE TABLE `#{changes_table}` (id INT PRIMARY KEY, claim INT, INDEX index_claim (claim))")
+      do_query(db, "CREATE TRIGGER `#{table}__tai` AFTER INSERT ON `#{table}` FOR EACH ROW INSERT IGNORE INTO `#{changes_table}` (id) VALUES (NEW.id) ON DUPLICATE KEY UPDATE claim=NULL")
+      do_query(db, "CREATE TRIGGER `#{table}__tau` AFTER UPDATE ON `#{table}` FOR EACH ROW INSERT IGNORE INTO `#{changes_table}` (id) VALUES (NEW.id) ON DUPLICATE KEY UPDATE claim=NULL")
+    end
+  end
+
+  def tracking_remove(db, table_config)
+    table = table_config[:table]
+    changes_table = "#{table}__changes"
+
+    if (table_exists?(db, changes_table))
+      do_query(db, "DROP TABLE IF EXISTS `#{table}__changes`")
+      do_query(db, "DROP TRIGGER IF EXISTS `#{table}__tai`")
+      do_query(db, "DROP TRIGGER IF EXISTS `#{table}__tau`")
+    else
+      STDERR.puts("Table #{changes_table} does not exist. Not removed.")
+    end
+  end
+
+  def tracking_seed(db, table_config)
+    table = table_config[:table]
+    changes_table = "#{table}__changes"
+
+    result = do_query(db, "SELECT id FROM `#{table}` #{@strategy.where}")
+
+    ids = result.collect { |r| r[:id] }
+    GC.start
+
+    if (ids.any?)
+      log("Populating #{ids.length} entries into #{changes_table} from #{table}")
+
+      ((ids.length / @strategy.block_size) + 1).times do |n|
+        start_offset = @strategy.block_size * n
+        id_block = ids[start_offset, @strategy.block_size]
+
+        if (id_block and id_block.any?)
+          query = "INSERT IGNORE INTO `#{changes_table}` (id) VALUES %s" % [
+            id_block.collect { |id| "(%d)" % id }.join(',')
+          ]
+
+          do_query(db, query)
+
+          log("%d/%d entries added to #{changes_table}" % [ start_offset + id_block.length, ids.length ])
+        end
+      end
+    else
+      log("No records to migrate from #{table}")
+    end
+  end
+
+  def table_report_status(source_db, target_db, table_config)
+    table = table_config[:table]
+    changes_table = "#{table}__changes"
+
+    source_table_count = do_query(source_db, "SELECT COUNT(*) AS count FROM `#{table}`").first[:count]
+    target_table_count = do_query(target_db, "SELECT COUNT(*) AS count FROM `#{table}`").first[:count]
+    migrated_count = do_query(source_db, "SELECT COUNT(*) AS count FROM `#{changes_table}` WHERE claim IS NOT NULL").first[:count]
+    tracked_count = do_query(source_db, "SELECT COUNT(*) AS count FROM `#{changes_table}`").first[:count]
+
+    percentage = tracked_count > 0 ? (migrated_count.to_f * 100 / tracked_count) : 0.0
+
+    log(
+      "%s: %d/%d [%d/%d] (%.1f%%)" % [
+        table,
+        source_table_count,
+        target_table_count,
+        migrated_count,
+        tracked_count,
+        percentage
+      ]
+    )
+  end
+
+  def table_migrate(source_db, target_db, table_config)
+    table = table_config[:table]
+    changes_table = "#{table}__changes"
+
+    result = do_query(source_db, "SELECT COUNT(*) AS rows FROM `#{changes_table}` WHERE claim IS NULL")
+    count = table_config[:count] = result.first[:rows]
+
+    log("#{table} has #{table_config[:count]} records to migrate.")
+
+    next_claim = do_query(source_db, "SELECT MAX(claim) AS claim FROM `#{changes_table}`").first[:claim] || 0
+
+    result = do_query(source_db, "SHOW FIELDS FROM `#{table}`")
+
+    exclusions = Hash[
+      @strategy.exclude_columns.collect do |column|
+        [ column.to_sym, true ]
+      end
+    ]
+
+    columns = [ ]
+    binary_columns = { }
+
+    result.each do |r|
+      column = r[:Field].to_sym
+
+      next if (exclusions[column])
+
+      columns << column
+
+      case (r[:Type].downcase)
+      when 'tinyblob','blob','mediumblob','longblob','binary','varbinary'
+        binary_columns[column] = true
+      end
+    end
+
+    if (binary_columns.any?)
+      log("#{table} has binary columns: #{binary_columns.keys.join(',')}")
+    end
+
+    @migrating ||= { }
+
+    fiber = Fiber.current
+    migrated = 0
+    selected = 1
+
+    loop do
+      next_claim += 1
+      do_query(source_db, "UPDATE `#{changes_table}` SET claim=? WHERE claim IS NULL LIMIT ?", next_claim, @strategy.block_size)
+
+      result = do_query(source_db, "SELECT id FROM `#{changes_table}` WHERE claim=?", next_claim)
+
+      id_block = result.to_a.collect { |r| r[:id] }
+
+      if (id_block.length == 0)
+        if (@strategy.persist?)
+          EventMachine::Timer.new(1) do
+            fiber.resume
+          end
+
+          Fiber.yield
+
+          next
+        else
+          break
+        end
+      end
+
+      log("Claim \##{next_claim} yields #{id_block.length} records.")
+
+      selected = do_query(source_db, "SELECT * FROM `#{table}` WHERE id IN (?)", id_block)
+
+      values = selected.collect do |row|
+        "(%s)" % [
+          escaper(
+            source_db,
+            columns.collect do |column|
+              (binary_columns[column] and row[column]) ? BinaryString.new(row[column]) : row[column]
+            end
+          )
+        ]
+      end
+
+      do_query(target_db, "REPLACE INTO `#{table}` (#{columns.collect { |c| "`#{c}`" }.join(',')}) VALUES #{values.join(',')}")
+
+      selected = values.length
+      migrated += values.length
+
+      log("Migrated %d/%d records for #{table}" % [ migrated, count ])
+    end
+  end
+
+  def table_create_test(db, table_config)
+    table = table_config[:table]
+
+    do_query(db, "CREATE TABLE `#{table}` (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255), created_at DATETIME, updated_at DATETIME)")
+  rescue Mysql2::Error => e
+    puts e.to_s
+  end
+
+  def table_fuzz(db, table_config, count)
+    require 'securerandom'
+
+    table = table_config[:table]
+
+    EventMachine::PeriodicTimer.new(1) do
+      unless (@inserting)
+        @inserting = true
+
+        Fiber.new do
+          now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
+
+          log("Adding #{count} rows to #{table}")
+
+          count.times do
+            do_query(db,
+              "INSERT IGNORE INTO `#{table}` (id, name, created_at, updated_at) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE name=VALUES(name), updated_at=VALUES(updated_at)",
+              SecureRandom.random_number(1<<20),
+              SecureRandom.hex,
+              now,
+              now
+            )
+          end
+
+          @inserting = false
+        end.resume
+      end
+    end
+  end
+end

data/lib/tableflip/strategy.rb

@@ -0,0 +1,46 @@
+require 'ostruct'
+
+class Tableflip::Strategy
+  # == Properties ===========================================================
+
+  attr_accessor :actions
+  attr_accessor :block_size
+  attr_accessor :complete
+  attr_accessor :config_path
+  attr_accessor :debug_queries
+  attr_accessor :encoding
+  attr_accessor :exclude_columns
+  attr_accessor :fuzz_intensity
+  attr_accessor :message
+  attr_accessor :persist
+  attr_accessor :source_env
+  attr_accessor :tables
+  attr_accessor :target_env
+  attr_accessor :where
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+
+  def initialize
+    @actions = [ ]
+    @tables = [ ]
+    @exclude_columns = [ ]
+    @fuzz_intensity = 1
+    @block_size = 10000
+
+    yield(self) if (block_given?)
+  end
+
+  def persist?
+    !!@persist
+  end
+
+  def complete?
+    !!@complete
+  end
+
+  def debug_queries?
+    !!@debug_queries
+  end
+end

data/tableflip.gemspec

@@ -0,0 +1,70 @@
+# 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 = "tableflip"
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Scott Tadman"]
+  s.date = "2013-07-29"
+  s.description = "Flips tables from one database to another"
+  s.email = "scott@twg.ca"
+  s.executables = ["tableflip"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/tableflip",
+    "lib/tableflip.rb",
+    "lib/tableflip/argument_parser.rb",
+    "lib/tableflip/database_handle.rb",
+    "lib/tableflip/executor.rb",
+    "lib/tableflip/strategy.rb",
+    "tableflip.gemspec",
+    "test/config/.gitignore",
+    "test/helper.rb",
+    "test/unit/test_tableflip.rb",
+    "test/unit/test_tableflip_argument_parser.rb",
+    "test/unit/test_tableflip_strategy.rb"
+  ]
+  s.homepage = "http://github.com/twg/tableflip"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "MySQL Table Flipping System"
+
+  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<mysql2>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+      s.add_runtime_dependency(%q<em-synchrony>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.8.4"])
+    else
+      s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, [">= 0"])
+      s.add_dependency(%q<em-synchrony>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.8.4"])
+    end
+  else
+    s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, [">= 0"])
+    s.add_dependency(%q<em-synchrony>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.8.4"])
+  end
+end
+

data/test/config/.gitignore

@@ -0,0 +1,2 @@
+database.yml
+

data/test/helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'tableflip'
+
+class Test::Unit::TestCase
+end

data/test/unit/test_tableflip.rb

@@ -0,0 +1,7 @@
+require_relative '../helper'
+
+class TestTableflip < Test::Unit::TestCase
+  def test_module
+    assert Tableflip
+  end
+end

data/test/unit/test_tableflip_argument_parser.rb

@@ -0,0 +1,40 @@
+require_relative '../helper'
+
+class TestTableflipArgumentParser < Test::Unit::TestCase
+  def test_default_env
+    assert_equal 'test', Tableflip::ArgumentParser.default_env('RAILS_ENV' => 'test')
+  end
+
+  def test_defaults
+    strategy = Tableflip::ArgumentParser.new.parse([ ])
+
+    assert_equal Tableflip::ArgumentParser.default_env, strategy.source_env
+  end
+
+  def test_defaults_with_env
+    strategy = Tableflip::ArgumentParser.new.parse([ ], 'RAILS_ENV' => 'test')
+
+    assert_equal 'test', strategy.source_env
+  end
+
+  def test_help
+    strategy = Tableflip::ArgumentParser.new.parse(%w[ --help ])
+
+    assert strategy.message
+  end
+
+  def test_one_table_one_action
+    strategy = Tableflip::ArgumentParser.new.parse(%w[ --track example_table ])
+
+    assert_equal [ :tracking_add ], strategy.actions
+    assert_equal [ 'example_table' ], strategy.tables
+  end
+
+  def test_one_table_many_actions
+    strategy = Tableflip::ArgumentParser.new.parse(%w[ --track --migrate --target=target_env example_table ])
+
+    assert_equal [ :tracking_add, :table_migrate ], strategy.actions
+    assert_equal [ 'example_table' ], strategy.tables
+    assert_equal 'target_env', strategy.target_env
+  end
+end

data/test/unit/test_tableflip_strategy.rb

@@ -0,0 +1,32 @@
+require_relative '../helper'
+
+class TestTableflipStrategy < Test::Unit::TestCase
+  def test_defaults
+    strategy = Tableflip::Strategy.new
+
+    assert_equal [ ], strategy.actions
+    assert_equal nil, strategy.config_path
+    assert_equal nil, strategy.source_env
+    assert_equal [ ], strategy.tables
+    assert_equal nil, strategy.target_env
+  end
+
+  def test_example
+    strategy = Tableflip::Strategy.new do |strategy|
+      strategy.actions << :test
+
+      strategy.tables << :table_a
+      strategy.tables << :table_b
+
+      strategy.source_env = 'staging'
+      strategy.target_env = 'test'
+    end
+
+    assert_equal [ :test ], strategy.actions
+    assert_equal [ :table_a, :table_b ], strategy.tables
+    assert_equal 'staging', strategy.source_env
+    assert_equal 'test', strategy.target_env
+
+    assert_equal nil, strategy.message
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: tableflip
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Scott Tadman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  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: eventmachine
+  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: em-synchrony
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: Flips tables from one database to another
+email: scott@twg.ca
+executables:
+- tableflip
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/tableflip
+- lib/tableflip.rb
+- lib/tableflip/argument_parser.rb
+- lib/tableflip/database_handle.rb
+- lib/tableflip/executor.rb
+- lib/tableflip/strategy.rb
+- tableflip.gemspec
+- test/config/.gitignore
+- test/helper.rb
+- test/unit/test_tableflip.rb
+- test/unit/test_tableflip_argument_parser.rb
+- test/unit/test_tableflip_strategy.rb
+homepage: http://github.com/twg/tableflip
+licenses:
+- MIT
+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.23
+signing_key: 
+specification_version: 3
+summary: MySQL Table Flipping System
+test_files: []