data_migrate 8.1.1 → 11.3.0

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -1,14 +1,12 @@
+# frozen_string_literal: true
+
 module DataMigrate
   module Tasks
     module DataMigrateTasks
       extend self
 
-      def schema_migrations_path
-        File.join('db', 'migrate')
-      end
-
       def migrations_paths
-        @migrations_paths ||= DataMigrate.config.data_migrations_path
+        @migrations_paths ||= Array.wrap(DataMigrate.config.data_migrations_path)
       end
 
       def dump
@@ -24,13 +22,13 @@ module DataMigrate
       def migrate
         target_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
 
-        DataMigrate::DataMigrator.assure_data_schema_table
+        DataMigrate::DataMigrator.create_data_schema_table
         DataMigrate::MigrationContext.new(migrations_paths).migrate(target_version)
       end
 
       def abort_if_pending_migrations(migrations, message)
         if migrations.any?
-          puts "You have #{migrations.size} pending #{migrations.size > 1 ? 'migrations:' : 'migration:'}"
+          puts "You have #{migrations.size} pending #{'migration'.pluralize(migrations.size)}:"
           migrations.each do |pending_migration|
             puts "  %4d %s" % [pending_migration[:version], pending_migration[:name]]
           end
@@ -47,35 +45,29 @@ module DataMigrate
       end
 
       def status
-        config = connect_to_database
-        return unless config
-
-        connection = ActiveRecord::Base.connection
-        puts "\ndatabase: #{config['database']}\n\n"
-        DataMigrate::StatusService.dump(connection)
+        DataMigrate::StatusService.dump
       end
 
       def status_with_schema
-        config = connect_to_database
-        return unless config
-
         db_list_data = ActiveRecord::Base.connection.select_values(
-          "SELECT version FROM #{DataMigrate::DataSchemaMigration.table_name}"
-        )
-        db_list_schema = ActiveRecord::Base.connection.select_values(
-          "SELECT version FROM #{ActiveRecord::SchemaMigration.schema_migrations_table_name}"
+          "SELECT version FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}"
         )
+        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
 
-        Dir.foreach(File.join(Rails.root, schema_migrations_path)) do |file|
+        DataMigrate::SchemaMigration.migrations_paths.map do |path|
+          Dir.children(path) if Dir.exist?(path)
+        end.flatten.compact.each do |file|
           # only files matching "20091231235959_some_name.rb" pattern
           if match_data = /(\d{14})_(.+)\.rb/.match(file)
             status = db_list_schema.delete(match_data[1]) ? 'up' : 'down'
@@ -86,7 +78,7 @@ module DataMigrate
         file_list.sort!{|a,b| "#{a[1]}_#{a[3] == 'data' ? 1 : 0}" <=> "#{b[1]}_#{b[3] == 'data' ? 1 : 0}" }
 
         # output
-        puts "\ndatabase: #{config['database']}\n\n"
+        puts "\ndatabase: #{database_name}\n\n"
         puts "#{"Status".center(8)} #{"Type".center(8)}  #{"Migration ID".ljust(14)} Migration Name"
         puts "-" * 60
         file_list.each do |file|
@@ -103,23 +95,12 @@ module DataMigrate
 
       private
 
-      def connect_to_database
-        config = if ActiveRecord.version < Gem::Version.new('6.1')
-          ActiveRecord::Base.configurations[Rails.env || 'development']
-        else
-          ActiveRecord::Base.configurations.find_db_config(Rails.env || 'development').configuration_hash
-        end
-        ActiveRecord::Base.establish_connection(config)
-
-        unless DataMigrate::DataSchemaMigration.table_exists?
-          puts 'Data migrations table does not exist yet.'
-          config = nil
-        end
-        unless ActiveRecord::SchemaMigration.table_exists?
-          puts 'Schema migrations table does not exist yet.'
-          config = nil
+      def database_name
+        if Gem::Dependency.new("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
+          ActiveRecord::Base.connection_db_config.database
+        elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+          ActiveRecord::Base.connection_config[:database]
         end
-        config
       end
     end
   end

data/lib/data_migrate/version.rb

@@ -1,3 +1,3 @@
 module DataMigrate
-  VERSION = "8.1.1".freeze
+  VERSION = "11.3.0".freeze
 end

data/lib/data_migrate.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-require File.join(File.dirname(__FILE__), "data_migrate", "data_migrator_five")
+require File.join(File.dirname(__FILE__), "data_migrate", "rails_helper")
+require File.join(File.dirname(__FILE__), "data_migrate", "data_migrator")
 require File.join(File.dirname(__FILE__), "data_migrate", "data_schema_migration")
 require File.join(File.dirname(__FILE__), "data_migrate", "data_schema")
 require File.join(File.dirname(__FILE__), "data_migrate", "database_tasks")
 require File.join(File.dirname(__FILE__), "data_migrate", "schema_dumper")
-require File.join(File.dirname(__FILE__), "data_migrate", "status_service_five")
+require File.join(File.dirname(__FILE__), "data_migrate", "status_service")
 require File.join(File.dirname(__FILE__), "data_migrate", "migration_context")
 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", "legacy_migrator")
 require File.join(File.dirname(__FILE__), "data_migrate", "config")
-
-if Rails::VERSION::MAJOR == 5
-  require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration_five")
-else
-  require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration_six")
-end
+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
+    File.dirname(__FILE__)
+  end
 end

data/lib/generators/data_migrate.rb

@@ -1,9 +1,22 @@
 require 'rails/generators/named_base'
+
 module DataMigrate
   module Generators
     class DataMigrationGenerator < Rails::Generators::NamedBase #:nodoc:
-      def self.source_root
-         @_data_migrate_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), generator_name, 'templates'))
+      class << self
+        def source_root
+          build_data_migrate_source_root
+        end
+
+        private
+
+        def build_data_migrate_source_root
+          if DataMigrate.config.data_template_path == DataMigrate::Config::DEFAULT_DATA_TEMPLATE_PATH
+            File.expand_path(File.join(File.dirname(__FILE__), generator_name, 'templates'))
+          else
+            File.expand_path(File.dirname(DataMigrate.config.data_template_path))
+          end
+        end
       end
     end
   end

data/lib/generators/data_migration/data_migration_generator.rb

@@ -14,7 +14,7 @@ module DataMigrate
 
       def create_data_migration
         set_local_assigns!
-        migration_template "data_migration.rb", data_migrations_file_path
+        migration_template template_path, data_migrations_file_path
       end
 
       protected
@@ -26,6 +26,10 @@ module DataMigrate
         end
       end
 
+      def template_path
+        DataMigrate.config.data_template_path
+      end
+
       def migration_base_class_name
         "ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
       end
@@ -34,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

data/tasks/databases.rake

@@ -1,54 +1,12 @@
+# frozen_string_literal: true
+
 require 'data_migrate/tasks/data_migrate_tasks'
 
 namespace :db do
   namespace :migrate do
     desc "Migrate the database data and schema (options: VERSION=x, VERBOSE=false)."
-    task :with_data => :environment do
-      assure_data_schema_table
-
-      ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-      target_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-      migrations = []
-
-      if target_version.nil?
-        migrations = pending_migrations.map{ |m| m.merge(:direction =>:up) }
-      else
-        current_schema_version = ActiveRecord::Migrator.current_version
-        schema_migrations = if target_version > current_schema_version
-                              pending_schema_migrations.keep_if{ |m| m[:version] <= target_version }.map{ |m| m.merge(:direction =>:up) }
-                            elsif target_version < current_schema_version
-                              past_migrations.keep_if{ |m| m[:version] > target_version }.map{ |m| m.merge(:direction =>:down) }
-                            else # ==
-                              []
-                            end
-
-        current_data_version = ActiveRecord::Migrator.current_version
-        data_migrations = if target_version > current_data_version
-                            pending_data_migrations.keep_if{ |m| m[:version] <= target_version }.map{ |m| m.merge(:direction =>:up) }
-                          elsif target_version < current_data_version
-                            past_migrations.keep_if{ |m| m[:version] > target_version }.map{ |m| m.merge(:direction =>:down) }
-                          else # ==
-                            []
-                          end
-        migrations = if schema_migrations.empty?
-                       data_migrations
-                     elsif data_migrations.empty?
-                       schema_migrations
-                     elsif target_version > current_data_version && target_version > current_schema_version
-                       sort_migrations data_migrations, schema_migrations
-                     elsif target_version < current_data_version && target_version < current_schema_version
-                       sort_migrations(data_migrations, schema_migrations).reverse
-                     elsif target_version > current_data_version && target_version < current_schema_version
-                       schema_migrations + data_migrations
-                     elsif target_version < current_data_version && target_version > current_schema_version
-                       schema_migrations + data_migrations
-                     end
-      end
-
-      migrations.each do |migration|
-        run_migration(migration, migration[:direction])
-      end
-
+    task :with_data => :load_config do
+      DataMigrate::DatabaseTasks.migrate_with_data
       Rake::Task["db:_dump"].invoke
       Rake::Task["data:dump"].invoke
     end
@@ -56,7 +14,7 @@ namespace :db do
     namespace :redo do
       desc 'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
       task :with_data => :environment do
-      assure_data_schema_table
+        DataMigrate::DataMigrator.create_data_schema_table
         if ENV["VERSION"]
           Rake::Task["db:migrate:down:with_data"].invoke
           Rake::Task["db:migrate:up:with_data"].invoke
@@ -72,16 +30,16 @@ namespace :db do
       task :with_data => :environment do
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         raise "VERSION is required" unless version
-        assure_data_schema_table
+        DataMigrate::DataMigrator.create_data_schema_table
         run_both = ENV["BOTH"] == "true"
-        migrations = pending_migrations.keep_if{|m| m[:version] == version}
+        migrations = DataMigrate::DatabaseTasks.pending_migrations.keep_if{|m| m[:version] == version}
 
         unless run_both || migrations.size < 2
           migrations = migrations.slice(0,1)
         end
 
         migrations.each do |migration|
-          run_migration(migration, :up)
+          DataMigrate::DatabaseTasks.run_migration(migration, :up)
         end
 
         Rake::Task["db:_dump"].invoke
@@ -94,16 +52,16 @@ namespace :db do
       task :with_data => :environment do
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         raise "VERSION is required" unless version
-        assure_data_schema_table
+        DataMigrate::DataMigrator.create_data_schema_table
         run_both = ENV["BOTH"] == "true"
-        migrations = past_migrations.keep_if{|m| m[:version] == version}
+        migrations = DataMigrate::DatabaseTasks.past_migrations.keep_if{|m| m[:version] == version}
 
         unless run_both || migrations.size < 2
           migrations = migrations.slice(0,1)
         end
 
         migrations.each do |migration|
-          run_migration(migration, :down)
+          DataMigrate::DatabaseTasks.run_migration(migration, :down)
         end
 
         Rake::Task["db:_dump"].invoke
@@ -123,9 +81,9 @@ namespace :db do
     desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
     task :with_data => :environment do
       step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-      assure_data_schema_table
-      past_migrations[0..(step - 1)].each do | past_migration |
-        run_migration(past_migration, :down)
+      DataMigrate::DataMigrator.create_data_schema_table
+      DataMigrate::DatabaseTasks.past_migrations[0..(step - 1)].each do | past_migration |
+        DataMigrate::DatabaseTasks.run_migration(past_migration, :down)
       end
 
       Rake::Task["db:_dump"].invoke
@@ -136,7 +94,7 @@ namespace :db do
   namespace :forward do
     desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
     task :with_data => :environment do
-      assure_data_schema_table
+      DataMigrate::DataMigrator.create_data_schema_table
       step = ENV['STEP'] ? ENV['STEP'].to_i : 1
       DataMigrate::DatabaseTasks.forward(step)
       Rake::Task["db:_dump"].invoke
@@ -147,7 +105,7 @@ namespace :db do
   namespace :version do
     desc "Retrieves the current schema version numbers for data and schema migrations"
     task :with_data => :environment do
-      assure_data_schema_table
+      DataMigrate::DataMigrator.create_data_schema_table
       puts "Current Schema version: #{ActiveRecord::Migrator.current_version}"
       puts "Current Data version: #{DataMigrate::DataMigrator.current_version}"
     end
@@ -157,7 +115,7 @@ namespace :db do
     desc "Raises an error if there are pending migrations or data migrations"
     task with_data: :environment do
       message = %{Run `rake db:migrate:with_data` to update your database then try again.}
-      DataMigrate::Tasks::DataMigrateTasks.abort_if_pending_migrations(pending_migrations, message)
+      DataMigrate::Tasks::DataMigrateTasks.abort_if_pending_migrations(DataMigrate::DatabaseTasks.pending_migrations, message)
     end
   end
 
@@ -188,6 +146,13 @@ namespace :db do
       end
     end
   end
+
+  namespace :prepare do
+    desc "Runs setup if database does not exist, or runs data and schema migrations if it does"
+    task with_data: :environment do
+      DataMigrate::DatabaseTasks.prepare_all_with_data
+    end
+  end
 end
 
 namespace :data do
@@ -200,7 +165,7 @@ namespace :data do
   namespace :migrate do
     desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => :environment do
-      assure_data_schema_table
+      DataMigrate::DataMigrator.create_data_schema_table
       if ENV["VERSION"]
         Rake::Task["data:migrate:down"].invoke
         Rake::Task["data:migrate:up"].invoke
@@ -212,10 +177,10 @@ namespace :data do
 
     desc 'Runs the "up" for a given migration VERSION.'
     task :up => :environment do
-      assure_data_schema_table
+      DataMigrate::DataMigrator.create_data_schema_table
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      DataMigrate::DataMigrator.run(:up, data_migrations_path, version)
+      DataMigrate::DataMigrator.run(:up, DataMigrate::DatabaseTasks.data_migrations_path, version)
       Rake::Task["data:dump"].invoke
     end
 
@@ -223,8 +188,8 @@ namespace :data do
     task :down => :environment do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      assure_data_schema_table
-      DataMigrate::DataMigrator.run(:down, data_migrations_path, version)
+      DataMigrate::DataMigrator.create_data_schema_table
+      DataMigrate::DataMigrator.run(:down, DataMigrate::DatabaseTasks.data_migrations_path, version)
       Rake::Task["data:dump"].invoke
     end
 
@@ -236,35 +201,35 @@ namespace :data do
 
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
   task :rollback => :environment do
-    assure_data_schema_table
+    DataMigrate::DataMigrator.create_data_schema_table
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    DataMigrate::DataMigrator.rollback(data_migrations_path, step)
+    DataMigrate::DataMigrator.rollback(DataMigrate::DatabaseTasks.data_migrations_path, step)
     Rake::Task["data:dump"].invoke
   end
 
   desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
   task :forward => :environment do
-    assure_data_schema_table
+    DataMigrate::DataMigrator.create_data_schema_table
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     # TODO: No worky for .forward
     # DataMigrate::DataMigrator.forward('db/data/', step)
-    migrations = pending_data_migrations.reverse.pop(step).reverse
+    migrations = DataMigrate::DatabaseTasks.pending_data_migrations.reverse.pop(step).reverse
     migrations.each do | pending_migration |
-      DataMigrate::DataMigrator.run(:up, data_migrations_path, pending_migration[:version])
+      DataMigrate::DataMigrator.run(:up, DataMigrate::DatabaseTasks.data_migrations_path, pending_migration[:version])
     end
     Rake::Task["data:dump"].invoke
   end
 
   desc "Retrieves the current schema version number for data migrations"
   task :version => :environment do
-    assure_data_schema_table
+    DataMigrate::DataMigrator.create_data_schema_table
     puts "Current data version: #{DataMigrate::DataMigrator.current_version}"
   end
 
   desc "Raises an error if there are pending data migrations"
   task abort_if_pending_migrations: :environment do
     message = %{Run `rake data:migrate` to update your database then try again.}
-    DataMigrate::Tasks::DataMigrateTasks.abort_if_pending_migrations(pending_data_migrations, message)
+    DataMigrate::Tasks::DataMigrateTasks.abort_if_pending_migrations(DataMigrate::DatabaseTasks.pending_data_migrations, message)
   end
 
   desc "Create a db/data_schema.rb file that stores the current data version"
@@ -287,53 +252,3 @@ namespace :data do
     end
   end
 end
-
-def pending_migrations
-  DataMigrate::DatabaseTasks.sort_migrations(
-    DataMigrate::DatabaseTasks.pending_schema_migrations,
-    DataMigrate::DatabaseTasks.pending_data_migrations
-  )
-end
-
-def pending_data_migrations
-  DataMigrate::DatabaseTasks.pending_data_migrations
-end
-
-def pending_schema_migrations
-  DataMigrate::DatabaseTasks.pending_schema_migrations
-end
-
-def sort_migrations set_1, set_2=nil
-  migrations = set_1 + (set_2 || [])
-  migrations.sort{|a,b|  sort_string(a) <=> sort_string(b)}
-end
-
-def sort_string migration
-  "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
-end
-
-def past_migrations(sort=nil)
-  DataMigrate::DatabaseTasks.past_migrations(sort)
-end
-
-def assure_data_schema_table
-  DataMigrate::DataMigrator.assure_data_schema_table
-end
-
-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