data_migrate 3.0.1 → 4.0.0

data/lib/data_migrate/database_tasks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module DataMigrate
+  ##
+  # This class extends DatabaseTasks to add a data_schema_file method.
+  class DatabaseTasks
+    extend ActiveRecord::Tasks::DatabaseTasks
+
+    def self.data_schema_file
+      File.join(db_dir, "data_schema.rb")
+    end
+
+    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
+          ActiveRecord::Migration.write("== %s %s" % ["Data", "=" * 71])
+          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])
+        end
+      end
+    end
+
+    def self.data_migrations_path
+      "db/data/"
+    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, 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
+    end
+
+  end
+end

data/lib/data_migrate/migration.rb

@@ -11,7 +11,7 @@ module DataMigrate
       end
 
       def table_name
-        ActiveRecord::Base.table_name_prefix + 'data_migrations' + ActiveRecord::Base.table_name_suffix
+        ActiveRecord::Base.table_name_prefix + "data_migrations" + ActiveRecord::Base.table_name_suffix
       end
 
       def index_name

data/lib/data_migrate/migration_context.rb

@@ -0,0 +1,90 @@
+module DataMigrate
+  class MigrationContext < ActiveRecord::MigrationContext
+    def initialize(migrations_paths = "db/data")
+      @migrations_paths = migrations_paths || "db/data"
+    end
+
+    def up(target_version = nil)
+      selected_migrations = if block_given?
+                              migrations.select { |m| yield m }
+                            else
+                              migrations
+                            end
+
+      DataMigrator.new(:up, selected_migrations, target_version).migrate
+    end
+
+    def down(target_version = nil)
+      selected_migrations =
+        if block_given?
+          migrations.select { |m| yield m }
+        else
+          migrations
+        end
+
+      DataMigrator.new(:down, selected_migrations, target_version).migrate
+    end
+
+    def run(direction, target_version)
+      DataMigrator.new(direction, migrations, target_version).run
+    end
+
+    def current_version
+      get_all_versions.max || 0
+    rescue ActiveRecord::NoDatabaseError
+    end
+
+    def migration_files
+      paths = Array(migrations_paths)
+      Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+    end
+
+    def migrations_status
+      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 = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+        status = db_list.delete(version) ? "up" : "down"
+        [status, version, (name + scope).humanize]
+      end.compact
+
+      db_list.map! do |version|
+        ["up", version, "********** NO FILE **********"]
+      end
+
+      (db_list + file_list).sort_by { |_, version, _| version }
+    end
+
+    private
+
+    def get_all_versions
+      if DataMigrate::DataSchemaMigration.table_exists?
+        DataSchemaMigration.normalized_versions.map(&:to_i)
+      else
+        []
+      end
+    end
+
+    def move(direction, steps)
+      migrator = DataMigrator.new(direction, migrations)
+
+      if current_version != 0 && !migrator.current_migration
+        raise ActiveRecord::UnknownMigrationVersionError.new(current_version)
+      end
+
+      start_index =
+        if current_version.zero?
+          0
+        else
+          migrator.migrations.index(migrator.current_migration)
+        end
+
+      finish = migrator.migrations[start_index + steps]
+      version = finish ? finish.version : 0
+      send(direction, version)
+    end
+
+  end
+end

data/lib/data_migrate/migration_five.rb

@@ -0,0 +1,26 @@
+module DataMigrate
+  class MigrationFive < ::ActiveRecord::Migration[5.0]
+
+    class << self
+      def check_pending!(connection = ::ActiveRecord::Base.connection)
+        raise ActiveRecord::PendingMigrationError if DataMigrator::Migrator.needs_migration?(connection)
+      end
+
+      def migrate(direction)
+        new.migrate direction
+      end
+
+      def table_name
+        ActiveRecord::Base.table_name_prefix + 'data_migrations' + ActiveRecord::Base.table_name_suffix
+      end
+
+      def index_name
+        "#{table_name_prefix}unique_data_migrations#{table_name_suffix}"
+      end
+    end
+
+    def initialize(name = self.class.name, version = nil)
+      super(name, version)
+    end
+  end
+end

data/lib/data_migrate/railtie.rb

@@ -1,5 +1,5 @@
 module DataMigrate
-  class Railtie < Rails::Railtie
+  class Railtie < ::Rails::Railtie
     generators = config.respond_to?(:app_generators) ? config.app_generators : config.generators
 
     rake_tasks do

data/lib/data_migrate/schema_dumper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DataMigrate
+  ##
+  # Provides the capability to write the current data schema version to
+  # the data_schema file Based on ActiveRecord::SchemaDumper
+  class SchemaDumper
+    private_class_method :new
+
+    class << self
+      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT)
+        new(connection).dump(stream)
+        stream
+      end
+    end
+
+    def dump(stream)
+      define_params = @version ? "version: #{@version}" : ""
+
+      if stream.respond_to?(:external_encoding) && stream.external_encoding
+        stream.puts "# encoding: #{stream.external_encoding.name}"
+      end
+
+      stream.puts "DataMigrate::Data.define(#{define_params})"
+
+      stream
+    end
+
+    private
+
+    def initialize(connection)
+      @connection = connection
+      all_versions =  DataSchemaMigration.normalized_versions
+
+      @version = begin
+                    all_versions.max
+                  rescue StandardError
+                    0
+                  end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+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)
+      unless @connection.table_exists?(table_name)
+        stream.puts "Data migrations table does not exist yet."
+        return
+      end
+      sql = "SELECT version FROM #{DataMigrate::DataMigrator.schema_migrations_table_name}"
+      db_list = ActiveRecord::Base.connection.select_values(sql)
+      output(stream, db_list)
+    end
+
+    private
+
+    def table_name
+      DataMigrate::DataMigrator.schema_migrations_table_name
+    end
+
+    def output(stream, db_list)
+      stream.puts "#{"Status".center(8)}  #{"Migration ID".ljust(14)}  Migration Name"
+      stream.puts "-" * 50
+      list =  migration_files(db_list) + migration_list(db_list)
+      list.sort! {|line1, line2| line1[1] <=> line2[1]}
+      list.each do |file|
+        stream.puts "#{file[0].center(8)}  #{file[1].ljust(14)}  #{file[2]}"
+      end
+      stream.puts
+    end
+
+    def migration_list(db_list)
+      list = []
+      db_list.each do |version|
+        list << ["up", version, "********** NO FILE *************"]
+      end
+      list
+    end
+
+    def migration_files(db_list)
+      file_list = []
+      Dir.foreach(File.join(root_folder, "db", "data")) do |file|
+        # only files matching "20091231235959_some_name.rb" pattern
+        if match_data = DataMigrate::DataMigrator.match(file)
+          status = db_list.delete(match_data[1]) ? "up" : "down"
+          file_list << [status, match_data[1], match_data[2].humanize]
+        end
+      end
+      file_list
+    end
+  end
+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.0.1'.freeze
+  VERSION = "4.0.0".freeze
 end

data/lib/data_migrate.rb

@@ -1,4 +1,30 @@
-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', 'migration')
-require File.join(File.dirname(__FILE__), 'data_migrate', 'railtie')
+# frozen_string_literal: true
+
+if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR == 2
+  require File.join(File.dirname(__FILE__), "data_migrate", "data_migrator_five")
+else
+  require File.join(File.dirname(__FILE__), "data_migrate", "data_migrator")
+end
+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")
+if Rails::VERSION::MAJOR == 5 &&  Rails::VERSION::MINOR == 2
+  require File.join(File.dirname(__FILE__), "data_migrate", "status_service_five")
+  require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration_five")
+else
+  require File.join(File.dirname(__FILE__), "data_migrate", "status_service")
+  require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration")
+end
+if Rails::VERSION::MAJOR == 5
+  if  Rails::VERSION::MINOR == 2
+    require File.join(File.dirname(__FILE__), "data_migrate", "migration_context")
+  else
+    require File.join(File.dirname(__FILE__), "data_migrate", "migration_five")
+  end
+else
+  require File.join(File.dirname(__FILE__), "data_migrate", "migration")
+end
+require File.join(File.dirname(__FILE__), "data_migrate", "railtie")
+require File.join(File.dirname(__FILE__), "data_migrate", "tasks/data_migrate_tasks")

data/lib/generators/data_migration/data_migration_generator.rb

@@ -1,38 +1,39 @@
-require 'generators/data_migrate'
-require 'rails/generators'
-require 'rails/generators/migration'
+require "generators/data_migrate"
+require "rails/generators"
+require "rails/generators/active_record/migration"
+require "rails/generators/migration"
 
 module DataMigrate
   module Generators
     class DataMigrationGenerator < Rails::Generators::NamedBase
       namespace "data_migration"
-      include Rails::Generators::Migration
+      include ActiveRecord::Generators::Migration
 
-      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
       def create_data_migration
         set_local_assigns!
-        migration_template 'data_migration.rb', "db/data/#{file_name}.rb"
+        migration_template "data_migration.rb", "db/data/#{file_name}.rb"
       end
 
       protected
 
-      attr_reader :migration_action
-
-      def self.next_migration_number(dirname)
-        if ActiveRecord::Base.timestamped_migrations
-          Time.new.utc.strftime("%Y%m%d%H%M%S")
-        else
-          "%.3d" % (current_migration_number(dirname) + 1)
-        end
-      end
-
       def set_local_assigns!
         if file_name =~ /^(add|remove)_.*_(?:to|from)_(.*)/
           @migration_action = $1
           @table_name       = $2.pluralize
         end
       end
+
+      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
+      end
     end
   end
 end

data/lib/generators/data_migration/templates/data_migration.rb

@@ -1,8 +1,8 @@
-class <%= migration_class_name %> < ActiveRecord::Migration
-  def self.up
+class <%= migration_class_name %> < <%= migration_base_class_name %>
+  def up
   end
 
-  def self.down
+  def down
     raise ActiveRecord::IrreversibleMigration
   end
-end
+end

data/spec/data_migrate/data_migrator_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe DataMigrate::DataMigrator do
+  let(:subject) { DataMigrate::DataMigrator }
+  let(:db_config) do
+    {
+      adapter: "sqlite3",
+      database: "spec/db/test.db"
+    }
+  end
+
+  describe :assure_data_schema_table do
+    before do
+      allow(subject).to receive(:db_config) { db_config }.at_least(:once)
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+
+    after do
+      ActiveRecord::Migration.drop_table("data_migrations")
+    end
+
+    it do
+      expect(
+        ActiveRecord::Base.connection.table_exists?("data_migrations")
+      ).to eq false
+      subject.assure_data_schema_table
+      expect(
+        ActiveRecord::Base.connection.table_exists?("data_migrations")
+      ).to eq true
+    end
+  end
+
+  describe :match do
+    context "when the file does not match" do
+      it "returns nil" do
+        expect(subject.match("not_a_data_migration_file")).to be_nil
+      end
+    end
+
+    context "when the file matches" do
+      it "returns a valid MatchData object" do
+        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"
+        expect(match_data[2]).to eq "some_name"
+      end
+    end
+  end
+end

data/spec/data_migrate/data_schema_migration_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe DataMigrate::DataSchemaMigration do
+  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 index name" do
+      expect(subject.index_name).to eq("unique_data_migrations")
+    end
+  end
+end