data_migrate 8.5.0 → 9.2.0

data/lib/data_migrate/database_tasks.rb

@@ -9,36 +9,23 @@ module DataMigrate
     extend ActiveRecord::Tasks::DatabaseTasks
 
     class << self
-      def schema_file_type(_format = nil)
-        "data_schema.rb"
+      def schema_file(_format = nil)
+        File.join(db_dir, "data_schema.rb")
       end
 
-      def dump_filename(namespace, format = ActiveRecord::Base.schema_format)
-        filename = if namespace == "primary"
-          schema_file_type(format)
-        else
-          "#{namespace}_#{schema_file_type(format)}"
-        end
-
-        ENV["DATA_SCHEMA"] || File.join(schema_location, filename)
+      def schema_file_type(_format = nil)
+        "data_schema.rb"
       end
 
-      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
-        return ENV["DATA_SCHEMA"] if ENV["DATA_SCHEMA"]
-
-        filename = if db_config.primary?
+      # 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
-          [db_config.name, schema_file_type(format)].join("_")
+          "#{spec_name}_#{schema_file_type(format)}"
         end
 
-        return unless filename
-
-        File.dirname(filename) == schema_location ? filename : File.join(schema_location, filename)
-      end
-
-      def schema_location
-        db_dir
+        ENV["DATA_SCHEMA"] || File.join(db_dir, filename)
       end
 
       def check_schema_file(filename)
@@ -55,9 +42,8 @@ module DataMigrate
         )
       end
 
-      def sort_migrations set_1, set_2=nil
-        migrations = set_1 + (set_2 || [])
-        migrations.sort{|a,b|  sort_string(a) <=> sort_string(b)}
+      def sort_migrations(*migrations)
+        migrations.flatten.sort { |a, b|  sort_string(a) <=> sort_string(b) }
       end
 
       def sort_string migration
@@ -81,15 +67,26 @@ module DataMigrate
           )
         end
       end
-    end
 
-    # This overrides ActiveRecord::Tasks::DatabaseTasks
-    def self.schema_file(_format = nil)
-      File.join(db_dir, "data_schema.rb")
+      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
     end
 
     def self.forward(step = 1)
-      DataMigrate::DataMigrator.assure_data_schema_table
+      DataMigrate::DataMigrator.create_data_schema_table
       migrations = pending_migrations.reverse.pop(step).reverse
       migrations.each do | pending_migration |
         if pending_migration[:kind] == :data
@@ -97,63 +94,29 @@ module DataMigrate
           DataMigrate::DataMigrator.run(:up, data_migrations_path, pending_migration[:version])
         elsif pending_migration[:kind] == :schema
           ActiveRecord::Migration.write("== %s %s" % ["Schema", "=" * 69])
-          DataMigrate::SchemaMigration.run(:up, schema_migrations_path, pending_migration[:version])
+          DataMigrate::SchemaMigration.run(:up, DataMigrate::SchemaMigration.migrations_paths, pending_migration[:version])
         end
       end
     end
 
-    def self.data_migrations_path
-      DataMigrate.config.data_migrations_path
-    end
-
-    def self.schema_migrations_path
-      "db/migrate/"
-    end
-
-    def self.pending_migrations
-      sort_migrations(pending_schema_migrations, pending_data_migrations)
-    end
-
     def self.pending_data_migrations
       data_migrations = DataMigrate::DataMigrator.migrations(data_migrations_path)
-      sort_migrations(DataMigrate::DataMigrator.new(:up, data_migrations ).
-        pending_migrations.map {|m| { version: m.version, name: m.name, kind: :data }})
+      data_migrator = DataMigrate::RailsHelper.data_migrator(:up, data_migrations)
+      sort_migrations(
+        data_migrator.pending_migrations.map { |m| { version: m.version, name: m.name, kind: :data } }
+        )
     end
 
     def self.pending_schema_migrations
       ::DataMigrate::SchemaMigration.pending_schema_migrations
     end
 
-    def self.sort_migrations(set1, set2 = nil)
-      migrations = set1 + (set2 || [])
-      migrations.sort {|a, b|  sort_string(a) <=> sort_string(b)}
-    end
-
-    def self.sort_string(migration)
-      "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
-    end
-
     def self.past_migrations(sort = nil)
-      sort = sort.downcase if sort
-      db_list_data =
-        if DataMigrate::DataSchemaMigration.table_exists?
-          DataMigrate::DataSchemaMigration.normalized_versions.sort
-        else
-          []
-        end
-      db_list_schema = ActiveRecord::SchemaMigration.normalized_versions.sort.sort
-      migrations = db_list_data.map do |d|
-        {
-          version: d.to_i, kind: :data
-        }
-      end +
-                   db_list_schema.map do |d|
-                     {
-                       version: d.to_i, kind: :schema
-                     }
-                   end
-
-      sort == "asc" ? sort_migrations(migrations) : sort_migrations(migrations).reverse
+      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
   end
 end

data/lib/data_migrate/migration_context.rb

@@ -11,7 +11,8 @@ module DataMigrate
                               migrations
                             end
 
-      DataMigrator.new(:up, selected_migrations, target_version).migrate
+      data_migrator = DataMigrate::RailsHelper.data_migrator(:up, selected_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.migrate
     end
 
     def down(target_version = nil)
@@ -22,11 +23,13 @@ module DataMigrate
           migrations
         end
 
-      DataMigrator.new(:down, selected_migrations, target_version).migrate
+      data_migrator = DataMigrate::RailsHelper.data_migrator(:down, selected_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.migrate
     end
 
     def run(direction, target_version)
-      DataMigrator.new(direction, migrations, target_version).run
+      data_migrator = DataMigrate::RailsHelper.data_migrator(direction, migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.run
     end
 
     def current_version
@@ -40,12 +43,12 @@ module DataMigrate
     end
 
     def migrations_status
-      db_list = DataSchemaMigration.normalized_versions
+      db_list = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
 
       file_list = migration_files.map do |file|
         version, name, scope = parse_migration_filename(file)
         raise ActiveRecord::IllegalMigrationNameError.new(file) unless version
-        version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+        version = DataMigrate::RailsHelper.schema_migration.normalize_migration_number(version)
         status = db_list.delete(version) ? "up" : "down"
         [status, version, (name + scope).humanize]
       end.compact
@@ -60,15 +63,15 @@ module DataMigrate
     private
 
     def get_all_versions
-      if DataMigrate::DataSchemaMigration.table_exists?
-        DataSchemaMigration.normalized_versions.map(&:to_i)
+      if DataMigrate::RailsHelper.data_schema_migration.table_exists?
+        DataMigrate::RailsHelper.data_schema_migration.normalized_versions.map(&:to_i)
       else
         []
       end
     end
 
     def move(direction, steps)
-      migrator = DataMigrator.new(direction, migrations)
+      migrator = DataMigrate::RailsHelper.data_migrator(direction, migrations)
 
       if current_version != 0 && !migrator.current_migration
         raise ActiveRecord::UnknownMigrationVersionError.new(current_version)

data/lib/data_migrate/rails_helper.rb

@@ -0,0 +1,79 @@
+module DataMigrate
+  class RailsHelper
+    class << self
+      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)
+
+        @equal_to_or_higher_than_7_1 = Gem::Dependency.new("railties", ">= 7.1.0.alpha").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+
+      def rails_version_equal_to_or_higher_than_7_0
+        return @rails_version_equal_to_or_higher_than_7_0 if defined?(@rails_version_equal_to_or_higher_than_7_0)
+
+        @rails_version_equal_to_or_higher_than_7_0 = Gem::Dependency.new("railties", ">= 7.0").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+
+      def internal_metadata
+        if rails_version_equal_to_or_higher_than_7_1
+          ActiveRecord::Base.connection.internal_metadata
+        else
+          ActiveRecord::InternalMetadata
+        end
+      end
+
+      def schema_migration
+        if rails_version_equal_to_or_higher_than_7_1
+          ActiveRecord::Base.connection.schema_migration
+        else
+          ActiveRecord::SchemaMigration
+        end
+      end
+
+      def schema_migration_versions
+        if rails_version_equal_to_or_higher_than_7_1
+          schema_migration.versions
+        else
+          schema_migration.all.pluck(:version)
+        end
+      end
+
+      def schema_create_version(version)
+        if rails_version_equal_to_or_higher_than_7_1
+          schema_migration.create_version(version)
+        else
+          schema_migration.create(version: version)
+        end
+      end
+
+      def data_schema_delete_version(version)
+        if rails_version_equal_to_or_higher_than_7_1
+          data_schema_migration.delete_version(version)
+        else
+          data_schema_migration.where(version: version.to_s).delete_all
+        end
+      end
+
+      def data_schema_migration
+        if rails_version_equal_to_or_higher_than_7_1
+          DataMigrate::DataSchemaMigration.new(ActiveRecord::Tasks::DatabaseTasks.migration_connection)
+        else
+          DataMigrate::DataSchemaMigration
+        end
+      end
+
+      def data_migrator(
+        direction,
+        migrations,
+        schema_migration = DataMigrate::RailsHelper.schema_migration,
+        internal_metadata = DataMigrate::RailsHelper.internal_metadata,
+        target_version = nil
+      )
+        if rails_version_equal_to_or_higher_than_7_1
+          DataMigrate::DataMigrator.new(direction, migrations, schema_migration, internal_metadata, target_version)
+        else
+          DataMigrate::DataMigrator.new(direction, migrations, schema_migration, target_version)
+        end
+      end
+    end
+  end
+end

data/lib/data_migrate/schema_dumper.rb

@@ -26,7 +26,7 @@ module DataMigrate
 
     def initialize(connection)
       @connection = connection
-      all_versions =  DataSchemaMigration.normalized_versions
+      all_versions =  DataMigrate::RailsHelper.data_schema_migration.normalized_versions
 
       @version = begin
                     all_versions.max

data/lib/data_migrate/{schema_migration_six.rb → schema_migration.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DataMigrate
   # Helper class to getting access to db schema
   # to allow data/schema combiation tasks
@@ -5,14 +7,14 @@ module DataMigrate
     def self.pending_schema_migrations
       all_migrations = DataMigrate::MigrationContext.new(migrations_paths).migrations
       sort_migrations(
-        ActiveRecord::Migrator.new(:up, all_migrations, ActiveRecord::Base.connection.schema_migration).
+        ActiveRecord::Migrator.new(:up, all_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata).
         pending_migrations.
         map {|m| { version: m.version, kind: :schema }}
       )
     end
 
     def self.run(direction, migration_paths, version)
-      ActiveRecord::MigrationContext.new(migration_paths, ActiveRecord::Base.connection.schema_migration).run(direction, version)
+      ActiveRecord::MigrationContext.new(migration_paths, DataMigrate::RailsHelper.schema_migration).run(direction, version)
     end
 
     def self.sort_migrations(set1, set2 = nil)
@@ -22,9 +24,10 @@ module DataMigrate
 
     def self.migrations_paths
       spec_name = DataMigrate.config.spec_name
-      if spec_name && Rails.version > '6.1'
+      # The positional argument true is to include pre-release versions, such as 7.1.0.alpha
+      if spec_name && Gem::Dependency.new("railties", ">= 7.0").match?("railties", Gem.loaded_specs["railties"].version, true)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: spec_name).migrations_paths
-      elsif spec_name
+      elsif spec_name && Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name).migrations_paths
       else
         Rails.application.config.paths["db/migrate"].to_a

data/lib/data_migrate/{status_service_five.rb → status_service.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DataMigrate
   class StatusService
     class << self
@@ -22,22 +24,18 @@ module DataMigrate
     private
 
     def table_name
-      DataMigrate::DataSchemaMigration.table_name
+      DataMigrate::RailsHelper.data_schema_migration.table_name
     end
 
     def output(stream)
-      unless DataMigrate::DataSchemaMigration.table_exists?
+      unless DataMigrate::RailsHelper.data_schema_migration.table_exists?
         stream.puts "Data migrations table does not exist yet."
         return
       end
 
       # output
-      if ActiveRecord.version >= Gem::Version.new('7.0')
-        stream.puts "\ndatabase: #{ActiveRecord::Base.connection_db_config.configuration_hash[:database]}\n\n"
-      else
-        stream.puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
-      end
-      stream.puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
+      stream.puts "\ndatabase: #{database_name}\n\n"
+      stream.puts "#{"Status".center(8)}  #{"Migration ID".ljust(14)}  Migration Name"
       stream.puts "-" * 50
       db_list.each do |status, version, name|
         stream.puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
@@ -45,6 +43,14 @@ module DataMigrate
       stream.puts
     end
 
+    def database_name
+      if Gem::Dependency.new("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
+        ActiveRecord::Base.connection_db_config.configuration_hash[:database]
+      elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+        ActiveRecord::Base.connection_config[:database]
+      end
+    end
+
     def db_list
       DataMigrate::DataMigrator.migrations_status
     end

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -1,12 +1,10 @@
+# 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
       end
@@ -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,24 +45,14 @@ 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|
@@ -75,7 +63,9 @@ module DataMigrate
           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 +76,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 +93,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.5.0".freeze
+  VERSION = "9.2.0".freeze
 end

data/lib/data_migrate.rb

@@ -1,22 +1,17 @@
 # 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")
 
 module DataMigrate
   def self.root

data/spec/data_migrate/config_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe DataMigrate::Config do
@@ -11,41 +13,42 @@ describe DataMigrate::Config do
 
   describe "data migration path configured" do
     subject { DataMigrate.config.data_migrations_path }
+    let(:data_migrations_path) { "db/awesome/" }
+
     before do
-      @before = DataMigrate.config.data_migrations_path
+      @original_data_migrations_path = DataMigrate.config.data_migrations_path
+
       DataMigrate.configure do |config|
-        config.data_migrations_path = "db/awesome/"
+        config.data_migrations_path = data_migrations_path
       end
     end
 
     after do
       DataMigrate.configure do |config|
-        config.data_migrations_path = @before
+        config.data_migrations_path = @original_data_migrations_path
       end
     end
 
     it "equals the custom data migration path" do
-      is_expected.to eq "db/awesome/"
+      is_expected.to eq(data_migrations_path)
     end
   end
 
   describe "data template path configured" do
     subject { DataMigrate.config.data_template_path }
+    let(:data_template_path) { File.join(DataMigrate.root, "generators", "data_migration", "templates", "data_migration.rb") }
 
     before do
-      @before = DataMigrate.config.data_template_path
+      @original_data_migrations_path = DataMigrate.config.data_template_path
+
       DataMigrate.configure do |config|
         config.data_template_path = data_template_path
       end
     end
 
-    let(:data_template_path) do
-      File.join(DataMigrate.root, "generators", "data_migration", "templates", "data_migration.rb")
-    end
-
     after do
       DataMigrate.configure do |config|
-        config.data_template_path = @before
+        config.data_template_path = @original_data_migrations_path
       end
     end