data_migrate 9.2.0 → 11.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98382ecfcd0ad635d3e53bb746f4b2a7a402c2b2a78d312e864bbe6f288b65b1
-  data.tar.gz: 315d89e1465e7f5a804d4e70d67963949608632b91b7276ea23319f2183789ba
+  metadata.gz: 907383933e031d0a1da7bad6dd3a43807794c0abeb27313af27e59ed8d802f3a
+  data.tar.gz: 1ddf826962f7078972ca9a234a723646d7744a41990dbe38550155fc0276fca3
 SHA512:
-  metadata.gz: '04098142838de3bb59be85adc46a9a4aed734668a154378488c74ea2a1982793a45450364f089edb479add87cab1b47e801916553c01ad003bbe71c0ba06b855'
-  data.tar.gz: 4654fdfb138a53c5cc4ff59df1d63bc66ccd0f66d292f79c0d37ccbdb43c184144d5122718e9027ea643f1e0786d79844aee44d70feb5a1c455a59670286e5ef
+  metadata.gz: e9e79dd56bda8e5f2afecb79f940eb17d7b5439c1d07b38d67943d58fc0ebaf159283d4478ac13925a2ee399097f6825b519052d3fea9f7b04c659a98647e75f
+  data.tar.gz: '0959a1bcf969cbc7834c839eca029d1416ff287ea2927a8ae0493a7880fb6910adea4baf5a2d162bd4cce35f80b610dc2f9d671cf77cf6583a699a96196871de'

data/Changelog.md

@@ -1,5 +1,41 @@
 # Changelog
 
+# 11.2.0
+
+- Remove committed Gemfile.lock, reduce bundled file list when running `gem install` https://github.com/ilyakatz/data-migrate/pull/351
+- [Bump actionpack from 7.1.3.4 to 7.1.4.1](https://github.com/ilyakatz/data-migrate/pull/348)
+- [Bump rexml from 3.3.6 to 3.3.9](https://github.com/ilyakatz/data-migrate/pull/349)
+- Fix db_config_with_versions arity change and backport https://github.com/ilyakatz/data-migrate/pull/337
+
+# 11.1.0
+- Allow multiple data migration paths https://github.com/ilyakatz/data-migrate/pull/331
+- Fix db:prepare:with_data task on [Rails 7.2](https://github.com/ilyakatz/data-migrate/pull/339)
+- Fix ConnectionPool deprecation warnings on [Rails 7.2](https://github.com/ilyakatz/data-migrate/pull/341)
+- Add Rails 8.0 to testing grounds https://github.com/ilyakatz/data-migrate/pull/341
+- [Bump webrick from 1.8.1 to 1.8.2](https://github.com/ilyakatz/data-migrate/pull/345)
+
+# 11.0.0
+- [Update rexml to 3.3.6](https://github.com/ilyakatz/data-migrate/pull/329)
+- Fixes a bug which ignored migrations on [Rails 7.1 and higher](https://github.com/ilyakatz/data-migrate/pull/326)
+
+# 11.0.0rc
+- Remove Ruby 3.0 from build matrix
+- Support Rails 7.2.0 https://github.com/ilyakatz/data-migrate/pull/312
+- Update gemfile.lock builds
+
+## 9.4.2
+- Fix db:prepare:with_data task
+
+## 9.4.1
+- Add db:prepare task
+
+## 9.4.0
+- Reset model schema cache before each data migration https://github.com/ilyakatz/data-migrate/pull/307
+- Run load_config rake task before db:migrate:with_data https://github.com/ilyakatz/data-migrate/pull/308
+
+## 9.3.0
+- Improve with_data Rake task for multiple database https://github.com/ilyakatz/data-migrate/pull/296
+
 ## 9.2.0
 - Support Rails 7.1 https://github.com/ilyakatz/data-migrate/pull/278
 - Build and test against 7.1.0.rc1 https://github.com/ilyakatz/data-migrate/pull/286

data/README.md

@@ -36,8 +36,13 @@ table to track all migrations.
 
 ## Rails Support
 
-Support Rails 6.1 through 7.1
+Support Rails 6.1 through 7.2
 
+For **Rails 6.0** support, please use gem version `9.1.x`:
+
+```ruby
+gem 'data_migrate', '~> 9.1.0'
+```
 
 #### v1
 
@@ -86,6 +91,7 @@ You can generate a data migration as you would a schema migration:
     rake db:migrate:status:with_data               # Display status of data and schema migrations
     rake db:migrate:up:with_data                   # Runs the "up" for a given migration VERSION
     rake db:migrate:with_data                      # Migrate the database data and schema (options: VERSION=x, VERBOSE=false)
+    rake db:prepare:with_data                      # Runs setup if database does not exist, or runs data and schema migrations if it does
     rake db:rollback:with_data                     # Rolls the schema back to the previous version (specify steps w/ STEP=n)
     rake db:schema:load:with_data                  # Load both schema.rb and data_schema.rb file into the database
     rake db:structure:load:with_data               # Load both structure.sql and data_schema.rb file into the database
@@ -138,19 +144,12 @@ From now on capistrano will run `rake db:migrate:with_data` in every deploy.
 ## Rails Engines support
 
 This gem also has a initial support for adding data migrations inside Rails engines.
-Inside the Engine's class initializer (the one that inherits from `Rails::Engine`, usually inside `engines/ENGINE_NAME/lib/engine.rb`) you need to add something like this:
-
+Just add your engines directory pattern to data_migrations initializer, for example 
+in the case your engines are located in `engines` folder you can set it up like this:
 
 ```ruby
-module EngineName
-  class Engine < ::Rails::Engine
-    initializer :engine_name do |app|
-      ::DataMigrate.configure do |data_migrate|
-        default_path = ::DataMigrate::Config.new.data_migrations_path
-        data_migrate.data_migrations_path = [default_path, root.join('db', 'data')]
-      end
-    end
-  end
+DataMigrate.configure do |config|
+  config.data_migrations_path = ['db/data'] + Dir['engines/**/db/data']
 end
 ```
 
@@ -163,12 +162,20 @@ Then, in the Engine's `db/data` folder, you can add data migrations and run them
 Run tests for a specific version of Rails
 
 ```
-bundle exec appraisal install
 bundle exec appraisal rails-6.1 rspec
 bundle exec appraisal rails-7.0 rspec
 bundle exec appraisal rails-7.1 rspec
+bundle exec appraisal rails-7.2 rspec
 ```
 
+## Releasing new version
+
+1. Create a new tag, eg `git tag 9.4.1`
+1. Go to https://github.com/ilyakatz/data-migrate/tags
+1. Click "Create release" under 9.4.1
+1. CLick "Generate release notes"
+1. Click "Publish release"
+
 ## Thanks
 
 [Andrew J Vargo](http://github.com/ajvargo) Andrew was the original creator and maintainer of this project!

data/lib/data_migrate/data_migrator.rb

@@ -12,7 +12,7 @@ module DataMigrate
 
     class << self
       def migrations_paths
-        [DataMigrate.config.data_migrations_path]
+        Array.wrap(DataMigrate.config.data_migrations_path)
       end
 
       def create_data_schema_table
@@ -54,6 +54,10 @@ module DataMigrate
 
       #TODO: this was added to be backward compatible, need to re-evaluate
       def run(direction, migration_paths, version)
+        # Ensure all Active Record model cache is reset for each data migration
+        # As recommended in: https://github.com/rails/rails/blob/da21c2e9812e5eb0698fba4a9aa38632fc004432/activerecord/lib/active_record/migration.rb#L467-L470
+        ActiveRecord::Base.descendants.each(&:reset_column_information)
+
         DataMigrate::MigrationContext.new(migration_paths).run(direction, version)
       end
 

data/lib/data_migrate/data_schema.rb

@@ -29,13 +29,13 @@ module DataMigrate
     end
 
     def versions
-      @versions ||= begin
-        versions = []
-        Dir.foreach(DataMigrate::DataMigrator.full_migrations_path) do |file|
-          match_data = DataMigrate::DataMigrator.match(file)
-          versions << match_data[1].to_i if match_data
+      @versions ||= Set.new.tap do |versions|
+        DataMigrate::DataMigrator.migrations_paths.each do |path|
+          Dir.foreach(path) do |file|
+            match_data = DataMigrate::DataMigrator.match(file)
+            versions << match_data[1].to_i if match_data
+          end
         end
-        versions
       end
     end
 

data/lib/data_migrate/database_configurations_wrapper.rb

@@ -0,0 +1,11 @@
+module DataMigrate
+  # This wrapper is used to differentiate between
+  # a data and schema db config when running migrations
+  class DatabaseConfigurationWrapper
+    attr_reader :db_config
+
+    def initialize(db_config)
+      @db_config = db_config
+    end
+  end
+end

data/lib/data_migrate/database_tasks.rb

@@ -5,87 +5,142 @@ require "data_migrate/config"
 module DataMigrate
   ##
   # This class extends DatabaseTasks to add a schema_file method.
-  class DatabaseTasks
+  module DatabaseTasks
     extend ActiveRecord::Tasks::DatabaseTasks
+    extend self
 
-    class << self
-      def schema_file(_format = nil)
-        File.join(db_dir, "data_schema.rb")
-      end
-
-      def schema_file_type(_format = nil)
-        "data_schema.rb"
-      end
-
-      # This method is removed in Rails 7.0
-      def dump_filename(spec_name, format = ActiveRecord::Base.schema_format)
-        filename = if spec_name == "primary"
-          schema_file_type(format)
+    # These method are only introduced in Rails 7.1
+    unless respond_to?(:with_temporary_pool_for_each)
+      def with_temporary_pool_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, &block) # :nodoc:
+        if name
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
+           with_temporary_pool(db_config, &block)
         else
-          "#{spec_name}_#{schema_file_type(format)}"
+          ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
+             with_temporary_pool(db_config, &block)
+          end
         end
-
-        ENV["DATA_SCHEMA"] || File.join(db_dir, filename)
       end
 
-      def check_schema_file(filename)
-        unless File.exist?(filename)
-          message = +%{#{filename} doesn't exist yet. Run `rake data:migrate` to create it, then try again.}
-          Kernel.abort message
+      def with_temporary_connection(db_config, &block) # :nodoc:
+        with_temporary_pool(db_config) do |pool|
+          pool.with_connection(&block)
         end
       end
 
-      def pending_migrations
-        sort_migrations(
-          pending_schema_migrations,
-          pending_data_migrations
-        )
+      def migration_class # :nodoc:
+        ActiveRecord::Base
       end
 
-      def sort_migrations(*migrations)
-        migrations.flatten.sort { |a, b|  sort_string(a) <=> sort_string(b) }
+      def migration_connection # :nodoc:
+        migration_class.connection
       end
 
-      def sort_string migration
-        "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
-      end
+      private def with_temporary_pool(db_config)
+        original_db_config = migration_class.connection_db_config
+        pool = migration_class.connection_handler.establish_connection(db_config)
 
-      def data_migrations_path
-        ::DataMigrate.config.data_migrations_path
+        yield pool
+      ensure
+        migration_class.connection_handler.establish_connection(original_db_config)
       end
+    end
 
-      def run_migration(migration, direction)
-        if migration[:kind] == :data
-          ::ActiveRecord::Migration.write("== %s %s" % ['Data', "=" * 71])
-          ::DataMigrate::DataMigrator.run(direction, data_migrations_path, migration[:version])
-        else
-          ::ActiveRecord::Migration.write("== %s %s" % ['Schema', "=" * 69])
-          ::DataMigrate::SchemaMigration.run(
-            direction,
-            ::DataMigrate::SchemaMigration.migrations_paths,
-            migration[:version]
-          )
+    def db_configs_with_versions
+      db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
+
+      with_temporary_pool_for_each do |pool|
+        db_config = pool.db_config
+        if db_config.primary?
+          versions_to_run = DataMigrate::DatabaseTasks.pending_data_migrations.map { |m| m[:version] }
+          target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
+
+          versions_to_run.each do |version|
+            next if target_version && target_version != version
+            db_configs_with_versions[version] << DatabaseConfigurationWrapper.new(db_config)
+          end
         end
       end
 
-      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
-        return ENV["DATA_SCHEMA"] if ENV["DATA_SCHEMA"]
+      db_configs_with_versions
+    end
+
+    def schema_file(_format = nil)
+      File.join(db_dir, "data_schema.rb")
+    end
+
+    def schema_file_type(_format = nil)
+      "data_schema.rb"
+    end
+
+    # This method is removed in Rails 7.0
+    def dump_filename(spec_name, format = ActiveRecord::Base.schema_format)
+      filename = if spec_name == "primary"
+        schema_file_type(format)
+      else
+        "#{spec_name}_#{schema_file_type(format)}"
+      end
 
-        # We only require a schema.rb file for the primary database
-        return unless db_config.primary?
+      ENV["DATA_SCHEMA"] || File.join(db_dir, filename)
+    end
 
-        File.join(File.dirname(ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config, format)), schema_file_type)
+    def check_schema_file(filename)
+      unless File.exist?(filename)
+        message = +%{#{filename} doesn't exist yet. Run `rake data:migrate` to create it, then try again.}
+        Kernel.abort message
       end
+    end
+
+    def pending_migrations
+      sort_migrations(
+        pending_schema_migrations,
+        pending_data_migrations
+      )
+    end
+
+    def sort_migrations(*migrations)
+      migrations.flatten.sort { |a, b|  sort_string(a) <=> sort_string(b) }
+    end
+
+    def sort_string migration
+      "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
+    end
 
-      # Override this method from `ActiveRecord::Tasks::DatabaseTasks`
-      # to ensure that the sha saved in ar_internal_metadata table
-      # is from the original schema.rb file
-      def schema_sha1(file)
-        ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env, name: "primary"))
+    def data_migrations_path
+      ::DataMigrate.config.data_migrations_path
+    end
+
+    def run_migration(migration, direction)
+      if migration[:kind] == :data
+        ::ActiveRecord::Migration.write("== %s %s" % ['Data', "=" * 71])
+        ::DataMigrate::DataMigrator.run(direction, data_migrations_path, migration[:version])
+      else
+        ::ActiveRecord::Migration.write("== %s %s" % ['Schema', "=" * 69])
+        ::DataMigrate::SchemaMigration.run(
+          direction,
+          ::DataMigrate::SchemaMigration.migrations_paths,
+          migration[:version]
+        )
       end
     end
 
-    def self.forward(step = 1)
+    def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+      return ENV["DATA_SCHEMA"] if ENV["DATA_SCHEMA"]
+
+      # We only require a schema.rb file for the primary database
+      return unless db_config.primary?
+
+      File.join(File.dirname(ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config, format)), schema_file_type)
+    end
+
+    # Override this method from `ActiveRecord::Tasks::DatabaseTasks`
+    # to ensure that the sha saved in ar_internal_metadata table
+    # is from the original schema.rb file
+    def schema_sha1(file)
+      ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env, name: "primary"))
+    end
+
+    def forward(step = 1)
       DataMigrate::DataMigrator.create_data_schema_table
       migrations = pending_migrations.reverse.pop(step).reverse
       migrations.each do | pending_migration |
@@ -99,7 +154,7 @@ module DataMigrate
       end
     end
 
-    def self.pending_data_migrations
+    def pending_data_migrations
       data_migrations = DataMigrate::DataMigrator.migrations(data_migrations_path)
       data_migrator = DataMigrate::RailsHelper.data_migrator(:up, data_migrations)
       sort_migrations(
@@ -107,16 +162,121 @@ module DataMigrate
         )
     end
 
-    def self.pending_schema_migrations
+    def pending_schema_migrations
       ::DataMigrate::SchemaMigration.pending_schema_migrations
     end
 
-    def self.past_migrations(sort = nil)
+    def past_migrations(sort = nil)
       data_versions = DataMigrate::RailsHelper.data_schema_migration.table_exists? ? DataMigrate::RailsHelper.data_schema_migration.normalized_versions : []
       schema_versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
       migrations = data_versions.map { |v| { version: v.to_i, kind: :data } } + schema_versions.map { |v| { version: v.to_i, kind: :schema } }
 
       sort&.downcase == "asc" ? sort_migrations(migrations) : sort_migrations(migrations).reverse
     end
+
+    def self.migrate_with_data
+      DataMigrate::DataMigrator.create_data_schema_table
+
+      ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+
+      # 7.2 removes the param for db_configs_with_versions in https://github.com/rails/rails/commit/9572fcb4a0bd5396436689a6a42613886871cd81
+      # 7.1 stable backported the change in https://github.com/rails/rails/commit/c53ec4b60980036b43528829d4b0b7457f759224
+      schema_mapped_versions = if Gem::Dependency.new("railties", ">= 7.1.4").match?("railties", Gem.loaded_specs["railties"].version, true)
+        ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
+      else
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+
+        ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions(db_configs)
+      end
+
+      data_mapped_versions = DataMigrate::DatabaseTasks.db_configs_with_versions
+
+      mapped_versions = schema_mapped_versions.merge(data_mapped_versions) do |_key, schema_db_configs, data_db_configs|
+        schema_db_configs + data_db_configs
+      end
+
+      mapped_versions.sort.each do |version, db_configs|
+        db_configs.each do |db_config|
+          if is_data_migration = db_config.is_a?(DataMigrate::DatabaseConfigurationWrapper)
+            db_config = db_config.db_config
+          end
+
+          DataMigrate::DatabaseTasks.with_temporary_connection(db_config) do
+            if is_data_migration
+              DataMigrate::DataMigrator.run(:up, DataMigrate::DatabaseTasks.data_migrations_path, version)
+            else
+              ActiveRecord::Tasks::DatabaseTasks.migrate(version)
+            end
+          end
+        end
+      end
+    end
+
+    def self.prepare_all_with_data
+      seed = false
+
+      each_current_configuration(env) do |db_config|
+        next unless primary?(db_config)
+
+        with_temporary_pool(db_config) do |pool|
+          unless database_exists?(pool.connection)
+            create(db_config)
+            if File.exist?(schema_dump_path(db_config))
+              load_schema(db_config, schema_format, nil)
+              load_schema_current(
+                :ruby,
+                ENV["DATA_SCHEMA"]
+              )
+            end
+
+            seed = true
+          end
+
+          migrate_with_data
+          if dump_schema_after_migration?
+            dump_schema(db_config)
+            DataMigrate::Tasks::DataMigrateTasks.dump
+          end
+        end
+      end
+
+      load_seed if seed
+    end
+
+    private
+
+    def database_exists?(connection)
+      if connection.respond_to?(:database_exists?)  # Rails 7.1+
+        connection.database_exists?
+      else
+        connection.table_exists?(ActiveRecord::SchemaMigration.table_name)
+      end
+    rescue ActiveRecord::NoDatabaseError
+      false
+    end
+
+    def primary?(db_config)
+      if db_config.respond_to?(:primary?)  # Rails 7.0+
+        db_config.primary?
+      else
+        db_config.name == "primary"
+      end
+    end
+
+    def dump_schema_after_migration?
+      if ActiveRecord.respond_to?(:dump_schema_after_migration)
+        ActiveRecord.dump_schema_after_migration
+      else
+        ActiveRecord::Base.dump_schema_after_migration
+      end
+    end
+
+    def schema_format
+      if ActiveRecord.respond_to?(:schema_format)
+        ActiveRecord.schema_format
+      else
+        ActiveRecord::Base.schema_format
+      end
+    end
   end
 end

data/lib/data_migrate/rails_helper.rb

@@ -1,6 +1,12 @@
 module DataMigrate
   class RailsHelper
     class << self
+      def rails_version_equal_to_or_higher_than_7_2
+        return @equal_to_or_higher_than_7_2 if defined?(@equal_to_or_higher_than_7_2)
+
+        @equal_to_or_higher_than_7_2 = Gem::Dependency.new("railties", ">= 7.2.0.alpha").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+
       def rails_version_equal_to_or_higher_than_7_1
         return @equal_to_or_higher_than_7_1 if defined?(@equal_to_or_higher_than_7_1)
 
@@ -14,7 +20,9 @@ module DataMigrate
       end
 
       def internal_metadata
-        if rails_version_equal_to_or_higher_than_7_1
+        if rails_version_equal_to_or_higher_than_7_2
+          ActiveRecord::Base.connection_pool.internal_metadata
+        elsif rails_version_equal_to_or_higher_than_7_1
           ActiveRecord::Base.connection.internal_metadata
         else
           ActiveRecord::InternalMetadata
@@ -22,7 +30,9 @@ module DataMigrate
       end
 
       def schema_migration
-        if rails_version_equal_to_or_higher_than_7_1
+        if rails_version_equal_to_or_higher_than_7_2
+          ActiveRecord::Base.connection_pool.schema_migration
+        elsif rails_version_equal_to_or_higher_than_7_1
           ActiveRecord::Base.connection.schema_migration
         else
           ActiveRecord::SchemaMigration
@@ -54,7 +64,9 @@ module DataMigrate
       end
 
       def data_schema_migration
-        if rails_version_equal_to_or_higher_than_7_1
+        if rails_version_equal_to_or_higher_than_7_2
+          DataMigrate::DataSchemaMigration.new(ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool)
+        elsif rails_version_equal_to_or_higher_than_7_1
           DataMigrate::DataSchemaMigration.new(ActiveRecord::Tasks::DatabaseTasks.migration_connection)
         else
           DataMigrate::DataSchemaMigration

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -6,7 +6,7 @@ module DataMigrate
       extend self
 
       def migrations_paths
-        @migrations_paths ||= DataMigrate.config.data_migrations_path
+        @migrations_paths ||= Array.wrap(DataMigrate.config.data_migrations_path)
       end
 
       def dump
@@ -55,11 +55,13 @@ module DataMigrate
         db_list_schema = DataMigrate::RailsHelper.schema_migration_versions
         file_list = []
 
-        Dir.foreach(File.join(Rails.root, migrations_paths)) do |file|
-          # only files matching "20091231235959_some_name.rb" pattern
-          if match_data = /(\d{14})_(.+)\.rb/.match(file)
-            status = db_list_data.delete(match_data[1]) ? 'up' : 'down'
-            file_list << [status, match_data[1], match_data[2], 'data']
+        migrations_paths.each do |path|
+          Dir.foreach(File.join(Rails.root, path)) do |file|
+            # only files matching "20091231235959_some_name.rb" pattern
+            if match_data = /(\d{14})_(.+)\.rb/.match(file)
+              status = db_list_data.delete(match_data[1]) ? 'up' : 'down'
+              file_list << [status, match_data[1], match_data[2], 'data']
+            end
           end
         end
 

data/lib/data_migrate/version.rb

@@ -1,3 +1,3 @@
 module DataMigrate
-  VERSION = "9.2.0".freeze
+  VERSION = "11.2.0".freeze
 end

data/lib/data_migrate.rb

@@ -12,6 +12,7 @@ require File.join(File.dirname(__FILE__), "data_migrate", "railtie")
 require File.join(File.dirname(__FILE__), "data_migrate", "tasks/data_migrate_tasks")
 require File.join(File.dirname(__FILE__), "data_migrate", "config")
 require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration")
+require File.join(File.dirname(__FILE__), "data_migrate", "database_configurations_wrapper")
 
 module DataMigrate
   def self.root

data/lib/generators/data_migration/data_migration_generator.rb

@@ -38,8 +38,9 @@ module DataMigrate
         File.join(data_migrations_path, "#{file_name}.rb")
       end
 
+      # Use the first path in the data_migrations_path as the target directory
       def data_migrations_path
-        DataMigrate.config.data_migrations_path
+        Array.wrap(DataMigrate.config.data_migrations_path).first
       end
     end
   end