migratrix 0.0.5

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2009 David Brady github@shinybit.com
+ 
+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,144 @@
+# Migratrix
+
+Dominate your legacy Rails migrations! Migratrix is a gem to help you
+generate and control Migrations, which extract data from legacy systems
+and import them into your current one.
+
+## Warning: Experimental Developmental In-Progress Stuff
+
+I am currently extracting Migratrix from an ancient legacy codebase.
+(Oh the irony.) A lot of the stuff I say Migratrix supports is stuff
+that it supports over there, not in here. Be aware that most of this
+document is more of a TODO list than a statement of fact. I'll remove
+this message once Migratrix does what it says on the tin.
+
+## General Info
+
+Migratrix is a legacy migration tool strategy
+
+## Motivation
+
+So... much... legacy... data....
+
+## Rails and Ruby Requirements
+
+### Rails 3 Only
+
+Migratrix was originally developed under Rails 2, but come on. Rails 2
+apps are legacy SOURCES now, not destinations. Migratrix requires
+Rails 3. Once everything's in place I'll bump the Migratrix version to
+3.x to indicate that Migratrix is in keeping with Rails 3.
+
+### Ruby 1.9
+
+Because I can.
+
+## Example
+
+## ETL
+
+I use the term "ETL" here in a loosely similar mechanism as in data
+warehousing: Extract, Transform and Load. Migratrix approaches
+migrations in three phases:
+
+* **Extract** The Migration obtains the legacy data from 1 or more
+    sources
+    
+* **Transform** The Migration transforms the data into 1 or more
+    outputs
+    
+* **Load** The Migration saves the data into the new database or other
+    output(s)
+    
+
+## Migration Dependencies
+
+Migratrix isn't quite smart enough to know that a migrator depends on
+another migrator. (Actually, that's easy. What's hard is knowing if a
+dependent migrator has run and is up-to-date.)
+
+## Strategies
+
+Migratrix supports multiple migration strategies:
+
+* Straight up ActiveRecord: Given a model class (probably connected to
+  a legacy database), a mapping transform and a destination model,
+  Migratrix extracts the source models, transforms them and saves
+  them. (In Rails 2 this was sometimes dangerous because the entire
+  source table(s) would be loaded into memory during the Extract
+  phase. In Rails 3 this is no longer a problem, somewhat reducing the
+  motivation for the next strategy.)
+
+* Batch Select: Given a SQL query as the extraction source, a
+  Migration can pull batches of hashes from the legacy database. You
+  give up having legacy model objects in exchange for being able to
+  scan massive tables in batches of 1000 or more (or less). In Rails 3
+  this is less of a motivation. However, for complicated source
+  extractions where a source model does not make sense, this strategy
+  is still excellent.
+
+* Pure SQL: If both databases are on the same server, you can often
+  migrate data with a +SELECT INTO+ or +INSERT SELECT+ statement. This
+  is one of the fastest ways to migrate data because the data never
+  comes up into the ruby data space. On the other hand, the migration
+  may be more complicated to write because the data can be manipulated
+  by ruby--the entire ETL must be handled by the single SQL statement.
+  Additionally, it is seriously nontrivial to log the migrated records
+  because you have to handle that at the SQL level as well.
+
+## Slices of Data
+
+Migratrix supports taking partial slices of data. You can migrate a
+single record to test a migraton, grab 100 records or 1000 to get an
+idea for how long a full migration will take, or perform the entire
+migration.
+
+## Ongoing Migrations
+
+Migratrix also supports ongoing migrations, which are useful when the
+legacy database continues to operate and change after the new Rails
+site is live and you cannot remigrate all-new data.
+
+## Migration Log
+
+Migratrix can create a migration log for you. This is a table that
+contains the legacy id and table, and the destination id and table. It
+can also record the source object, which is useful for debugging or
+handling migration cases where legacy records get changed or deleted
+after migrating.
+
+## Migration Tests
+
+Sorry, nothing to see here yet. Migratrix was originally developed in
+an environment where the migrations were so heavy-duty and hairy that
+we literally had `legacy_migration_test` and
+`legacy_migration_development` databases for migration development.
+Migratrix doesn't directly support testing of migrations yet. This is
+mostly a note to remind myself that that heavy-duty migrations can and
+should be developed in a TDD style, and Migratrix should make this
+easy.
+
+## A note about the name
+
+In old Latin, -or versus -ix endings aren't just about feminine and
+masculine. Like old Greek's -a versus -os endings, a masculine ending
+usually refers to a small, single instance of a thing while the
+feminine refers to the large or collective instance. For example, in
+Greek, the masculine word _petros_ means "stone" or "pebble" while the
+feminine word _petra_ means "bedrock". More poetically, the feminine
+can sometimes be viewed not as a gender mirror, but maternally
+instead: the bedrock is what creates or gives birth to stones and
+pebbles.
+
+Hence Migratrix is the gem that helps you generate and control your
+Migrations, while Migration is the class that defines how a single
+set of data, such as a table, a set of models, etc., is migrated.
+
+## License
+
+MIT. See the license file.
+
+## Authors
+
+* David Brady -- github@shinybit.com
+

data/bin/migratrix

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts "Nothing to see here yet -- use rake tasks to call Migratrix.migrate!(:migrator, options) directly"

data/lib/migratrix/active_record_migration_helpers.rb

@@ -0,0 +1,57 @@
+module Migratrix
+  module ActiveRecordMigrationHelpers
+
+    # Executes a query on this class' connection, and logs the query
+    # or an optional message to Migratrix.log.
+    def execute(query, msg=nil)
+      Migratrix.log(msg || query) unless msg == false
+      connection.execute query
+    end
+
+    # MySQL ONLY: truncates a table using TRUNCATE, which drops the
+    # data very quickly and resets any autoindexing primary key to 1.
+    def mysql_truncate(table)
+      execute("TRUNCATE #{table}")
+    end
+
+    # PostGreSQL ONLY: truncates a table by deleting all its rows and
+    # restarting its id sequence at 1.
+    #
+    # Note: TRUNCATE was added to PostGreSQL in version 8.3, which at
+    # the time of this writing is still poorly adopted. This code
+    # works on earlier versions, is MVCC-safe, and will trigger
+    # cascading deletes.
+    #
+    # It does NOT, however, actually look up the table's sequence
+    # definition. It assumes the sequence for a is named a_id_seq and
+    # that it should be reset to 1. (A tiny dash of extra cleverness
+    # is all that would be needed to read start_value from the
+    # sequence, but for now this is a pure-SQL, stateless call.)
+    def psql_truncate(table)
+      execute("DELETE FROM #{table}; ALTER SEQUENCE #{table}_id_seq RESTART WITH 1")
+    end
+
+    # MySQL ONLY: Disables indexes on a table and locks it for
+    # writing, optionally read-locks another list of tables, then
+    # yields to the given block before unlocking. This prevents MySQL
+    # from indexing the migrated data until the block is complete.
+    # This produces a significant speedup on InnoDB tables with
+    # multiple indexes. (The plural of anecdote is not data, but on
+    # one heavily-indexed table, migrating 10 million records took 38
+    # hours with indexes enabled and under 2 hours with them
+    # disabled.)
+    def with_mysql_indexes_disabled_on(table, *read_locked_tables, &block)
+      log "Locking table '#{table}' and disabling indexes..."
+      lock_cmd = "LOCK TABLES `#{table}` WRITE"
+      if read_locked_tables.andand.size > 0
+        lock_cmd += ', ' + (read_locked_tables.map {|t| "#{t} READ"} * ", ")
+      end
+      execute lock_cmd
+      execute("/*!40000 ALTER TABLE `#{table}` DISABLE KEYS */")
+      yield
+      log "Unlocking table '#{table}' and re-enabling indexes..."
+      execute("/*!40000 ALTER TABLE `#{table}` ENABLE KEYS */")
+      execute("UNLOCK TABLES")
+    end
+  end
+end

data/lib/migratrix/exceptions.rb

@@ -0,0 +1,8 @@
+module Migratrix
+  # ----------------------------------------------------------------------
+  # Exceptions
+  class MigrationAlreadyExists < Exception; end
+  class MigrationFileNotFound < Exception; end
+  class MigrationNotDefined < Exception; end
+end
+

data/lib/migratrix/migration.rb

@@ -0,0 +1,52 @@
+module Migratrix
+  # Superclass for all migrations. Migratrix COULD check to see that a
+  # loaded migration inherits from this class, but hey, duck typing.
+  class Migration
+    attr_accessor :options, :logger
+
+    def initialize(options={})
+      # cannot make a deep copy of an IO stream (e.g. logger) so make a shallow copy of it and move it out of the way
+      @options = options.dup.tap {|h| @logger = h.delete("logger")}.deep_copy
+
+#       if options["logger"]
+#         @logger = options["logger"]
+#         options = options.dup
+#         options.delete["logger"]
+#       end
+#       @options = options.deep_copy
+      # This should only be loaded if a) the Migration uses the AR
+      # extract strategy and b) it's not already loaded
+#      ::ActiveRecord::Base.send(:include, MigrationHelpers) unless ::ActiveRecord::Base.const_defined?("MigrationHelpers")
+    end
+
+    # Load this data from source
+    def extract
+      # run the chain of extractions
+    end
+
+    # Transforms source data into outputs
+    def transform
+      # run the chain of transforms
+    end
+
+    # Saves the migrated data by "loading" it into our database or
+    # other data sink.
+    def load
+      # run the chain of loads
+    end
+
+    # Perform the migration
+    def migrate
+      extract
+      transform
+      load
+    end
+
+    def self.log(msg="", level=:info)
+      return unless logger
+      level = :info unless level.in? [:debug, :info, :warn, :error, :fatal, :unknown]
+      logger.send level, "#{Time.now.strftime('%T')}: #{msg}"
+    end
+  end
+end
+

data/lib/migratrix/migratrix.rb

@@ -0,0 +1,98 @@
+# Main "App" or Driver class for Migrating. Responsible for loading
+# and integrating all the parts of a migration.
+
+module Migratrix
+
+  def migrate(name, options={})
+    ::Migratrix::Migratrix.migrate(name, options)
+  end
+
+  class Migratrix
+    def self.migrate(name, options={})
+      migratrix = self.new()
+      migration = migratrix.create_migration(name, options)
+      migration.migrate
+      migratrix
+    end
+
+    # Loads #{name}_migration.rb from migrations path, instantiates
+    # #{Name}Migration with options, and returns it.
+    def create_migration(name, options={})
+      options = filter_options(options)
+      klass_name = migration_name(name)
+      unless loaded?(klass_name)
+        raise MigrationAlreadyExists.new("Migratrix cannot instantiate class Migratrix::#{klass_name} because it already exists") if ::Migratrix.const_defined?(klass_name)
+        filename = migrations_path + "#{name}_migration.rb"
+        raise MigrationFileNotFound.new("Migratrix cannot find migration file #{filename}") unless File.exists?(filename)
+        load filename
+        raise MigrationNotDefined.new("Expected migration file #{filename} to define Migratrix::#{klass_name} but it did not") unless ::Migratrix.const_defined?(klass_name)
+        register_migration(klass_name, "Migratrix::#{klass_name}".constantize)
+      end
+      fetch_migration(klass_name).new(options)
+    end
+
+    def migration_name(name)
+      name = name.to_s
+      name = if name.plural?
+               name.classify.pluralize
+             else
+               name.classify
+             end
+      name + "Migration"
+    end
+
+    def filter_options(hash)
+      Hash[valid_options.map {|v| hash.key?(v) ? [v, hash[v]] : nil }.compact]
+    end
+
+    def valid_options
+      %w(limit where logger)
+    end
+
+    # ----------------------------------------------------------------------
+    # Candidate for exract class? MigrationRegistry?
+    def loaded?(name)
+      registered_migrations.key? name.to_s
+    end
+
+    def register_migration(name, klass)
+      registered_migrations[name.to_s] = klass
+    end
+
+    def fetch_migration(name)
+      registered_migrations.fetch name.to_s
+    end
+
+    def registered_migrations
+      @registered_migrations ||= {}
+    end
+    # End MigrationRegistry
+    # ----------------------------------------------------------------------
+
+    # ----------------------------------------------------------------------
+    # Migration path class accessors. Defaults to lib/migrations.
+    def migrations_path
+      @migrations_path ||= ::Migratrix::DEFAULT_MIGRATIONS_PATH
+    end
+
+    def migrations_path=(new_path)
+      @migrations_path = Pathname.new new_path
+    end
+
+#     def self.migrations_path
+#       @@migrations_path ||= ::Migratrix::DEFAULT_MIGRATIONS_PATH
+#     end
+
+#     def self.migrations_path=(new_path)
+#       @@migrations_path = Pathname.new new_path
+#     end
+    # End Migration path management
+    # ----------------------------------------------------------------------
+
+#     def self.log(msg="", level=:info)
+#       return if quiet
+#       level = :info unless level.in? [:debug, :info, :warn, :error, :fatal, :unknown]
+#       logger.send level, "#{Time.now.strftime('%T')}: #{msg}"
+#     end
+  end
+end

data/lib/migratrix.rb

@@ -0,0 +1,18 @@
+require 'pathname'
+require 'forwardable'
+
+module Migratrix
+  APP=Pathname.new(__FILE__).dirname + "migratrix"
+  EXT=Pathname.new(__FILE__).dirname + "patches"
+
+  DEFAULT_MIGRATIONS_PATH = Rails.root + 'lib/migrations'
+
+
+  require EXT + 'string_ext'
+  require EXT + 'object_ext'
+  require EXT + 'andand'
+  require APP + 'exceptions'
+  require APP + 'migration'
+  require APP + 'migratrix'
+
+end

data/lib/patches/andand.rb

@@ -0,0 +1,104 @@
+=begin
+
+This code was hand-patched by David Brady in May 2011 to shut up the
+warning in Ruby 1.9. At the time of this writing there is a
+6-month-old patch for this in Reg's github version of andand but the
+gem still does not support it. This is minor tweak; Reg's copyright
+and license remain unchanged.
+
+Copyright (c) 2008 Reginald Braithwaite
+http://weblog.raganwald.com/2008/01/objectandand-objectme-in-ruby.html
+
+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.
+
+Some code adapted from Jim Weirich's post:
+http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+
+=end
+module AndAnd
+# :nocov:
+
+  module ObjectGoodies
+
+    def andand (p = nil)
+      if self
+        if block_given?
+          yield(self)
+        elsif p
+          p.to_proc.call(self)
+        else
+          self
+        end
+      else
+        if block_given? or p
+          self
+        else
+          MockReturningMe.new(self)
+        end
+      end
+    end
+
+    def me (p = nil)
+      if block_given?
+        yield(self)
+        self
+      elsif p
+        p.to_proc.call(self)
+        self
+      else
+        ProxyReturningMe.new(self)
+      end
+    end
+
+  end
+
+end
+
+class Object
+  include AndAnd::ObjectGoodies
+end
+
+module AndAnd
+
+  class BlankSlate
+    instance_methods.reject { |m| m =~ /^(__|object_id$)/ }.each { |m| undef_method m }
+    def initialize(me)
+      @me = me
+    end
+  end
+
+  class MockReturningMe < BlankSlate
+    def method_missing(*args)
+      @me
+    end
+  end
+
+  class ProxyReturningMe < BlankSlate
+    def method_missing(sym, *args, &block)
+      @me.__send__(sym, *args, &block)
+      @me
+    end
+  end
+#:nocov:
+
+end
+

data/lib/patches/object_ext.rb

@@ -0,0 +1,10 @@
+class Object
+  def in?(array)
+    array.include? self
+  end
+
+  def deep_copy
+    Marshal::load(Marshal::dump(self))
+  end
+end
+

data/lib/patches/string_ext.rb

@@ -0,0 +1,11 @@
+# String extensions
+class String
+  def plural?
+    self != self.singularize
+  end
+
+  def singular?
+    self != self.pluralize
+  end
+end
+

data/spec/fixtures/migrations/marbles_migration.rb

@@ -0,0 +1,17 @@
+module Migratrix
+  # Fake migration fixture for "Marbles"
+  class MarblesMigration < Migration
+    def initialize(options={})
+      super
+      @@migrated = false
+    end
+
+    def migrate
+      @@migrated = true
+    end
+
+    def self.migrated?
+      @@migrated
+    end
+  end
+end

data/spec/lib/migration_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+# This migration is embedded in migration_spec.rb to allow testing of
+# the class methods that specialize subclasses.
+class Migratrix::TestMigration < Migratrix::Migration
+
+end
+
+describe Migratrix::Migration do
+  describe ".new" do
+    it "does not modify given options hash" do
+      conditions = ["id=? AND approved=?", 42, true]
+      migration = Migratrix::TestMigration.new({ "where" => conditions })
+
+      migration.options["where"][0] += " AND pants=?"
+      migration.options["where"] << false
+      migration.options["where"].should == ["id=? AND approved=? AND pants=?", 42, true, false]
+      conditions.should == ["id=? AND approved=?", 42, true]
+    end
+
+    it "safely moves logger option out of its options and into logger attribute" do
+      conditions = ["id=? AND approved=?", 42, true]
+      logger = Logger.new(StringIO.new)
+      options = { "where" => conditions, "logger" => logger }
+
+      migration = Migratrix::TestMigration.new(options)
+
+      migration.options.should_not have_key("logger")
+      migration.logger.should == logger
+      options.should == { "where" => conditions, "logger" => logger }
+    end
+  end
+
+  describe "#migrate" do
+    let(:migration) { Migratrix::TestMigration.new }
+
+    it "delegates to extract, transform, and load" do
+      migration.should_receive(:extract).once
+      migration.should_receive(:transform).once
+      migration.should_receive(:load).once
+      migration.migrate
+    end
+  end
+end
+
+
+

data/spec/lib/migrator_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Migratrix::Migratrix do
+  it "should exist" do
+    Migratrix::Migratrix.should_not be_nil
+  end
+end

data/spec/lib/migratrix_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+# Migatrix loads Migration classes into its namespace. In order to
+# test collision prevention, I needed to reach into Migratrix and
+# mindwipe it of any migrations. Here's the shiv to do that. I
+# originally put an API to do this on Migratrix but these specs are
+# the only clients of it so I removed it again. If you find a
+# legitimate use for it, feel free to re-add a remove_migration
+# method and send me a patch.
+def reset_migratrix!(migratrix)
+  Migratrix.constants.map(&:to_s).select {|m| m =~ /.+Migration$/}.each do |migration|
+    Migratrix.send(:remove_const, migration.to_sym)
+  end
+  migratrix.registered_migrations.clear
+end
+
+describe Migratrix::Migratrix do
+  let (:migratrix) { Migratrix::Migratrix.new }
+
+  it "exists (sanity check)" do
+    Migratrix.should_not be_nil
+    Migratrix.class.should == Module
+    Migratrix.class.should_not == Class
+    Migratrix::Migratrix.class.should_not == Module
+    Migratrix::Migratrix.class.should == Class
+    Migratrix.const_defined?("Migratrix").should be_true
+  end
+
+  describe "MigrationRegistry (needs to be extracted)" do
+    before do
+      reset_migratrix! migratrix
+      Migratrix.class_eval("class PantsMigration < Migration; end")
+      migratrix.register_migration "PantsMigration", Migratrix::PantsMigration
+    end
+
+    it "can register migrations by name" do
+      migratrix.loaded?("PantsMigration").should be_true
+      Migratrix.const_defined?("PantsMigration").should be_true
+    end
+
+    it "can fetch registered migration class" do
+      migratrix.fetch_migration("PantsMigration").should == Migratrix::PantsMigration
+    end
+
+    it "raises fetch error when fetching unregistered migration" do
+      lambda { migratrix.fetch_migration("arglebargle") }.should raise_error(KeyError)
+    end
+  end
+
+  describe ".migrations_path" do
+    it "uses ./lib/migrations by default" do
+      migratrix.migrations_path.should == ROOT + "lib/migrations"
+    end
+
+    it "can be overridden" do
+      migratrix.migrations_path = Pathname.new('/tmp')
+      migratrix.migrations_path.should == Pathname.new("/tmp")
+    end
+  end
+
+  describe "#valid_options" do
+    it "returns the valid set of option keys" do
+      migratrix.valid_options.should == ["limit", "where", "logger"]
+    end
+  end
+
+  describe "#filter_options" do
+    it "filters out invalid options" do
+      options = migratrix.filter_options({ "pants" => 42, "limit" => 3})
+      options["limit"].should == 3
+      options.should_not have_key("pants")
+    end
+  end
+
+  describe "#migration_name" do
+    it "classifies the name and adds Migration" do
+      migratrix.migration_name("shirt").should == "ShirtMigration"
+    end
+
+    it "handles symbols" do
+      migratrix.migration_name(:socks).should == "SocksMigration"
+    end
+
+    it "preserves pluralization" do
+      migratrix.migration_name(:pants).should == "PantsMigration"
+      migratrix.migration_name(:shirts).should == "ShirtsMigration"
+    end
+  end
+
+  describe "#create_migration" do
+    before do
+      reset_migratrix! migratrix
+      migratrix.migrations_path = SPEC + "fixtures/migrations"
+    end
+
+    it "creates new migration by name with filtered options" do
+      migration = migratrix.create_migration :marbles, { "cheese" => 42, "where" => "id > 100", "limit" => "100" }
+      migration.class.should == Migratrix::MarblesMigration
+      Migratrix::MarblesMigration.should_not be_migrated
+      migration.options.should == { "where" => "id > 100", "limit" => "100" }
+    end
+  end
+
+  describe ".migrate" do
+    before do
+      reset_migratrix! migratrix
+      migratrix.migrations_path = SPEC + "fixtures/migrations"
+    end
+
+    it "loads migration and migrates it" do
+      Migratrix::Migratrix.stub!(:new).and_return(migratrix)
+      Migratrix::Migratrix.migrate :marbles
+      Migratrix::MarblesMigration.should be_migrated
+    end
+  end
+end
+

data/spec/patches/object_ext_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe String do
+  describe "#plural?" do
+    it "identifies plural strings" do
+      "shirts".should be_plural
+    end
+
+    it "identifies collectively plural strings" do
+      "people".should be_plural
+    end
+
+    it "ignores singular strings" do
+      "sock".should_not be_plural
+    end
+  end
+
+  describe "#singular?" do
+    it "identifies singular strings" do
+      "shirt".should be_singular
+    end
+
+    it "identifies collectively plural strings as singular" do
+      "person".should be_singular
+    end
+
+    it "ignores plural strings" do
+      "socks".should_not be_singular
+    end
+  end
+end

data/spec/patches/string_ext_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Object do
+  describe "#in?" do
+    it "returns true if object is included in collection" do
+      3.should be_in([1,2,3,4])
+      "sexy".should be_in("dylsexyc")
+    end
+  end
+
+  describe "#deep_copy" do
+    let(:ray) { [1,2,3]}
+    let(:hash) { {a: 42, b: 69, c: 13, d: 64} }
+    let(:struct) { Struct.new(:array, :hash).new(ray, hash)}
+    let(:big_hash) { {:struct1 => struct, :struct2 => struct, :hash => hash, :array => ray }}
+
+    describe "sanity check" do
+      it "should have objects correctly aliased" do
+        big_hash[:struct1].object_id.should == big_hash[:struct2].object_id
+      end
+    end
+
+#     it "returns a completely cloned, fully deep copy of the object" do
+#     end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'pathname'
+require 'ruby-debug'
+require 'rails'
+require 'logger'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+SPEC = Pathname.new(__FILE__).dirname
+ROOT = SPEC + ".."
+LIB = ROOT + "lib"
+
+# Rails is loaded but not actually started. Let's keep it that way as
+# much as possible. But we DO need Rails.root, so:
+module Rails
+  def self.root
+    ROOT
+  end
+end
+
+Dir[SPEC + "support/**/*.rb"].each {|f| require f}
+
+require LIB + 'migratrix'
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+end
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: migratrix
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- David Brady
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &2153520180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153520180
+description: Migratrix, a Rails legacy database migration tool supporting multiple
+  strategies, including arbitrary n-ary migrations (1->n, n->1, n->m), arbitrary inputs
+  and outputs (ActiveRecord, bare SQL, CSV) and migration logging
+email: github@shinybit.com
+executables:
+- migratrix
+extensions: []
+extra_rdoc_files:
+- README.md
+- MIT-LICENSE
+files:
+- README.md
+- bin/migratrix
+- lib/migratrix.rb
+- lib/migratrix/active_record_migration_helpers.rb
+- lib/migratrix/exceptions.rb
+- lib/migratrix/migration.rb
+- lib/migratrix/migratrix.rb
+- lib/patches/andand.rb
+- lib/patches/object_ext.rb
+- lib/patches/string_ext.rb
+- spec/fixtures/migrations/marbles_migration.rb
+- spec/lib/migration_spec.rb
+- spec/lib/migrator_spec.rb
+- spec/lib/migratrix_spec.rb
+- spec/patches/object_ext_spec.rb
+- spec/patches/string_ext_spec.rb
+- spec/spec_helper.rb
+- MIT-LICENSE
+homepage: http://github.com/dbrady/migratrix/
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --main
+- README.md
+- --title
+- Migratrix - Rails migrations made less icky
+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.6
+signing_key: 
+specification_version: 3
+summary: Rails 3 legacy database migratrion tool supporting multiple strategies
+test_files: []