data_migrate 9.4.2 → 10.0.0.rc1

data/lib/data_migrate/database_tasks.rb

@@ -5,143 +5,67 @@ require "data_migrate/config"
 module DataMigrate
   ##
   # This class extends DatabaseTasks to add a schema_file method.
-  module DatabaseTasks
+  class DatabaseTasks
     extend ActiveRecord::Tasks::DatabaseTasks
-    extend self
-
-    # These method are only introduced in Rails 7.1
-    unless respond_to?(:with_temporary_connection_for_each)
-      def with_temporary_connection_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_connection(db_config, &block)
-        else
-          ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
-            with_temporary_connection(db_config, &block)
-          end
-        end
+
+    class << self
+      def schema_file_type(_format = nil)
+        "data_schema.rb"
       end
 
-      def with_temporary_connection(db_config) # :nodoc:
-        with_temporary_pool(db_config) do |pool|
-          yield pool.connection
+      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
-      end
 
-      def migration_class # :nodoc:
-        ActiveRecord::Base
+        ENV["DATA_SCHEMA"] || File.join(db_dir, filename)
       end
 
-      def migration_connection # :nodoc:
-        migration_class.connection
+      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
 
-      private def with_temporary_pool(db_config)
-        original_db_config = migration_class.connection_db_config
-        pool = migration_class.connection_handler.establish_connection(db_config)
-
-        yield pool
-      ensure
-        migration_class.connection_handler.establish_connection(original_db_config)
+      def pending_migrations
+        sort_migrations(
+          pending_schema_migrations,
+          pending_data_migrations
+        )
       end
-    end
-
-    def db_configs_with_versions
-      db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
-
-      with_temporary_connection_for_each do |conn|
-        db_config = conn.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
+      def sort_migrations(*migrations)
+        migrations.flatten.sort { |a, b|  sort_string(a) <=> sort_string(b) }
       end
 
-      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)}"
+      def sort_string migration
+        "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
       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 data_migrations_path
+        ::DataMigrate.config.data_migrations_path
       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
 
-    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]
-        )
+      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
     end
 
-    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
+    def self.forward(step = 1)
+      DataMigrate::DataMigrator.assure_data_schema_table
       migrations = pending_migrations.reverse.pop(step).reverse
       migrations.each do | pending_migration |
         if pending_migration[:kind] == :data
@@ -154,92 +78,22 @@ module DataMigrate
       end
     end
 
-    def pending_data_migrations
+    def self.pending_data_migrations
       data_migrations = DataMigrate::DataMigrator.migrations(data_migrations_path)
-      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 } }
-        )
+      sort_migrations(DataMigrate::DataMigrator.new(:up, data_migrations ).
+        pending_migrations.map {|m| { version: m.version, name: m.name, kind: :data }})
     end
 
-    def pending_schema_migrations
+    def self.pending_schema_migrations
       ::DataMigrate::SchemaMigration.pending_schema_migrations
     end
 
-    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
+    def self.past_migrations(sort = nil)
+      data_versions = DataMigrate::DataSchemaMigration.table_exists? ? DataMigrate::DataSchemaMigration.normalized_versions : []
+      schema_versions = ActiveRecord::SchemaMigration.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
-
-      db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
-
-      schema_mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions(db_configs)
-      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 db_config.primary?
-
-        with_temporary_pool(db_config) do
-          begin
-            database_initialized = migration_connection.schema_migration.table_exists?
-          rescue ActiveRecord::NoDatabaseError
-            create(db_config)
-            retry
-          end
-
-          unless database_initialized
-            if File.exist?(schema_dump_path(db_config))
-              load_schema(db_config, ActiveRecord.schema_format, nil)
-              load_schema_current(
-                :ruby,
-                ENV["DATA_SCHEMA"]
-              )
-            end
-
-            seed = true
-          end
-
-          migrate_with_data
-          if ActiveRecord.dump_schema_after_migration
-            dump_schema(db_config)
-            DataMigrate::Tasks::DataMigrateTasks.dump
-          end
-        end
-      end
-
-      load_seed if seed
-    end
   end
 end

data/lib/data_migrate/legacy_migrator.rb

@@ -0,0 +1,22 @@
+module DataMigrate
+  class LegacyMigrator
+    def initialize(migrations_paths = "db/data")
+      @migrations_paths = migrations_paths || "db/data"
+    end
+
+    def migrate
+      dates =
+        DataMigrate::DataMigrator.migrations(@migrations_paths).collect(&:version)
+      legacy = ActiveRecord::SchemaMigration.where(version: dates)
+      legacy.each do |v|
+        begin
+          version = v.version
+          puts "Creating #{version} in data schema"
+          DataMigrate::DataSchemaMigration.create(version: version)
+        rescue ActiveRecord::RecordNotUnique
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/data_migrate/migration_context.rb

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

data/lib/data_migrate/schema_dumper.rb

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

data/lib/data_migrate/schema_migration.rb

@@ -7,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, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata).
+        ActiveRecord::Migrator.new(:up, all_migrations, ActiveRecord::Base.connection.schema_migration).
         pending_migrations.
         map {|m| { version: m.version, kind: :schema }}
       )
     end
 
     def self.run(direction, migration_paths, version)
-      ActiveRecord::MigrationContext.new(migration_paths, DataMigrate::RailsHelper.schema_migration).run(direction, version)
+      ActiveRecord::MigrationContext.new(migration_paths, ActiveRecord::Base.connection.schema_migration).run(direction, version)
     end
 
     def self.sort_migrations(set1, set2 = nil)
@@ -24,10 +24,9 @@ module DataMigrate
 
     def self.migrations_paths
       spec_name = DataMigrate.config.spec_name
-      # 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)
+      if spec_name && Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: spec_name).migrations_paths
-      elsif spec_name && Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+      elsif spec_name && Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].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.rb

@@ -24,11 +24,11 @@ module DataMigrate
     private
 
     def table_name
-      DataMigrate::RailsHelper.data_schema_migration.table_name
+      DataMigrate::DataSchemaMigration.table_name
     end
 
     def output(stream)
-      unless DataMigrate::RailsHelper.data_schema_migration.table_exists?
+      unless DataMigrate::DataSchemaMigration.table_exists?
         stream.puts "Data migrations table does not exist yet."
         return
       end
@@ -44,9 +44,9 @@ module DataMigrate
     end
 
     def database_name
-      if Gem::Dependency.new("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
+      if Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
         ActiveRecord::Base.connection_db_config.configuration_hash[:database]
-      elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+      elsif Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
         ActiveRecord::Base.connection_config[:database]
       end
     end

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -9,9 +9,9 @@ module DataMigrate
         @migrations_paths ||= DataMigrate.config.data_migrations_path
       end
 
-      def dump
+      def dump(db_config)
         if dump_schema_after_migration?
-          filename = DataMigrate::DatabaseTasks.schema_file
+          filename = DataMigrate::DatabaseTasks.dump_filename(spec_name(db_config), ActiveRecord::Base.schema_format)
           ActiveRecord::Base.establish_connection(DataMigrate.config.db_configuration) if DataMigrate.config.db_configuration
           File.open(filename, "w:utf-8") do |file|
             DataMigrate::SchemaDumper.dump(ActiveRecord::Base.connection, file)
@@ -22,7 +22,7 @@ module DataMigrate
       def migrate
         target_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
 
-        DataMigrate::DataMigrator.create_data_schema_table
+        DataMigrate::DataMigrator.assure_data_schema_table
         DataMigrate::MigrationContext.new(migrations_paths).migrate(target_version)
       end
 
@@ -44,15 +44,16 @@ module DataMigrate
         end
       end
 
-      def status
-        DataMigrate::StatusService.dump
+      def status(db_config)
+        puts "\ndatabase: #{spec_name(db_config)}\n\n"
+        DataMigrate::StatusService.dump(ActiveRecord::Base.connection)
       end
 
-      def status_with_schema
+      def status_with_schema(db_config)
         db_list_data = ActiveRecord::Base.connection.select_values(
-          "SELECT version FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}"
+          "SELECT version FROM #{DataMigrate::DataSchemaMigration.table_name}"
         )
-        db_list_schema = DataMigrate::RailsHelper.schema_migration_versions
+        db_list_schema = ActiveRecord::SchemaMigration.all.pluck(:version)
         file_list = []
 
         Dir.foreach(File.join(Rails.root, migrations_paths)) do |file|
@@ -76,7 +77,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: #{database_name}\n\n"
+        puts "\ndatabase: #{spec_name(db_config)}\n\n"
         puts "#{"Status".center(8)} #{"Type".center(8)}  #{"Migration ID".ljust(14)} Migration Name"
         puts "-" * 60
         file_list.each do |file|
@@ -93,11 +94,11 @@ module DataMigrate
 
       private
 
-      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]
+      def spec_name(db_config)
+        if Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
+          db_config.name
+        elsif Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
+          db_config.spec_name
         end
       end
     end

data/lib/data_migrate/version.rb

@@ -1,3 +1,3 @@
 module DataMigrate
-  VERSION = "9.4.2".freeze
+  VERSION = "10.0.0.rc1".freeze
 end

data/lib/data_migrate.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-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")
@@ -10,9 +9,9 @@ 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")
 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/spec/data_migrate/data_migrator_spec.rb

@@ -3,8 +3,7 @@
 require "spec_helper"
 
 describe DataMigrate::DataMigrator do
-  let(:described_class) { DataMigrate::DataMigrator }
-
+  let(:subject) { DataMigrate::DataMigrator }
   let(:db_config) do
     {
       adapter: "sqlite3",
@@ -14,8 +13,8 @@ describe DataMigrate::DataMigrator do
 
   before do
     ActiveRecord::Base.establish_connection(db_config)
-    DataMigrate::RailsHelper.schema_migration.create_table
-    DataMigrate::RailsHelper.data_schema_migration.create_table
+    ::ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
   after do
@@ -24,24 +23,22 @@ describe DataMigrate::DataMigrator do
   end
 
   describe ".load_migrated" do
-    let(:migrator) { DataMigrate::RailsHelper.data_migrator(:up, []) }
-
     it "loads migrated versions" do
-      DataMigrate::RailsHelper.data_schema_migration.create_version(20090000000000)
-      DataMigrate::RailsHelper.schema_create_version(20100000000000)
-      DataMigrate::RailsHelper.data_schema_migration.create_version(20110000000000)
-      DataMigrate::RailsHelper.schema_create_version(20120000000000)
-      migrated = migrator.load_migrated
+      DataMigrate::DataSchemaMigration.create(version: 20090000000000)
+      ::ActiveRecord::SchemaMigration.create(version: 20100000000000)
+      DataMigrate::DataSchemaMigration.create(version: 20110000000000)
+      ::ActiveRecord::SchemaMigration.create(version: 20120000000000)
+      migrated = subject.new(:up, []).load_migrated
       expect(migrated.count).to eq 2
       expect(migrated).to include 20090000000000
       expect(migrated).to include 20110000000000
     end
   end
 
-  describe :create_data_schema_table do
+  describe :assure_data_schema_table do
     it "creates the data_migrations table" do
       ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-      described_class.create_data_schema_table
+      subject.assure_data_schema_table
       expect(
         ActiveRecord::Base.connection.table_exists?("data_migrations")
       ).to eq true
@@ -50,7 +47,7 @@ describe DataMigrate::DataMigrator do
 
   describe "#migrations_status" do
     it "returns all migrations statuses" do
-      status = described_class.migrations_status
+      status = subject.migrations_status
       expect(status.length).to eq 2
       expect(status.first).to eq ["down", "20091231235959", "Some name"]
       expect(status.second).to eq ["down", "20171231235959", "Super update"]
@@ -60,19 +57,19 @@ describe DataMigrate::DataMigrator do
   describe :match do
     context "when the file does not match" do
       it "returns nil" do
-        expect(described_class.match("not_a_data_migration_file")).to be_nil
+        expect(subject.match("not_a_data_migration_file")).to be_nil
       end
     end
 
     context "when the file doesn't end in .rb" do
       it "returns nil" do
-        expect(described_class.match("20091231235959_some_name.rb.un~")).to be_nil
+        expect(subject.match("20091231235959_some_name.rb.un~")).to be_nil
       end
     end
 
     context "when the file matches" do
       it "returns a valid MatchData object" do
-        match_data = described_class.match("20091231235959_some_name.rb")
+        match_data = subject.match("20091231235959_some_name.rb")
 
         expect(match_data[0]).to eq "20091231235959_some_name.rb"
         expect(match_data[1]).to eq "20091231235959"

data/spec/data_migrate/data_schema_migration_spec.rb

@@ -1,33 +1,16 @@
 require 'spec_helper'
 
 describe DataMigrate::DataSchemaMigration do
-  if DataMigrate::RailsHelper.rails_version_equal_to_or_higher_than_7_1
-    let(:connection) { double(:connection) }
-    let(:subject) { DataMigrate::DataSchemaMigration.new(connection) }
-
-    describe :table_name do
-      it "returns correct table name" do
-        expect(subject.table_name).to eq("data_migrations")
-      end
-    end
-
-    describe :index_name do
-      it "returns correct primary key name" do
-        expect(subject.primary_key).to eq("version")
-      end
-    end
-  else
-    let(:subject) { DataMigrate::DataSchemaMigration }
-    describe :table_name do
-      it "returns correct table name" do
-        expect(subject.table_name).to eq("data_migrations")
-      end
+  let(:subject) { DataMigrate::DataSchemaMigration }
+  describe :table_name do
+    it "returns correct table name" do
+      expect(subject.table_name).to eq("data_migrations")
     end
+  end
 
-    describe :index_name do
-      it "returns correct primary key name" do
-        expect(subject.primary_key).to eq("version")
-      end
+  describe :index_name do
+    it "returns correct primary key name" do
+      expect(subject.primary_key).to eq("version")
     end
   end
 end

data/spec/data_migrate/data_spec.rb

@@ -55,7 +55,7 @@ describe DataMigrate::Data do
 
         sql_select = <<-SQL
           SELECT version
-          FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}
+          FROM #{DataMigrate::DataSchemaMigration.table_name}
         SQL
 
         db_list_data = ActiveRecord::Base.connection.