migratrix 0.8.3 → 0.8.5

data/lib/migratrix.rb

@@ -10,6 +10,7 @@ module Migratrix
   require EXT + 'object_ext'
   require EXT + 'andand'
   require APP + 'exceptions'
+  require APP + 'active_record_migration_helpers'
 
   require APP + 'callbacks'
   require APP + 'loggable'
@@ -20,12 +21,15 @@ module Migratrix
   require APP + 'migratrix'
 
   require APP + 'extractions/extraction'
+  require APP + 'extractions/no_op'
   require APP + 'extractions/active_record'
 
   require APP + 'transforms/transform'
+  require APP + 'transforms/no_op'
   require APP + 'transforms/map'
 
   require APP + 'loads/load'
+  require APP + 'loads/no_op'
   require APP + 'loads/yaml'
 #  require APP + 'loads/csv'
 #  require APP + 'loads/active_record'
@@ -73,11 +77,15 @@ module Migratrix
   # Register in-gem Components
   register_extraction :extraction, Extractions::Extraction
   register_extraction :active_record, Extractions::ActiveRecord
+  register_extraction :no_op, Extractions::NoOp
 
   register_transform :transform, Transforms::Transform
   register_transform :map, Transforms::Map
+  register_transform :no_op, Transforms::NoOp
 
   register_load :load, Loads::Load
+  register_load :no_op, Loads::NoOp
   register_load :yaml, Loads::Yaml
+
 end
 

data/lib/migratrix/active_record_migration_helpers.rb

@@ -1,57 +1,64 @@
+require 'active_support/concern'
+
 module Migratrix
   module ActiveRecordMigrationHelpers
+    extend ActiveSupport::Concern
 
-    # 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
+    module ClassMethods
+      # Executes a query on this class' connection, and logs the query
+      # or an optional message to Migratrix.logger.
+      def execute(query, msg=nil)
+        Migratrix.logger.info(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
+      # 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=nil)
+        table ||= table_name
+        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
+      # 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=nil)
+        table ||= table_name
+        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"} * ", ")
+      # 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)
+        info "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
+        info "Unlocking table '#{table}' and re-enabling indexes..."
+        execute("/*!40000 ALTER TABLE `#{table}` ENABLE KEYS */")
+        execute("UNLOCK TABLES")
       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/extractions/active_record.rb

@@ -2,7 +2,7 @@ module Migratrix
   module Extractions
     # Extraction that expects to be pointed at an ActiveRecord class.
     class ActiveRecord < Extraction
-      set_valid_options :fetchall
+      set_valid_options :fetchall, :includes, :joins
 
       def source=(new_source)
         raise TypeError.new(":source is of type must be an ActiveRecord model class (must inherit from ActiveRecord::Base)") unless is_ar?(new_source)
@@ -15,10 +15,25 @@ module Migratrix
 
       def obtain_source(source, options={})
         raise ExtractionSourceUndefined unless source
-        raise TypeError.new(":source is of type must be an ActiveRecord model class (must inherit from ActiveRecord::Base)") unless is_ar?(source)
         source
       end
 
+      def process_source(source, options={})
+        options = @options.merge(options)
+        source = super source, options
+        source = handle_joins(source, options[:joins]) if options[:joins]
+        source = handle_includes(source, options[:includes]) if options[:includes]
+        source
+      end
+
+      def handle_joins(source, clause)
+        source.joins(clause)
+      end
+
+      def handle_includes(source, clause)
+        source.includes(clause)
+      end
+
       def handle_where(source, clause)
         source.where(clause)
       end
@@ -36,8 +51,33 @@ module Migratrix
       end
 
       # Constructs the query
-      def to_query(source)
-        if source.is_a?(::ActiveRecord::Relation)
+      #
+      # TODO: A bit of a POLS violation here. Let's say you define a
+      # migration class that has an extraction, then instantiate that
+      # migration with m = MyMigration.new(where: 'id=42'). You might
+      # expect to be abe to call m.extractions[:default].to_sql and
+      # get the query, but the reality is that the extraction hasn't
+      # actually seen the migration's options yet. They are passed in
+      # to extract, but not to to_sql. Not sure how to resolve this
+      # cleanly. Some options: 1. have Components know who their
+      # Migration is and ask it for its options (blegh); 2. pass in
+      # options here to to_sql (also blegh, because now end-users have
+      # to know they need to pass in the migration's options to
+      # to_sql); 3. have a proxy method on Migration that essentially
+      # works just like extract, but returns the query instead of the
+      # results. I dislike this mechanism the least but it's still
+      # only applicable to certain subclasses of Extraction so I
+      # hesitate to clutter Migration's API; 4. change
+      # Migration#extractions (et al) so it settles its options with
+      # the component before returning it. This seems like it would
+      # appear the cleanest to the end user but also seems like it
+      # would be excessively magical and a weird source of bugs--eg if
+      # you try to access migration.loads[:cheese] and it crashes
+      # because of an invalid option in loads[:wine].
+      def to_sql(source=nil)
+        source ||= @source
+        source = process_source(obtain_source(source))
+        if source.respond_to? :to_sql
           source.to_sql
         else
           handle_where(source, 1).to_sql
@@ -46,7 +86,7 @@ module Migratrix
 
       def execute_extract(src, options={})
         return src.all if options['fetchall']
-        ret = if src.is_a?(::ActiveRecord::Relation)
+        ret = if src.respond_to? :to_sql
                 src
               else
                 handle_where(src, 1)

data/lib/migratrix/extractions/extraction.rb

@@ -15,6 +15,8 @@ module Migratrix
       end
 
       def extract(options={})
+        options = options.deep_copy
+        options[:where] = Array(options[:where]) + Array(@options[:where])
         options = @options.merge(options).symbolize_keys
 
         # TODO: Raise error if self.abstract? DANGER/NOTE that this is
@@ -22,15 +24,23 @@ module Migratrix
         # extracted to a strategy object.
 
         src = obtain_source(self.source, options)
-        src = handle_where(src, options[:where]) if options[:where]
-        src = handle_order(src, options[:order]) if options[:order]
-        src = handle_limit(src, options[:limit]) if options[:limit]
-        src = handle_offset(src, options[:offset]) if options[:offset]
+        src = process_source(src, options)
         execute_extract(src, options)
       end
 
+      def process_source(source, options)
+        if options[:where]
+          options[:where].each do |where|
+            source = handle_where(source, where)
+          end
+        end
+        source = handle_order(source, options[:order]) if options[:order]
+        source = handle_limit(source, options[:limit]) if options[:limit]
+        source = handle_offset(source, options[:offset]) if options[:offset]
+        source
+      end
 
-    # = extraction filter methods
+      # = extraction filter methods
       #
       # The handle_* methods receive a source and return a source and
       # must be chainable. For example, source might come in as an
@@ -55,28 +65,22 @@ module Migratrix
       end
 
       # Apply where clause to source, return new source.
-      def handle_where(source)
+      def handle_where(source, where)
         raise NotImplementedError
       end
 
       # Apply limit clause to source, return new source.
-      def handle_limit(source)
+      def handle_limit(source, limit)
         raise NotImplementedError
       end
 
       # Apply offset clause to source, return new source.
-      def handle_offset(source)
+      def handle_offset(source, offset)
         raise NotImplementedError
       end
 
       # Apply order clause to source, return new source.
-      def handle_order(source)
-        raise NotImplementedError
-      end
-
-      # Constructs the query, if applicable. May not exist or make
-      # sense for non-SQL and/or non-ActiveRecord extractions.
-      def to_query(source)
+      def handle_order(source, order)
         raise NotImplementedError
       end
 

data/lib/migratrix/extractions/no_op.rb

@@ -0,0 +1,11 @@
+module Migratrix
+  module Extractions
+    # An Extraction object that does nothing. Useful for plugging into
+    # a Migration when you need to debug other parts of the migration
+    class NoOp < Extraction
+      def extract(options={})
+        []
+      end
+    end
+  end
+end

data/lib/migratrix/loads/no_op.rb

@@ -0,0 +1,11 @@
+module Migratrix
+  module Loads
+    # A Load object that does nothing. Useful for plugging into a
+    # Migration when you need to debug other parts of the migration
+    class NoOp < Load
+      def load(transformed_items, options={})
+        []
+      end
+    end
+  end
+end

data/lib/migratrix/migration.rb

@@ -63,7 +63,8 @@ module Migratrix
       extractions[nickname] = Migratrix.extraction(nickname, registered_name, options)
     end
 
-    def self.extend_extraction(nickname, options={})
+    def self.extend_extraction(nickname, options=nil)
+      nickname, options = :default, nickname if options.nil?
       migration = ancestors.detect {|k| k.respond_to?(:extractions) && k.extractions[nickname]}
       raise ExtractionNotDefined.new("Could not extend extraction '%s'; no parent Migration defines it" % nickname) unless migration
       extraction = migration.extractions[nickname]
@@ -104,11 +105,12 @@ module Migratrix
       transforms[nickname] = Migratrix.transform(nickname, registered_name, options)
     end
 
-    def self.extend_transform(transform_name, options={})
-      migration = ancestors.detect {|k| k.respond_to?(:transforms) && k.transforms[transform_name]}
-      raise TransformNotDefined.new("Could not extend extractar '%s'; no parent Migration defines it" % transform_name) unless migration
-      transform = migration.transforms[transform_name]
-      transforms[transform_name] = transform.class.new(transform_name, transform.options.merge(options))
+    def self.extend_transform(nickname, options=nil)
+      nickname, options = :default, nickname if options.nil?
+      migration = ancestors.detect {|k| k.respond_to?(:transforms) && k.transforms[nickname]}
+      raise TransformNotDefined.new("Could not extend transform '%s'; no parent Migration defines it" % nickname) unless migration
+      transform = migration.transforms[nickname]
+      transforms[nickname] = transform.class.new(nickname, transform.options.merge(options))
     end
 
     def self.transforms
@@ -149,11 +151,12 @@ module Migratrix
 #       loads[name] = Migratrix.load(name, type, options)
 #     end
 
-    def self.extend_load(load_name, options={})
-      migration = ancestors.detect {|k| k.respond_to?(:loads) && k.loads[load_name]}
-      raise LoadNotDefined.new("Could not extend extractar '%s'; no parent Migration defines it" % load_name) unless migration
-      load = migration.loads[load_name]
-      loads[load_name] = load.class.new(load_name, load.options.merge(options))
+    def self.extend_load(nickname, options=nil)
+      nickname, options = :default, nickname if options.nil?
+      migration = ancestors.detect {|k| k.respond_to?(:loads) && k.loads[nickname]}
+      raise LoadNotDefined.new("Could not extend load '%s'; no parent Migration defines it" % nickname) unless migration
+      load = migration.loads[nickname]
+      loads[nickname] = load.class.new(nickname, load.options.merge(options))
     end
 
     def self.loads

data/lib/migratrix/transforms/no_op.rb

@@ -0,0 +1,11 @@
+module Migratrix
+  module Transforms
+    # A Transform object that does nothing. Useful for plugging into a
+    # Migration when you need to debug other parts of the migration
+    class NoOp < Transform
+      def transform(extracted_items, options={})
+        []
+      end
+    end
+  end
+end

data/lib/migratrix/transforms/transform.rb

@@ -226,14 +226,18 @@ module Migratrix
 
       def extract_attribute(object, attribute_or_extract)
         raise NotImplementedError unless options[:extract_attribute]
-        option = options[:extract_attribute]
-        case option
-        when Proc
-          option.call(object, attribute_or_extract)
-        when Symbol
-          object.send(option, attribute_or_extract)
+        if attribute_or_extract.is_a? Proc
+          attribute_or_extract.call(object)
         else
-          raise TypeError
+          option = options[:extract_attribute]
+          case option
+          when Proc
+            option.call(object, attribute_or_extract)
+          when Symbol
+            object.send(option, attribute_or_extract)
+          else
+            raise TypeError
+          end
         end
       end
 

data/lib/patches/object_ext.rb

@@ -1,6 +1,22 @@
 class Object
+  # Make a deep copy of an object as safely as possible. This was
+  # originally a simple Marshal::load(Marshal::dump(self)) but it
+  # turns out in Migratrix that we frequently need to copy IO streams
+  # and lambdas, neither of which can be marshaled. Then it was a
+  # simple dup, but some singleton types like Fixnum cannot be dup'ed.
+  # So now we have this monstrosity.
   def deep_copy
-    Marshal::load(Marshal::dump(self))
+    if is_a?(Array)
+      map(&:deep_copy)
+    elsif is_a?(Hash)
+      Hash[to_a.map {|k,v| [k, v.deep_copy]}]
+    else
+      begin
+        Marshal::load(Marshal::dump(self))
+      rescue TypeError
+        dup
+      end
+    end
   end
 end
 

data/spec/lib/migratrix/callbacks_spec.rb

@@ -1,5 +1,3 @@
-require 'no_op_components'
-
 class TestCallbackMigration < Migratrix::Migration
   set_extraction :test, :no_op
   set_transform :test, :no_op
@@ -127,9 +125,6 @@ end
 describe "callbacks" do
   describe "sanity check cat" do
     it "is sanity checked" do
-      NoOpExtraction.should_not be_nil
-      NoOpTransform.should_not be_nil
-      NoOpLoad.should_not be_nil
       TestCallbackMigration.should_not be_nil
       MethodCallbackMigration.should_not be_nil
     end

data/spec/lib/migratrix/extractions/active_record_spec.rb

@@ -30,13 +30,13 @@ describe Migratrix::Extractions::ActiveRecord do
 
   describe ".local_valid_options" do
     it "returns the valid set of option keys" do
-      Migratrix::Extractions::ActiveRecord.local_valid_options.should == [:fetchall]
+      Migratrix::Extractions::ActiveRecord.local_valid_options.should == [:fetchall, :includes, :joins]
     end
   end
 
   describe ".valid_options" do
     it "returns the valid set of option keys" do
-      Migratrix::Extractions::ActiveRecord.valid_options.should == [:fetchall] + Migratrix::Extractions::Extraction.valid_options
+      Migratrix::Extractions::ActiveRecord.valid_options.should == [:fetchall, :includes, :joins] + Migratrix::Extractions::Extraction.valid_options
     end
   end
 
@@ -57,7 +57,7 @@ describe Migratrix::Extractions::ActiveRecord do
       extraction.source = source
     end
 
-    [:where, :order, :limit, :offset].each do |handler|
+    [:where, :order, :limit, :offset, :includes, :joins].each do |handler|
       describe "#handle_#{handler}" do
         it "calls #{handler} on the source ActiveRelation" do
           source.should_receive(handler).with(1).and_return(nil)
@@ -67,7 +67,7 @@ describe Migratrix::Extractions::ActiveRecord do
     end
   end
 
-  describe "#to_query" do
+  describe "#to_sql" do
     let(:source) { TestModel }
     let(:relation) { source.where(1) }
     let(:lolquery) { 'SELECT "HAY GUYZ IM A QUARY LOL"' }
@@ -75,18 +75,27 @@ describe Migratrix::Extractions::ActiveRecord do
       extraction.source = source
     end
 
-    describe "when source is ActiveRecord" do
+    describe "when source does not have to_sql (e.g. is ActiveRecord)" do
       it "converts it to ActiveRelation with where(1)" do
         extraction.should_receive(:handle_where).with(source, 1).and_return(relation)
         relation.should_receive(:to_sql).and_return(lolquery)
-        extraction.to_query(source).should == lolquery
+        extraction.to_sql(source).should == lolquery
       end
     end
 
-    describe "When source has already been converted to ActiveRelation" do
+    describe "When source responds to to_sql (e.g. is already an ActiveRelation)" do
       it "delegates to to_sql on source" do
+        relation.should_receive(:respond_to?).with(:to_sql).and_return(true)
         relation.should_receive(:to_sql).and_return(lolquery)
-        extraction.to_query(relation).should == lolquery
+        extraction.to_sql(relation).should == lolquery
+      end
+    end
+
+    describe "with default source" do
+      it "uses @source" do
+        extraction = Migratrix::Extractions::ActiveRecord.new(:default, source: source)
+        source.should_receive(:to_sql).and_return(lolquery)
+        extraction.to_sql.should == lolquery
       end
     end
   end

data/spec/lib/migratrix/extractions/extraction_spec.rb

@@ -19,10 +19,11 @@ describe Migratrix::Extractions::Extraction do
 
   describe "unimplemented methods:" do
     let(:base_extraction) { Migratrix::Extractions::Extraction.new :test }
-    [:obtain_source, :handle_where, :handle_limit, :handle_offset, :handle_order, :to_query, :execute_extract].each do |method|
+    [:obtain_source, :handle_where, :handle_limit, :handle_offset, :handle_order, :execute_extract].each do |method|
       describe "#{method}" do
         it "raises NotImplementedError" do
-          lambda { base_extraction.send(method, nil) }.should raise_error(NotImplementedError)
+          args = [nil, nil]
+          lambda { base_extraction.send(method, *args) }.should raise_error(NotImplementedError)
         end
       end
     end
@@ -31,17 +32,17 @@ describe Migratrix::Extractions::Extraction do
   describe "#extract (default strategy)" do
     describe "with no options" do
       let(:extraction) { TestExtraction.new :test }
-      it "should call handle_source and execute_extract only" do
-        extraction.should_receive(:obtain_source).with(nil, {}).and_return(13)
-        extraction.should_receive(:execute_extract).with(13, {}).and_return(64)
+      it "calls handle_source and execute_extract only" do
+        extraction.should_receive(:obtain_source).with(nil, {where: []}).and_return(13)
+        extraction.should_receive(:execute_extract).with(13, {where: []}).and_return(64)
         extraction.extract.should == 64
       end
     end
 
     describe "with all options" do
-      let(:options) { { :where => 1, :order => 2, :limit => 3, :offset => 4 } }
+      let(:options) { { :where => [1], :order => 2, :limit => 3, :offset => 4 } }
       let(:extraction) { TestExtraction.new :test, options }
-      it "should call entire handler chain" do
+      it "calls entire handler chain" do
         extraction.should_receive(:obtain_source).with(nil, options).and_return("A")
         extraction.should_receive(:handle_where).with("A", 1).and_return("B")
         extraction.should_receive(:handle_order).with("B", 2).and_return("C")
@@ -53,19 +54,27 @@ describe Migratrix::Extractions::Extraction do
     end
 
     describe "with overridden options" do
-      let(:options) { { :where => 1, :order => 2, :limit => 3, :offset => 4 } }
+      let(:options) { { :where => [1], :order => 2, :limit => 3, :offset => 4 } }
       let(:extraction) { TestExtraction.new :test, options }
-      let(:overrides) { {:where => 5, :order => 6, :limit => 7, :offset => 8 } }
-      it "should call entire handler chain" do
-        extraction.should_receive(:obtain_source).with(nil, overrides).and_return("A")
-        extraction.should_receive(:handle_where).with("A", 5).and_return("B")
+      let(:overrides) { {:where => [5], :order => 6, :limit => 7, :offset => 8 } }
+      let(:merged_options) { {:where => [5, 1], :order => 6, :limit => 7, :offset => 8 } }
+      it "calls entire handler chain, merging where clauses" do
+        extraction.should_receive(:obtain_source).with(nil, merged_options).and_return("A")
+        extraction.should_receive(:handle_where).exactly(2).times.and_return("B")
         extraction.should_receive(:handle_order).with("B", 6).and_return("C")
         extraction.should_receive(:handle_limit).with("C", 7).and_return("D")
         extraction.should_receive(:handle_offset).with("D", 8).and_return("E")
-        extraction.should_receive(:execute_extract).with("E", overrides).and_return("BONG")
+        extraction.should_receive(:execute_extract).with("E", merged_options).and_return("BONG")
         extraction.extract(overrides).should == "BONG"
       end
     end
+
+    describe "with where clause" do
+      let(:options) { { :where => 1, :order => 2, :limit => 3, :offset => 4 } }
+      let(:extraction) { TestExtraction.new :test, options }
+      it "promotes where clause to array" do
+      end
+    end
   end
 end
 

data/spec/lib/migratrix/migration_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'no_op_components'
 require 'test_migration'
 require 'inherited_migrations'
 
@@ -193,7 +192,7 @@ describe Migratrix::Migration do
         describe "#{component}" do
           it "extends the #{component} to child class" do
             ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2 })
-            ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100'}
+            ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100' }
           end
 
           it "extends the #{component} to the grandchild class" do

data/spec/spec_helper.rb

@@ -24,13 +24,12 @@ module Rails
   end
 end
 
-Dir[SPEC + "support/**/*.rb"].each {|f| require f}
-
 require LIB + 'migratrix'
-
 $:.unshift SPEC + "fixtures/migrations/"
 $:.unshift SPEC + "fixtures/components/"
 
+Dir[SPEC + "support/**/*.rb"].each {|f| require f}
+
 
 # Redirect singleton logger to logger of our choice, then release it
 # after the spec finishes or crashes.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: migratrix
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-26 00:00:00.000000000Z
+date: 2011-10-31 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
-  requirement: &2161676040 !ruby/object:Gem::Requirement
+  requirement: &2164754380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2161676040
+  version_requirements: *2164754380
 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
@@ -41,7 +41,9 @@ files:
 - lib/migratrix/exceptions.rb
 - lib/migratrix/extractions/active_record.rb
 - lib/migratrix/extractions/extraction.rb
+- lib/migratrix/extractions/no_op.rb
 - lib/migratrix/loads/load.rb
+- lib/migratrix/loads/no_op.rb
 - lib/migratrix/loads/yaml.rb
 - lib/migratrix/loggable.rb
 - lib/migratrix/migration.rb
@@ -49,12 +51,12 @@ files:
 - lib/migratrix/migratrix.rb
 - lib/migratrix/registry.rb
 - lib/migratrix/transforms/map.rb
+- lib/migratrix/transforms/no_op.rb
 - lib/migratrix/transforms/transform.rb
 - lib/migratrix/valid_options.rb
 - lib/patches/andand.rb
 - lib/patches/object_ext.rb
 - lib/patches/string_ext.rb
-- spec/fixtures/components/no_op_components.rb
 - spec/fixtures/migrations/inherited_migrations.rb
 - spec/fixtures/migrations/test_migration.rb
 - spec/lib/migratrix/_loggable_spec.rb

data/spec/fixtures/components/no_op_components.rb

@@ -1,22 +0,0 @@
-class NoOpExtraction < Migratrix::Extractions::Extraction
-  def extract(options={})
-    []
-  end
-end
-
-class NoOpTransform < Migratrix::Transforms::Transform
-  def transform(exts, options={})
-    []
-  end
-end
-
-class NoOpLoad < Migratrix::Loads::Load
-  def load(trans, options={})
-    []
-  end
-end
-
-Migratrix::Migratrix.register_extraction :no_op, NoOpExtraction
-Migratrix::Migratrix.register_transform :no_op, NoOpTransform
-Migratrix::Migratrix.register_load :no_op, NoOpLoad
-