wyrm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc95033a6576cd33f78d345b18f08564317c0bc1
+  data.tar.gz: 2c046fa329dc3cef258d1185ab390b3106e9fc1a
+SHA512:
+  metadata.gz: 07a728780ea1121ca6784ef83059a0fad6c5218c793d3a8e5033203a6ba60fb435587c1e65f5ff1e3a184a18a2d6ad87c4bf1b2a1e300bc056ded1662ff4f225
+  data.tar.gz: 94a9579c0070a612439a428e4379874671b4aee41d89bb1bb7c6e1a930838fa278f7a178435fc41a6e3cbf8ad98d16824c168f1e8edcc33576d158b92e206a2f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm 2.0.0@wyrm --create

data/Gemfile

@@ -0,0 +1,8 @@
+# source 'https://rubygems.org'
+source 'file:///var/cache/rubygems'
+
+gem 'sequel'
+gem 'fastandand'
+
+# Specify your gem's dependencies in wyrm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 John Anderson
+
+MIT License
+
+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,71 @@
+# Wyrm
+
+Transfer data from one database to another. Has been used to dump > 100M dbs,
+and one 850G db. Should theoretically work for any dbs supported by Sequel.
+
+Currently transfers tables and views only. Does not attempt to transfer
+stored procs, permissions, triggers etc.
+
+Works best for tables that have single numeric primary keys, but should also
+handle compound primary keys and tables without primary keys.
+
+Wyrm because:
+
+- I like dragons
+- I can have a Wyrm::Hole to transfer data through :-D
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wyrm'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wyrm
+
+Make sure you install the db gems, typically
+
+    $ gem install pg mysql2
+
+## Usage
+
+This is mostly a toolkit right now. To transfer from mysql to postgres do:
+```ruby
+require 'sequel'
+require 'pathname'
+
+# on the source host
+# dump tables from mysql
+require 'gbump/dump_schema'
+src_db = Sequel.connect "mysql2://localhost/lots"
+ds = DumpSchema.new src_db, Pathname('/tmp/lots')
+ds.dump_schema
+
+# this might take a while ;-)
+ds.dump_tables
+
+# transfer data. Already compressed, so no -z
+# rsync -var /tmp/lots user@host:/var/data/
+
+# on the destination host
+# restore tables to postgres
+require 'gbump/restore_schema'
+dst_db = Sequel.connect "postgres://localhost/lots"
+rs = RestoreSchema.new dst_db, Pathname('/var/data/lots')
+rs.create
+rs.restore_tables
+rs.index
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/wyrm.rb

@@ -0,0 +1,8 @@
+require "wyrm/version"
+require "wyrm/db_pump.rb"
+require "wyrm/restore_schema.rb"
+require "wyrm/dump_schema.rb"
+
+module Wyrm
+  # Your code goes here...
+end

data/lib/wyrm/db_pump.rb

@@ -0,0 +1,410 @@
+require 'sequel'
+require 'yaml'
+require 'ostruct'
+require 'logger'
+require 'fastandand'
+
+Sequel.extension :migration, :schema_dumper, :pagination
+
+
+# TODO possibly use Gem::Package::TarWriter to write tar files
+# TODO when restoring, could use a SizeQueue to make sure the db is kept busy
+
+# TODO need to version the dumps, or something like that.
+class DbPump
+  class RespondsTo
+    def initialize( *methods )
+      @methods = methods
+    end
+
+    def ===( instance )
+      @methods.all?{|m| instance.respond_to? m}
+    end
+  end
+
+  def initialize( codec = :marshal )
+    @codec =
+    case codec
+    when :yaml; YamlCodec.new
+    when :marshal; MarshalCodec.new
+    when Class
+      codec.new
+    when RespondsTo.new( :encode, :decode )
+      codec
+    else
+      raise "unknown codec #{codec}"
+    end
+  end
+
+  attr_reader :codec
+
+  # TODO could use msgpack as serialization here, but its API is unpleasant.
+
+  class MarshalCodec
+    def encode( obj, io )
+      Marshal.dump obj, io
+    end
+
+    def decode( io, &block )
+      obj = Marshal.load(io)
+      yield obj if block_given?
+      obj
+    end
+  end
+
+  class MsgPackCodec
+    def encode( obj, io )
+      Marshal.dump obj, io
+    end
+
+    def decode( io, &block )
+      obj = Marshal.load(io)
+      yield obj if block_given?
+      obj
+    end
+  end
+
+  class YamlCodec
+    def encode( obj, io )
+      YAML.dump obj, io
+    end
+
+    def decode( io, &block )
+      obj = YAML.load(io)
+      yield obj if block_given?
+      obj
+    end
+  end
+
+  def logger
+    @logger ||= Logger.new STDERR
+  end
+
+  def primary_keys( db, table_name )
+    db.schema(table_name).select{|df| df.last[:primary_key]}.map{|df| df.first}
+  end
+
+  # TODO possibly use select from outer / inner join to
+  # http://www.numerati.com/2012/06/26/reading-large-result-sets-with-hibernate-and-mysql/
+  # because mysql is useless
+  def paginated_dump( table_name, options = {} )
+    options = OpenStruct.new( {io: STDOUT, page_size: 10000, dry_run: false}.merge( options.to_h ) )
+    pk = primary_keys options.db, table_name
+    options.db[table_name].order(*pk).each_page(options[:page_size]) do |page|
+      logger.info page.sql
+      page.each do |row|
+        unless options[:dry_run]
+          codec.encode row.values, options.io
+        end
+      end
+    end
+    options.io.flush
+  end
+
+  # have to use this for non-integer pks
+  # The idea is that large offsets are expensive in the db because the db server has to read
+  # through the data set to reach the required offset. So make that only ids, and then
+  # do the main select from the limited id list.
+  # TODO could speed this up by have a query thread which runs the next page-query while
+  # the current one is being written/compressed.
+  # select * from massive as full
+  #   inner join (select id from massive order by whatever limit m, n) limit
+  #   on full.id = limit.id
+  # order by full.whatever
+  def inner_dump( table_name, options = {} )
+    options = OpenStruct.new( {io: STDOUT, page_size: 10000, dry_run: false}.merge( options.to_h ) )
+    pk = primary_keys options.db, table_name
+
+    table_dataset = options.db[table_name]
+    # could possibly overrride Dataset#paginate(page_no, page_size, record_count=nil)
+    0.step(table_dataset.count, options.page_size).each do |offset|
+      limit_dataset = table_dataset.select( *pk ).limit( options.page_size, offset ).order( *pk )
+      page = table_dataset.join( limit_dataset, Hash[ pk.map{|f| [f,f]} ] ).order( *pk ).qualify_to(table_name)
+      logger.info page.sql
+      page.each do |row|
+        unless options[:dry_run]
+          codec.encode row.values, options.io
+        end
+      end
+    end
+    options.io.flush
+  end
+
+  # TODO need to also dump a first row containing useful stuff:
+  # - source table name
+  # - number of rows
+  # - source db url
+  # - permissions?
+  # These should all be in one object that can be Marshall.load-ed easily.
+  def dump( table_name, options = {} )
+    pk = primary_keys options[:db], table_name
+    case
+    when pk.empty?
+      paginated_dump( table_name, options )
+    when pk.all?{|i| i == :id }
+      min_max_dump( table_name, options )
+    else
+      inner_dump( table_name, options )
+    end
+  end
+
+  # could use this for integer pks
+  def min_max_dump( table_name, options = {} )
+    # select max(id), min(id) from patents
+    # and then split that up into 10000 size chunks. Not really important if there aren't exactly 10000
+    options = OpenStruct.new( {io: STDOUT, page_size: 10000, dry_run: false}.merge( options.to_h ) )
+    pk = primary_keys options.db, table_name
+
+    table_dataset = options.db[table_name]
+    min, max = table_dataset.select{[min(id), max(id)]}.first.values
+    return unless min && max
+    # could possibly overrride Dataset#paginate(page_no, page_size, record_count=nil)
+    # TODO definitely need to refactor this
+
+    # will always include the last item because
+    (min..max).step(options.page_size).each do |offset|
+      page = table_dataset.where( id: offset...(offset+options.page_size) )
+      logger.info page.sql
+      page.each do |row|
+        unless options[:dry_run]
+          codec.encode row.values, options.io
+        end
+      end
+    end
+    options.io.flush
+  end
+
+  # TODO possible memory issues here if the rows are big. May need to fork this.
+  # TODO lazy evaluation
+  def restore( table_name, options = {} )
+    logger.info "restoring #{table_name}"
+    options = OpenStruct.new( {io: STDIN, page_size: 10000, start_row: 0, dry_run: false}.merge( options ) )
+    dataset = options.db[table_name.to_sym]
+    # destination db should be same structure as incoming data
+    column_names = options.db.schema(table_name.to_sym).map( &:first )
+    first = ->(row){raise "schema mismatch" if row.size != column_names.size}
+
+    rows_restored = 0
+
+    # skip this many rows
+    options.start_row.times do
+      codec.decode( options.io ) {|row|}
+    end
+
+    # copy rows into db
+    while !options.io.eof?
+      # fetch a page of rows
+      rows_ary = []
+      begin
+        options.page_size.times do |i|
+          codec.decode( options.io ) do |row|
+            rows_ary << row
+          end
+          rows_restored += 1
+        end
+      rescue EOFError => e
+        # ran out of rows, so just use the ones we have so far
+      end
+
+      # insert to db. Hopeful db support bulk insert, which Sequel will figure out
+      options.db.transaction do
+        dataset.import column_names, rows_ary
+        yield rows_restored if block_given?
+        logger.info "restored #{rows_restored}"
+      end
+    end
+
+    rows_restored
+  end
+
+  def from_bz2( filename, db, table_name, options = {} )
+    IO.popen( "pbzip2 -d -c #{filename}" ) do |io|
+      restore table_name, options.merge( io: io, db: db )
+    end
+  end
+end
+
+# There are actually 2 sources for this:
+# one is the src db, the other is the dumped files
+# And the one that transfers live is another version
+class Schema
+  def initialize( src_db, dst_db = nil )
+    @src_db = src_db
+    @dst_db = dst_db
+  end
+
+  def schema_migration
+    @schema_migration ||= src_db.dump_schema_migration(:indexes=>false, :same_db => same_db)
+  end
+
+  def index_migration
+    @index_migration ||= src_db.dump_indexes_migration(:same_db => same_db)
+  end
+
+  def fk_migration
+    @fk_migration ||= src_db.dump_foreign_key_migration(:same_db => same_db)
+  end
+
+  def restore_migration
+    <<-EOF
+      require 'restore_migration'
+      Sequel.migration do
+        def db_pump
+        end
+
+        up do
+          restore_tables
+        end
+
+        down do
+          # from each table clear table
+          each_table do |table_name|
+            db_pump.restore table_name, io: io, db: db
+          end
+        end
+      end
+    EOF
+  end
+
+  attr_accessor :dst_db
+  attr_reader :src_db
+
+  def same_db
+    @dst_db.andand.database_type == @src_db.andand.database_type
+  end
+
+  def logger
+    @logger ||= Logger.new STDERR
+  end
+
+  # create the destination schema
+  def create
+    eval( @schema_migration ).apply dst_db, :up
+  end
+
+  # create indexes and foreign keys, and reset sequences
+  def index
+    logger.info "creating indexes"
+    eval(@index_migration).apply dst, :up
+    logger.info "creating foreign keys"
+    eval(@fk_migration).apply dst, :up
+
+    if dst.database_type == :postgres
+      logger.info "reset primary key sequences"
+      dst.tables.each{|t| dst.reset_primary_key_sequence(t)}
+      logger.info "Primary key sequences reset successfully"
+    end
+  end
+
+  def transfer_table( table_name, options = {} )
+    options = OpenStruct.new( {page_size: 10000, dry_run: false}.merge( options ) )
+    total_records = @src_db[table_name].count
+    logger.info "transferring #{total_records}"
+    column_names = @src_db.schema(table_name.to_sym).map( &:first )
+
+    @src_db[table_name].each_page(options.page_size) do |page|
+      logger.info "#{page.sql} of #{total_records}"
+      unless options.dry_run
+        @dst_db.transaction do
+          rows_ary = []
+          page.each do |row_hash|
+            rows_ary << row_hash.values
+          end
+          @dst_db[table_name.to_sym].import column_names, rows_ary
+        end
+      end
+    end
+  end
+
+  # copy the data in the tables
+  def transfer
+    create
+    transfer_tables
+    index
+  end
+
+  def dump_schema( container, options = {codec: :marshal} )
+    (container + '001_schema.rb').open('w') do |io|
+      io.write schema_migration
+    end
+
+    (container + '002_populate_tables.rb').open('w') do |io|
+      io.write restore_migration
+    end
+
+    (container + '003_indexes.rb').open('w') do |io|
+      io.write index_migration
+    end
+
+    (container + '004_foreign keys.rb').open('w') do |io|
+      io.write fk_migration
+    end
+  end
+
+  def load_migrations( container )
+    @schema_migration = eval (container + '001_schema.rb').read
+    @index_migration = eval (container + '003_indexes.rb').read
+    @fk_migration = eval (container + '004_foreign keys.rb').read
+  end
+
+  def dump_one_table( table_name, pathname, db_pump )
+    logger.info "dumping #{table_name} to #{pathname}"
+    fio = pathname.open('w')
+    # open subprocess in read-write mode
+    zio = IO.popen( "pbzip2 -z", 'r+' )
+    copier = Thread.new do
+      begin
+        IO.copy_stream zio, fio
+        logger.debug "finished stream copy"
+      ensure
+        fio.close
+      end
+    end
+
+    # generate the dump
+    db_pump.dump table_name, db: src_db, io: zio
+
+    # signal the copier thread to stop
+    zio.close_write
+    logger.debug 'finished dumping'
+    # wait for copier thread to
+    copier.join
+    logger.debug 'stream copy thread finished'
+  ensure
+    zio.close unless zio.closed?
+    fio.close unless fio.closed?
+  end
+
+  def dump_tables( container, options = {:codec => :marshal} )
+    container = Pathname(container)
+    db_pump = DbPump.new( options[:codec] )
+
+    src_db.tables.each do |table_name|
+      filename = container + "#{table_name}.dbp.bz2"
+      dump_one_table table_name, filename, db_pump
+    end
+  end
+
+  def restore_one_table( table_file, db_pump )
+    logger.info "restoring from #{table_file}"
+    table_name = table_file.basename.sub_ext('').sub_ext('').to_s.to_sym
+    # check if table has been restored already, and has the correct rows,
+    # otherwise pass in a start row.
+    db_pump.from_bz2 table_file, dst_db, table_name
+  end
+
+  def restore_tables( container, options = {:codec => :marshal} )
+    db_pump = DbPump.new( options[:codec] )
+    table_files = Pathname.glob Pathname(container) + '*dbp.bz2'
+    table_files.each{|table_file| restore_one_table table_file, db_pump}
+  end
+
+  def restore_tables( container, options = {:codec => :marshal} )
+    container = Pathname(container)
+    container.child ren
+  end
+
+  def self.transfer( src_db, dst_db )
+    new( src_db, dst_db ).transfer
+  end
+end

data/lib/wyrm/dump_schema.rb

@@ -0,0 +1,111 @@
+# Dump a schema and compressed data from a db to a set of files
+#  src_db = Sequel.connect "postgres://localhost:5454/lots"
+#  ds = DumpSchema.new src_db, Pathname('/var/data/lots')
+#  ds.dump_schema
+#  ds.dump_tables
+class DumpSchema
+  def initialize( src_db, container = nil, options = {} )
+    @options = {:codec => :marshal}.merge( options )
+
+    @src_db = src_db
+    @container = Pathname(container)
+  end
+
+  attr_reader :src_db, :container, :codec
+
+  def schema_migration
+    @schema_migration ||= src_db.dump_schema_migration(:indexes=>false, :same_db => same_db)
+  end
+
+  def index_migration
+    @index_migration ||= src_db.dump_indexes_migration(:same_db => same_db)
+  end
+
+  def fk_migration
+    @fk_migration ||= src_db.dump_foreign_key_migration(:same_db => same_db)
+  end
+
+  def restore_migration
+    <<-EOF
+      require 'restore_migration'
+      Sequel.migration do
+        def db_pump
+        end
+
+        up do
+          restore_tables
+        end
+
+        down do
+          # from each table clear table
+          each_table do |table_name|
+            db_pump.restore table_name, io: io, db: db
+          end
+        end
+      end
+    EOF
+  end
+
+  def same_db
+    false
+  end
+
+  def logger
+    @logger ||= Logger.new STDERR
+  end
+
+  def dump_schema
+    (container + '001_schema.rb').open('w') do |io|
+      io.write schema_migration
+    end
+
+    (container + '002_populate_tables.rb').open('w') do |io|
+      io.write restore_migration
+    end
+
+    (container + '003_indexes.rb').open('w') do |io|
+      io.write index_migration
+    end
+
+    (container + '004_foreign keys.rb').open('w') do |io|
+      io.write fk_migration
+    end
+  end
+
+  def dump_one_table( table_name, pathname, db_pump )
+    logger.info "dumping #{table_name} to #{pathname}"
+    fio = pathname.open('w')
+    # open subprocess in read-write mode
+    zio = IO.popen( "pbzip2 -z", 'r+' )
+    copier = Thread.new do
+      begin
+        IO.copy_stream zio, fio
+        logger.debug "finished stream copy"
+      ensure
+        fio.close
+      end
+    end
+
+    # generate the dump
+    db_pump.dump table_name, db: src_db, io: zio
+
+    # signal the copier thread to stop
+    zio.close_write
+    logger.debug 'finished dumping'
+    # wait for copier thread to
+    copier.join
+    logger.debug 'stream copy thread finished'
+  ensure
+    zio.close unless zio.closed?
+    fio.close unless fio.closed?
+  end
+
+  def dump_tables
+    db_pump = DbPump.new( @options[:codec] )
+
+    src_db.tables.each do |table_name|
+      filename = container + "#{table_name}.dbp.bz2"
+      dump_one_table table_name, filename, db_pump
+    end
+  end
+end

data/lib/wyrm/other_schema.rb

@@ -0,0 +1,6 @@
+# Place for stuff that I'm not sure about yet
+class OtherSchema
+  def same_db
+    @dst_db.andand.database_type == @src_db.andand.database_type
+  end
+end

data/lib/wyrm/restore_schema.rb

@@ -0,0 +1,64 @@
+require 'logger'
+
+# Load a schema from a set of dump files (from DumpSchema)
+# and restore the table data
+#  dst_db = Sequel.connect "postgres://localhost:5454/lots"
+#  rs = RestoreSchema.new dst_db, Pathname('/var/data/lots')
+#  rs.create
+#  rs.restore_tables
+class RestoreSchema
+  def initialize( dst_db, container )
+    @container = container
+    @dst_db = dst_db
+    @options = {:codec => :marshal}
+    load_migrations @container
+  end
+
+  attr_reader :dst_db
+  attr_reader :options
+  attr_reader :container
+  attr_reader :schema_migration, :index_migration
+
+  def logger
+    @logger ||= Logger.new STDERR
+  end
+
+  def load_migrations( container )
+    @schema_migration = (container + '001_schema.rb').read
+    @index_migration = (container + '003_indexes.rb').read
+    @fk_migration = (container + '004_foreign keys.rb').read
+  end
+
+  # create indexes and foreign keys, and reset sequences
+  def index
+    logger.info "creating indexes"
+    eval( index_migration ).apply dst_db, :up
+    logger.info "creating foreign keys"
+    eval( fk_migration ).apply dst_db, :up
+
+    if dst_db.database_type == :postgres
+      logger.info "reset primary key sequences"
+      dst_db.tables.each{|t| dst_db.reset_primary_key_sequence(t)}
+      logger.info "Primary key sequences reset successfully"
+    end
+  end
+
+  # create the destination schema
+  def create
+    eval( schema_migration ).apply dst_db, :up
+  end
+
+  def restore_one_table( table_file, db_pump )
+    logger.info "restoring from #{table_file}"
+    table_name = table_file.basename.sub_ext('').sub_ext('').to_s.to_sym
+    # check if table has been restored already, and has the correct rows,
+    # otherwise pass in a start row.
+    db_pump.from_bz2 table_file, dst_db, table_name
+  end
+
+  def restore_tables
+    db_pump = DbPump.new( options[:codec] )
+    table_files = Pathname.glob Pathname(container) + '*dbp.bz2'
+    table_files.sort_by{|tf| tf.stat.size}.each{|table_file| restore_one_table table_file, db_pump}
+  end
+end

data/lib/wyrm/transferer.rb

@@ -0,0 +1,32 @@
+class Transferer
+  def transfer_table( table_name, options = {} )
+    options = OpenStruct.new( {page_size: 10000, dry_run: false}.merge( options ) )
+    total_records = @src_db[table_name].count
+    logger.info "transferring #{total_records}"
+    column_names = @src_db.schema(table_name.to_sym).map( &:first )
+
+    @src_db[table_name].each_page(options.page_size) do |page|
+      logger.info "#{page.sql} of #{total_records}"
+      unless options.dry_run
+        @dst_db.transaction do
+          rows_ary = []
+          page.each do |row_hash|
+            rows_ary << row_hash.values
+          end
+          @dst_db[table_name.to_sym].import column_names, rows_ary
+        end
+      end
+    end
+  end
+
+  # copy the data in the tables
+  def transfer
+    create
+    transfer_tables
+    index
+  end
+
+  def self.transfer( src_db, dst_db )
+    new( src_db, dst_db ).transfer
+  end
+end

data/lib/wyrm/version.rb

@@ -0,0 +1,3 @@
+module Wyrm
+  VERSION = "0.1.0"
+end

data/wyrm.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wyrm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wyrm"
+  spec.version       = Wyrm::VERSION
+  spec.authors       = ["John Anderson"]
+  spec.email         = ["panic@semiosix.com"]
+  spec.description   = %q{Transfer from one SQL database to another}
+  spec.summary       = %q{Transfer from one SQL database to another}
+  spec.homepage      = "http://djellemah.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: wyrm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Transfer from one SQL database to another
+email:
+- panic@semiosix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/wyrm.rb
+- lib/wyrm/db_pump.rb
+- lib/wyrm/dump_schema.rb
+- lib/wyrm/other_schema.rb
+- lib/wyrm/restore_schema.rb
+- lib/wyrm/transferer.rb
+- lib/wyrm/version.rb
+- wyrm.gemspec
+homepage: http://djellemah.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Transfer from one SQL database to another
+test_files: []