data_migrate 3.5.0 → 4.0.0

data/lib/data_migrate/schema_dumper.rb

@@ -30,9 +30,7 @@ module DataMigrate
 
     def initialize(connection)
       @connection = connection
-      all_versions = DataMigrate::DataSchemaMigration.all.map do |x|
-        x.version.to_i
-      end
+      all_versions =  DataSchemaMigration.normalized_versions
 
       @version = begin
                     all_versions.max

data/lib/data_migrate/schema_migration.rb

@@ -0,0 +1,31 @@
+module DataMigrate
+  # Helper class to getting access to db schema
+  # to allow data/schema combiation tasks
+  class SchemaMigration
+    def self.pending_schema_migrations
+      all_migrations = DataMigrate::DataMigrator.migrations(migrations_paths)
+      sort_migrations(
+        ActiveRecord::Migrator.new(:up, all_migrations).
+        pending_migrations.
+        map {|m| { version: m.version, kind: :schema }}
+      )
+    end
+
+    def self.run(direction, migration_paths, version)
+      ActiveRecord::Migrator.run(direction, migration_paths, version)
+    end
+
+    def self.sort_migrations(set1, set2 = nil)
+      migrations = set1 + (set2 || [])
+      migrations.sort {|a, b|  sort_string(a) <=> sort_string(b)}
+    end
+
+    def self.migrations_paths
+      Rails.application.config.paths["db/migrate"].to_a
+    end
+
+    def self.sort_string(migration)
+      "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
+    end
+  end
+end

data/lib/data_migrate/schema_migration_five.rb

@@ -0,0 +1,31 @@
+module DataMigrate
+  # Helper class to getting access to db schema
+  # to allow data/schema combiation tasks
+  class SchemaMigration
+    def self.pending_schema_migrations
+      all_migrations = ActiveRecord::MigrationContext.new(migrations_paths).migrations
+      sort_migrations(
+        ActiveRecord::Migrator.new(:up, all_migrations).
+        pending_migrations.
+        map {|m| { version: m.version, kind: :schema }}
+      )
+    end
+
+    def self.run(direction, migration_paths, version)
+      ActiveRecord::MigrationContext.new(migration_paths).run(direction, version)
+    end
+
+    def self.sort_migrations(set1, set2 = nil)
+      migrations = set1 + (set2 || [])
+      migrations.sort {|a, b|  sort_string(a) <=> sort_string(b)}
+    end
+
+    def self.migrations_paths
+      Rails.application.config.paths["db/migrate"].to_a
+    end
+
+    def self.sort_string(migration)
+      "#{migration[:version]}_#{migration[:kind] == :data ? 1 : 0}"
+    end
+  end
+end

data/lib/data_migrate/status_service.rb

@@ -45,7 +45,7 @@ module DataMigrate
     def migration_list(db_list)
       list = []
       db_list.each do |version|
-        list << ["up", version, "*** NO FILE ***"]
+        list << ["up", version, "********** NO FILE *************"]
       end
       list
     end

data/lib/data_migrate/status_service_five.rb

@@ -0,0 +1,48 @@
+module DataMigrate
+  class StatusService
+    class << self
+      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT)
+        new(connection).dump(stream)
+        stream
+      end
+    end
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def root_folder
+      Rails.root
+    end
+
+    def dump(stream)
+      output(stream)
+    end
+
+    private
+
+    def table_name
+      DataMigrate::DataSchemaMigration.table_name
+    end
+
+    def output(stream)
+      unless DataMigrate::DataSchemaMigration.table_exists?
+        stream.puts "Data migrations table does not exist yet."
+        return
+      end
+
+      # output
+      stream.puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\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}"
+      end
+      stream.puts
+    end
+
+    def db_list
+      DataMigrate::DataMigrator.migrations_status
+    end
+  end
+end

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -0,0 +1,25 @@
+module DataMigrate
+  module Tasks
+    module DataMigrateTasks
+      extend self
+      def migrations_paths
+        @migrations_paths ||= begin
+          if Rails.application && Rails.application.paths["data/migrate"]
+            Rails.application.paths["data/migrate"].to_a
+          end
+        end
+      end
+
+      def migrate
+        DataMigrate::DataMigrator.assure_data_schema_table
+        target_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR == 2
+          DataMigrate::MigrationContext.new(migrations_paths).migrate(target_version)
+        else
+          paths = migrations_paths || "db/data/"
+          DataMigrate::DataMigrator.migrate(paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+        end
+      end
+    end
+  end
+end

data/lib/data_migrate/version.rb

@@ -1,3 +1,3 @@
 module DataMigrate
-  VERSION = "3.5.0".freeze
+  VERSION = "4.0.0".freeze
 end

data/lib/generators/data_migration/data_migration_generator.rb

@@ -1,6 +1,7 @@
 require "generators/data_migrate"
 require "rails/generators"
 require "rails/generators/active_record/migration"
+require "rails/generators/migration"
 
 module DataMigrate
   module Generators
@@ -8,7 +9,6 @@ module DataMigrate
       namespace "data_migration"
       include ActiveRecord::Generators::Migration
 
-
       argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
       def create_data_migration
@@ -28,6 +28,8 @@ module DataMigrate
       def migration_base_class_name
         if ActiveRecord.version >= Gem::Version.new("5.0")
           "ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
+        elsif ActiveRecord.version >= Gem::Version.new("5.2")
+          "DataMigrate::MigrationContext"
         else
           "ActiveRecord::Migration"
         end

data/spec/data_migrate/data_migrator_spec.rb

@@ -11,7 +11,7 @@ describe DataMigrate::DataMigrator do
 
   describe :assure_data_schema_table do
     before do
-      expect(subject).to receive(:db_config) { db_config }.at_least(:once)
+      allow(subject).to receive(:db_config) { db_config }.at_least(:once)
       ActiveRecord::Base.establish_connection(db_config)
     end
 
@@ -30,18 +30,6 @@ describe DataMigrate::DataMigrator do
     end
   end
 
-  describe :schema_migrations_table_name do
-    it "returns correct table name" do
-      expect(subject.schema_migrations_table_name).to eq("data_migrations")
-    end
-  end
-
-  describe :migrations_path do
-    it "returns correct migrations path" do
-      expect(subject.migrations_path).to eq("db/data")
-    end
-  end
-
   describe :match do
     context "when the file does not match" do
       it "returns nil" do

data/spec/data_migrate/{data_schema_spec.rb → data_spec.rb}

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "spec_helper"
+
 describe DataMigrate::Data do
   let(:subject) { DataMigrate::Data }
   let(:db_config) do
@@ -27,10 +29,10 @@ describe DataMigrate::Data do
 
   describe :define do
     before do
-      expect(DataMigrate::DataMigrator).
-        to receive(:db_config) { db_config }.at_least(:once)
+      allow(DataMigrate::DataMigrator).
+        to receive(:db_config) { db_config }
       ActiveRecord::Base.establish_connection(db_config)
-      ActiveRecord::Base.connection.initialize_schema_migrations_table
+      ActiveRecord::SchemaMigration.create_table
     end
 
     after do
@@ -66,11 +68,11 @@ describe DataMigrate::Data do
 
         sql_select = <<-SQL
           SELECT version
-          FROM #{DataMigrate::DataMigrator.schema_migrations_table_name}
+          FROM #{DataMigrate::DataSchemaMigration.table_name}
         SQL
 
         db_list_data = ActiveRecord::Base.connection.
-                       select_values(sql_select).map(&:to_i)
+          select_values(sql_select).map(&:to_i)
         expect(db_list_data).to match_array(
           [fixture_file_timestamps[0], fixture_file_timestamps[1]].map(&:to_i)
         )

data/spec/data_migrate/database_tasks_spec.rb

@@ -1,7 +1,37 @@
 # frozen_string_literal: true
 
+require "spec_helper"
+
 describe DataMigrate::DatabaseTasks do
   let(:subject) { DataMigrate::DatabaseTasks }
+  let(:migration_path) {
+    if Rails::VERSION::MAJOR == 5
+      if Rails::VERSION::MINOR == 2
+        "spec/db/migrate/5.2"
+      else
+        "spec/db/migrate/5.0"
+      end
+    else
+      "spec/db/migrate/4.2"
+    end
+  }
+  let(:data_migrations_path) {
+    if Rails::VERSION::MAJOR == 5
+      if Rails::VERSION::MINOR == 2
+        "spec/db/data"
+      else
+        "spec/db/5.0"
+      end
+    else
+      "spec/db/4.2"
+    end
+  }
+  let(:db_config) do
+    {
+      adapter: "sqlite3",
+      database: "spec/db/test.db"
+    }
+  end
 
   before do
     # In a normal Rails installation, db_dir would defer to
@@ -10,9 +40,75 @@ describe DataMigrate::DatabaseTasks do
     allow(subject).to receive(:db_dir).and_return("db")
   end
 
+  before do
+    allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:migrations_paths) {
+      data_migrations_path
+    }
+    allow(DataMigrate::DataMigrator).to receive(:db_config) { db_config }
+    ActiveRecord::Base.establish_connection(db_config)
+  end
+
   describe :data_schema_file do
     it "returns the correct data schema file path" do
       expect(subject.data_schema_file).to eq "db/data_schema.rb"
     end
   end
+
+  context "migrations" do
+    after do
+      begin
+        ActiveRecord::Migration.drop_table("data_migrations")
+      rescue ActiveRecord::StatementInvalid
+      end
+      ActiveRecord::Migration.drop_table("schema_migrations")
+    end
+
+    before do
+      ActiveRecord::Base.establish_connection(db_config)
+      ActiveRecord::SchemaMigration.create_table
+
+      allow(DataMigrate::SchemaMigration).to receive(:migrations_paths) {
+        migration_path
+      }
+      allow(DataMigrate::DatabaseTasks).to receive(:data_migrations_path) {
+        data_migrations_path
+      }.at_least(:once)
+      allow(DataMigrate::DatabaseTasks).to receive(:schema_migrations_path) {
+        migration_path
+      }.at_least(:once)
+    end
+
+    describe :past_migrations do
+      it do
+        subject.forward
+        m = subject.past_migrations
+        expect(m.count).to eq 1
+        expect(m.first[:version]).to eq 20091231235959
+      end
+
+      it "shows nothing without any migrations" do
+        m = subject.past_migrations
+        expect(m.count).to eq 0
+      end
+    end
+
+    describe :forward do
+
+      it "run forward default amount of times" do
+        subject.forward
+        versions = DataMigrate::DataSchemaMigration.normalized_versions
+        expect(versions.count).to eq(1)
+      end
+
+      it "run forward defined number of times" do
+        subject.forward(2)
+        versions = DataMigrate::DataSchemaMigration.normalized_versions
+        expect(versions.count).to eq(1)
+        expect(versions.first).to eq "20091231235959"
+        versions = ActiveRecord::SchemaMigration.normalized_versions
+        expect(versions.count).to eq(1)
+        expect(versions.first).to eq "20131111111111"
+      end
+    end
+  end
 end

data/spec/data_migrate/migration_context_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe DataMigrate::DataMigrator do
+  let(:context) {
+    DataMigrate::MigrationContext.new("spec/db/data")
+  }
+
+  before do
+    unless Rails::VERSION::MAJOR == 5 and
+           Rails::VERSION::MINOR == 2
+      skip("Tests are only applicable for Rails 5.2")
+    end
+  end
+
+  after do
+    begin
+      ActiveRecord::Migration.drop_table("data_migrations")
+    rescue StandardError
+      nil
+    end
+  end
+
+  let(:db_config) do
+    {
+      adapter: "sqlite3",
+      database: "spec/db/test.db"
+    }
+  end
+
+  describe :migrate do
+    before do
+      ActiveRecord::Base.establish_connection(db_config)
+      ActiveRecord::SchemaMigration.create_table
+    end
+
+    it "migrates existing file" do
+      context.migrate(nil)
+      context.migrations_status
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      expect(versions.count).to eq(2)
+      expect(versions).to include("20091231235959")
+      expect(versions).to include("20171231235959")
+    end
+
+    it "undo migration" do
+      context.migrate(nil)
+      context.run(:down, 20171231235959)
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      expect(versions.count).to eq(1)
+      expect(versions).to include("20091231235959")
+    end
+
+    it "does not do anything if migration is undone twice" do
+      context.migrate(nil)
+      expect {
+        context.run(:down, 20171231235959)
+      }.to output(/Undoing SuperUpdate/).to_stdout
+      expect {
+        context.run(:down, 20171231235959)
+      }.not_to output(/Undoing SuperUpdate/).to_stdout
+    end
+
+    it "runs a specific migration" do
+      context.run(:up, 20171231235959)
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      expect(versions.count).to eq(1)
+      expect(versions).to include("20171231235959")
+    end
+
+    it "does not do anything if migration is ran twice" do
+      expect {
+        context.run(:up, 20171231235959)
+      }.to output(/Doing SuperUpdate/).to_stdout
+      expect {
+        context.run(:down, 20171231235959)
+      }.not_to output(/Doing SuperUpdate/).to_stdout
+    end
+
+    it "alerts for an invalid specific migration" do
+      expect {
+        context.run(:up, 201712312)
+      }.to raise_error(
+        ActiveRecord::UnknownMigrationVersionError,
+        /No migration with version number 201712312/
+      )
+    end
+
+    it "rolls back latest migration" do
+      context.migrate(nil)
+      expect {
+        context.rollback
+      }.to output(/Undoing SuperUpdate/).to_stdout
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      expect(versions.count).to eq(1)
+      expect(versions).to include("20091231235959")
+    end
+
+    it "rolls back 2 migrations" do
+      context.migrate(nil)
+      expect {
+        context.rollback(2)
+      }.to output(/Undoing SomeName/).to_stdout
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      expect(versions.count).to eq(0)
+    end
+  end
+end