migratrix 0.8.2 → 0.8.3

data/lib/migratrix/migration.rb

@@ -45,19 +45,40 @@ module Migratrix
     # TODO: THIS IS HUGE DUPLICATION, REFACTOR REFACTOR REFACTOR
 
     # extraction crap
-    def self.set_extraction(extraction_name, class_name, options={})
-      extractions[extraction_name] = Migratrix.extraction(class_name, extraction_name, options)
+    # set_extraction :nickname, :registered_name, options_hash
+    # set_extraction :nickname, :registered_name # options = {}
+    # set_extraction :registered_name, options_hash # nickname = :default
+    # set_extraction :registered_name # nickname = :default, options={}
+    def self.set_extraction(nickname, registered_name=nil, options=nil)
+      # barf, seriously these args need some detangler.
+      if registered_name.nil?
+        nickname, registered_name, options = :default, nickname, {}
+      elsif options.nil?
+        if registered_name.is_a?(Hash)
+          nickname, registered_name, options = :default, nickname, registered_name
+        else
+          nickname, registered_name, options = nickname, registered_name, {}
+        end
+      end
+      extractions[nickname] = Migratrix.extraction(nickname, registered_name, options)
     end
 
-    def self.extend_extraction(extraction_name, options={})
-      migration = ancestors.detect {|k| k.respond_to?(:extractions) && k.extractions[extraction_name]}
-      raise ExtractionNotDefined.new("Could not extend extractar '%s'; no parent Migration defines it" % extraction_name) unless migration
-      extraction = migration.extractions[extraction_name]
-      extractions[extraction_name] = extraction.class.new(extraction_name, extraction.options.merge(options))
+    def self.extend_extraction(nickname, options={})
+      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]
+      extractions[nickname] = extraction.class.new(nickname, extraction.options.merge(options))
     end
 
     def self.extractions
       @extractions ||= {}
+      ancestry = ancestors.select {|klass| klass != self && klass.respond_to?(:extractions) }.reverse
+      # take oldest ancestor and merge extractions forward
+      ext = {}
+      ancestry.each do |ancestor|
+        ext = ext.merge(ancestor.extractions || {})
+      end
+      @extractions = ext.merge(@extractions)
     end
 
     def extractions
@@ -65,8 +86,22 @@ module Migratrix
     end
 
     # transform crap
-    def self.set_transform(name, type, options={})
-      transforms[name] = Migratrix.transform(name, type, options)
+    # set_transform :nickname, :registered_name, options_hash
+    # set_transform :nickname, :registered_name # options = {}
+    # set_transform :registered_name, options_hash # nickname = :default
+    # set_transform :registered_name # nickname = :default, options={}
+    def self.set_transform(nickname, registered_name=nil, options=nil)
+      # barf, seriously these args need some detangler.
+      if registered_name.nil?
+        nickname, registered_name, options = :default, nickname, {}
+      elsif options.nil?
+        if registered_name.is_a?(Hash)
+          nickname, registered_name, options = :default, nickname, registered_name
+        else
+          nickname, registered_name, options = nickname, registered_name, {}
+        end
+      end
+      transforms[nickname] = Migratrix.transform(nickname, registered_name, options)
     end
 
     def self.extend_transform(transform_name, options={})
@@ -78,6 +113,13 @@ module Migratrix
 
     def self.transforms
       @transforms ||= {}
+      ancestry = ancestors.select {|klass| klass != self && klass.respond_to?(:transforms) }.reverse
+      # take oldest ancestor and merge transforms forward
+      ext = {}
+      ancestry.each do |ancestor|
+        ext = ext.merge(ancestor.transforms || {})
+      end
+      @transforms = ext.merge(@transforms)
     end
 
     def transforms
@@ -85,10 +127,28 @@ module Migratrix
     end
 
     # load crap
-    def self.set_load(name, type, options={})
-      loads[name] = Migratrix.load(name, type, options)
+    # set_load :nickname, :registered_name, options_hash
+    # set_load :nickname, :registered_name # options = {}
+    # set_load :registered_name, options_hash # nickname = :default
+    # set_load :registered_name # nickname = :default, options={}
+    def self.set_load(nickname, registered_name=nil, options=nil)
+      # barf, seriously these args need some detangler.
+      if registered_name.nil?
+        nickname, registered_name, options = :default, nickname, {}
+      elsif options.nil?
+        if registered_name.is_a?(Hash)
+          nickname, registered_name, options = :default, nickname, registered_name
+        else
+          nickname, registered_name, options = nickname, registered_name, {}
+        end
+      end
+      loads[nickname] = Migratrix.load(nickname, registered_name, options)
     end
 
+#     def self.set_load(name, type, options={})
+#       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
@@ -98,6 +158,13 @@ module Migratrix
 
     def self.loads
       @loads ||= {}
+      ancestry = ancestors.select {|klass| klass != self && klass.respond_to?(:loads) }.reverse
+      # take oldest ancestor and merge loads forward
+      ext = {}
+      ancestry.each do |ancestor|
+        ext = ext.merge(ancestor.loads || {})
+      end
+      @loads = ext.merge(@loads)
     end
 
     def loads

data/lib/migratrix/migratrix.rb

@@ -52,12 +52,12 @@ module Migratrix
       registry[:extractions]
     end
 
-    def self.register_extraction(class_name, klass, options={})
-      self.extractions.register(class_name, klass, options)
+    def self.register_extraction(registered_name, klass, options={})
+      self.extractions.register(registered_name, klass, options)
     end
 
-    def self.extraction(class_name, extraction_name, options={})
-      self.extractions.class_for(class_name).new(extraction_name, options)
+    def self.extraction(nickname, registered_name, options={})
+      self.extractions.class_for(registered_name).new(nickname, options)
     end
     # --------------------
 
@@ -71,8 +71,8 @@ module Migratrix
       self.transforms.register(name, klass, options)
     end
 
-    def self.transform(transform_name, class_name, options={})
-      self.transforms.class_for(class_name).new(transform_name, options)
+    def self.transform(nickname, registered_name, options={})
+      self.transforms.class_for(registered_name).new(nickname, options)
     end
     # --------------------
 
@@ -86,8 +86,8 @@ module Migratrix
       self.loads.register(name, klass, options)
     end
 
-    def self.load(load_name, class_name, options={})
-      self.loads.class_for(class_name).new(load_name, options)
+    def self.load(nickname, registered_name, options={})
+      self.loads.class_for(registered_name).new(nickname, options)
     end
     # --------------------
 

data/spec/fixtures/components/no_op_components.rb

@@ -0,0 +1,22 @@
+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
+

data/spec/fixtures/migrations/inherited_migrations.rb

@@ -0,0 +1,11 @@
+require 'test_migration'
+
+class ChildMigration1 < TestMigration
+end
+
+class ChildMigration2 < TestMigration
+end
+
+class GrandchildMigration1 < ChildMigration1
+end
+

data/spec/fixtures/migrations/test_migration.rb

@@ -0,0 +1,3 @@
+class TestMigration < Migratrix::Migration
+end
+

data/spec/lib/migratrix/callbacks_spec.rb

@@ -1,25 +1,4 @@
-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
-
+require 'no_op_components'
 
 class TestCallbackMigration < Migratrix::Migration
   set_extraction :test, :no_op

data/spec/lib/migratrix/migration_spec.rb

@@ -1,18 +1,7 @@
 require 'spec_helper'
-
-# This migration is embedded in migration_spec.rb to allow testing of
-# the class methods that specialize subclasses.
-class TestMigration < Migratrix::Migration
-end
-
-class ChildMigration1 < TestMigration
-end
-
-class ChildMigration2 < TestMigration
-end
-
-class GrandchildMigration1 < ChildMigration1
-end
+require 'no_op_components'
+require 'test_migration'
+require 'inherited_migrations'
 
 describe Migratrix::Migration do
   let(:migration) { TestMigration.new :cheese => 42 }
@@ -30,6 +19,31 @@ describe Migratrix::Migration do
     end
   end
 
+  [:extraction, :transform, :load].each do |component|
+    describe ".set_#{component}" do
+      describe "without options" do
+        it "creates #{component} with empty options" do
+          Migratrix::Migratrix.should_receive(component).with(:test, :no_op, {})
+          TestMigration.send "set_#{component}", :test, :no_op
+        end
+      end
+
+      describe "without nickname" do
+        it "creates #{component} with nickname :default" do
+          Migratrix::Migratrix.should_receive(component).with(:default, :no_op, {opt: 2})
+          TestMigration.send "set_#{component}", :no_op, {opt: 2}
+        end
+      end
+
+      describe "without options or nickname" do
+        it "creates #{component} with nickname :default and empty options hash" do
+          Migratrix::Migratrix.should_receive(component).with(:default, :no_op, {})
+          TestMigration.send "set_#{component}", :no_op
+        end
+      end
+    end
+  end
+
   describe "with mocked components" do
     let(:map) { { :id => :id, :name => :name }}
     let(:extraction) {
@@ -162,7 +176,7 @@ describe Migratrix::Migration do
     end
   end
 
-  describe "extending" do
+  describe "with inheritance" do
     before do
       [TestMigration, ChildMigration1, ChildMigration2, GrandchildMigration1].each do |klass|
         [:extractions, :transforms, :loads].each do |kollection|
@@ -172,56 +186,68 @@ describe Migratrix::Migration do
       TestMigration.set_extraction :cheese, :extraction, { first_option: 'id>100' }
       TestMigration.set_transform :cheese, :transform, { first_option: 'id>100' }
       TestMigration.set_load :cheese, :load, { first_option: 'id>100' }
-
     end
 
-    [:extraction, :transform, :load ].each do |component|
-      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'}
-        end
-
-        it "extends the #{component} to the grandchild class" do
-          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2 })
-          GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
-          GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100', surprise_option: 50 }
-        end
-
-        it "extends the #{component} to the grandchild class even if the child class does not extend" do
-          GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
-          GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100', surprise_option: 50 }
+    describe "extending" do
+      [:extraction, :transform, :load ].each do |component|
+        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'}
+          end
+
+          it "extends the #{component} to the grandchild class" do
+            ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2 })
+            GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
+            GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>100', surprise_option: 50 }
+          end
+
+          it "extends the #{component} to the grandchild class even if the child class does not extend" do
+            GrandchildMigration1.send("extend_#{component}", :cheese, { surprise_option: 50 })
+            GrandchildMigration1.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100', surprise_option: 50 }
+          end
+
+          it "overrides parent options" do
+            ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+            ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+          end
+
+          it "does not affect sibling class options" do
+            ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+            ChildMigration2.send("extend_#{component}", :cheese, { zany_option: Hash, first_option: 'id>75' })
+            ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+            ChildMigration2.new.send("#{component}s")[:cheese].options.should == { zany_option: Hash, first_option: 'id>75'}
+          end
+
+          it "does not affect parent class options" do
+            ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
+            ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
+            TestMigration.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100'}
+          end
+
+          it "raises #{component.capitalize}NotDefined if no parent has that #{component}" do
+            exception = "Migratrix::#{component.capitalize}NotDefined".constantize
+            lambda { ChildMigration1.send("extend_#{component}", :blargle, { second_option: 2, first_option: 'id>50' }) }.should raise_error(exception)
+          end
         end
+      end
+    end
 
-        it "overrides parent options" do
-          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
-          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
-        end
+    [:extraction, :transform, :load].each do |component|
+      describe "#{component}s" do
+        let(:opts) { { opts_option: 'id>100' } }
 
-        it "does not affect sibling class options" do
-          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
-          ChildMigration2.send("extend_#{component}", :cheese, { zany_option: Hash, first_option: 'id>75' })
-          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
-          ChildMigration2.new.send("#{component}s")[:cheese].options.should == { zany_option: Hash, first_option: 'id>75'}
+        it "inherit from ancestor #{component}s" do
+          GrandchildMigration1.send("#{component}s").should == TestMigration.send("#{component}s")
         end
 
-        it "does not affect parent class options" do
-          ChildMigration1.send("extend_#{component}", :cheese, { second_option: 2, first_option: 'id>50' })
-          ChildMigration1.new.send("#{component}s")[:cheese].options.should == { second_option: 2, first_option: 'id>50'}
-          TestMigration.new.send("#{component}s")[:cheese].options.should == { first_option: 'id>100'}
-        end
-
-        it "raises #{component.capitalize}NotDefined if no parent has that #{component}" do
-          exception = "Migratrix::#{component.capitalize}NotDefined".constantize
-          lambda { ChildMigration1.send("extend_#{component}", :blargle, { second_option: 2, first_option: 'id>50' }) }.should raise_error(exception)
+        it "are merged with ancestor #{component}s" do
+          GrandchildMigration1.send "set_#{component}", :wine, component, opts
+          my_component = GrandchildMigration1.send("#{component}s")[:wine]
+          GrandchildMigration1.send("#{component}s").should == TestMigration.send("#{component}s").merge( { wine: my_component })
         end
       end
     end
-
-
-    # TODO: lambdas cannot be deep-copied, and form closures at the
-    # time of creation. Is there a way to detect if a lambda has a
-    # closure?
   end
 end
 

data/spec/lib/migratrix/migratrix_spec.rb

@@ -77,7 +77,7 @@ describe Migratrix::Migratrix do
   end
 
   describe "with logger as a singleton" do
-    let (:migration) { Migratrix::MarblesMigration.new }
+    let (:migration) { Migratrix::Migration.new }
     let (:buffer) { StringIO.new }
 
     def spec_all_loggers_are(this_logger)
@@ -85,7 +85,7 @@ describe Migratrix::Migratrix do
       Migratrix::Migratrix.logger.should == this_logger
       migratrix.logger.should == this_logger
       migration.logger.should == this_logger
-      Migratrix::MarblesMigration.logger.should == this_logger
+      Migratrix::Migration.logger.should == this_logger
     end
 
     describe ".logger=" do

data/spec/spec_helper.rb

@@ -28,7 +28,9 @@ Dir[SPEC + "support/**/*.rb"].each {|f| require f}
 
 require LIB + 'migratrix'
 
-require SPEC + "fixtures/migrations/marbles_migration"
+$:.unshift SPEC + "fixtures/migrations/"
+$:.unshift SPEC + "fixtures/components/"
+
 
 # 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.2
+  version: 0.8.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000Z
+date: 2011-10-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
-  requirement: &2152828360 !ruby/object:Gem::Requirement
+  requirement: &2161676040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152828360
+  version_requirements: *2161676040
 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
@@ -54,7 +54,9 @@ files:
 - lib/patches/andand.rb
 - lib/patches/object_ext.rb
 - lib/patches/string_ext.rb
-- spec/fixtures/migrations/marbles_migration.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
 - spec/lib/migratrix/callbacks_spec.rb
 - spec/lib/migratrix/extractions/active_record_spec.rb

data/spec/fixtures/migrations/marbles_migration.rb

@@ -1,19 +0,0 @@
-module Migratrix
-  # Fake migration fixture for "Marbles"
-  class MarblesMigration < Migration
-    # :nocov: # because we play some games with file loading/unloading, SimpleCov often misses lines in this file
-    def initialize(options={})
-      super
-      @migrated = false
-    end
-
-    def migrate
-      @migrated = true
-    end
-
-    def migrated?
-      @migrated
-    end
-    # :nocov:
-  end
-end