lazy_migrate 0.1.1 → 0.3.0

data/lazy_migrate.gemspec

@@ -24,13 +24,19 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = "bin/exe"
+  spec.executables   = ['lazy_migrate']
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency 'pry-byebug', '~> 3.9.0'
+  spec.add_development_dependency "rails", "~> 6.0.3"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'sqlite3', '~> 1.4.2'
+  spec.add_development_dependency 'sorbet'
 
+  spec.add_runtime_dependency 'sorbet-runtime'
   spec.add_runtime_dependency 'tty-prompt', '~> 0.22.0'
 end

data/lib/lazy_migrate.rb

@@ -1,10 +1,14 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "lazy_migrate/version"
-require "lazy_migrate/migrator"
+require "lazy_migrate/client"
 
 module LazyMigrate
+  extend T::Sig
+
+  sig { void }
   def self.run
-    Migrator.run
+    Client.run
   end
 end

data/lib/lazy_migrate/client.rb

@@ -0,0 +1,123 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'active_record'
+require 'rails'
+require 'lazy_migrate/migrator_adapter_factory'
+
+module LazyMigrate
+  class Client
+    class << self
+      MIGRATE = 'migrate'
+      ROLLBACK = 'rollback'
+      UP = 'up'
+      DOWN = 'down'
+      REDO = 'redo'
+      BRING_TO_TOP = 'bring to top'
+
+      def run
+        migrator_adapter = MigratorAdapterFactory.create_migrator_adapter
+
+        loop do
+          catch(:done) do
+            on_done = -> { throw :done }
+
+            prompt.ok("\nDatabase: #{ActiveRecord::Base.connection_config[:database]}\n")
+
+            select_migration_prompt(on_done: on_done, migrator_adapter: migrator_adapter)
+          end
+        end
+      rescue TTY::Reader::InputInterrupt
+        puts
+      end
+
+      private
+
+      def prompt
+        TTY::Prompt.new(active_color: :bright_green)
+      end
+
+      def select_migration_prompt(on_done:, migrator_adapter:)
+        prompt.select('Pick a migration') do |menu|
+          migrator_adapter.find_migrations.each { |migration|
+            name = render_migration_option(migration)
+
+            menu.choice(
+              name,
+              -> {
+                select_action_prompt(
+                  on_done: on_done,
+                  migrator_adapter: migrator_adapter,
+                  migration: migration,
+                )
+              }
+            )
+          }
+        end
+      end
+
+      def select_action_prompt(on_done:, migrator_adapter:, migration:)
+        if !migration.has_file
+          prompt.select("\nFile not found for migration version.") do |menu|
+            menu.choice('remove version from version table', -> { migrator_adapter.remove_version_from_table(migration.version) })
+            menu.choice('cancel', -> {})
+          end
+          on_done.()
+        end
+
+        option_map = obtain_option_map(migrator_adapter: migrator_adapter, on_done: on_done)
+
+        prompt.select("\nWhat would you like to do for #{migration.version} #{name}?") do |menu|
+          option_map.each do |label, on_press|
+            menu.choice(label, -> {
+              with_unsafe_error_capture { on_press.(migration) }
+              migrator_adapter.dump_schema
+              on_done.()
+            })
+          end
+
+          menu.choice('cancel', on_done)
+        end
+      end
+
+      def obtain_option_map(migrator_adapter:, on_done:)
+        {
+          MIGRATE => ->(migration) { migrator_adapter.migrate(migration.version) },
+          ROLLBACK => ->(migration) { migrator_adapter.rollback(migration.version) },
+          UP => ->(migration) { migrator_adapter.up(migration.version) },
+          DOWN => ->(migration) { migrator_adapter.down(migration.version) },
+          REDO => ->(migration) { migrator_adapter.redo(migration.version) },
+          BRING_TO_TOP => ->(migration) { migrator_adapter.bring_to_top(migration: migration, ask_for_rerun: -> { ask_for_rerun(on_done) }) },
+        }
+      end
+
+      def ask_for_rerun(on_done)
+        prompt.select("\nMigration has been run. Would you like to `down` the migration before moving it, and then run it again after?") do |menu|
+          menu.choice('yes, down and re-run the migration', -> { true })
+          menu.choice('no, just bump the version without migrating anything', -> { false })
+          menu.choice('cancel', -> { on_done.() })
+        end
+      end
+
+      def render_migration_option(migration)
+        "#{
+          migration.status.ljust(6)
+        }#{
+          migration.version.to_s.ljust(16)
+        }#{
+          (migration.current ? 'current' : '').ljust(9)
+        }#{
+          migration.name
+        }"
+      end
+
+      def with_unsafe_error_capture
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # I am aware you should not rescue 'Exception' exceptions but I think this is is an 'exceptional' use case
+        prompt.error("\n#{e.class}: #{e.message}\n#{e.backtrace.take(5).join("\n")}")
+      end
+    end
+  end
+end

data/lib/lazy_migrate/migration.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module LazyMigrate
+  class Migration < T::Struct
+    prop :status, String
+    const :version, Integer
+    const :name, String
+    prop :has_file, T::Boolean
+    prop :current, T::Boolean
+  end
+end

data/lib/lazy_migrate/migrator_adapter.rb

@@ -0,0 +1,144 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'lazy_migrate/migration'
+
+module LazyMigrate
+  class MigratorAdapter
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { void }
+    def initialize; end
+
+    # bring_to_top updates the version of a migration to bring it to the top of the
+    # migration list. If the migration had already been up'd it will mark the
+    # new migration file as upped as well. The former version number will be
+    # removed from the schema_migrations table. The user chooses whether
+    # they want to down the migration before moving it.
+    sig { params(migration: LazyMigrate::Migration, ask_for_rerun: T.proc.returns(T::Boolean)).void }
+    def bring_to_top(migration:, ask_for_rerun:)
+      initial_version = migration.version
+      initial_status = migration.status
+      initial_filename = self.find_filename_for_migration(migration)
+
+      if initial_filename.nil?
+        raise("No file found for migration #{initial_version}")
+      end
+
+      re_run = initial_status == 'up' && ask_for_rerun.()
+
+      if re_run
+        self.down(initial_version)
+      end
+
+      last = self.last_version
+      new_version = ActiveRecord::Migration.new.next_migration_number(last ? last + 1 : 0).to_i
+      new_filename = replace_version_in_filename(initial_filename, new_version)
+      File.rename(initial_filename, new_filename)
+
+      if re_run
+        self.up(new_version)
+      elsif initial_status == 'up'
+        ActiveRecord::SchemaMigration.create(version: new_version)
+        ActiveRecord::SchemaMigration.find_by(version: initial_version)&.destroy!
+      end
+    end
+
+    sig { params(filename: String, new_version: Integer).returns(String) }
+    def replace_version_in_filename(filename, new_version)
+      basename = File.basename(filename)
+      dir = File.dirname(filename)
+      name_after_version = T.must(basename.split('_')[1..]).join('_')
+      new_basename = "#{new_version}_#{name_after_version}"
+      File.join(dir, new_basename)
+    end
+
+    sig { void }
+    def dump_schema
+      return if !ActiveRecord::Base.dump_schema_after_migration
+
+      # ripped from https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/railties/databases.rake
+      filename = ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema.rb")
+      File.open(filename, "w:utf-8") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+
+    sig { returns(T::Array[LazyMigrate::Migration]) }
+    def find_migrations
+      self.load_migration_paths
+      current_version = self.last_version
+
+      self.find_migration_tuples
+        .reverse
+        .map { |status, str_version, name|
+          # This depends on how rails reports a file is missing.
+          # This is no doubt subject to change so be wary.
+          has_file = name != '********** NO FILE **********'
+          version = str_version.to_i
+          current = version == current_version
+
+          LazyMigrate::Migration.new(
+            status: status,
+            version: version,
+            name: name,
+            has_file: has_file,
+            current: current,
+          )
+        }
+    end
+
+    sig { void }
+    def load_migration_paths
+      # silencing cos we might be re-initializing some constants and rails
+      # doesn't like that
+      Kernel.silence_warnings do
+        ActiveRecord::Migrator.migrations_paths.each do |path|
+          Dir[Rails.application.root.join("#{path}/**/*.rb")].each { |file| load file }
+        end
+      end
+    end
+
+    sig { params(arr: T::Array[Integer], value: Integer).returns(T.nilable(Integer)) }
+    def previous_value(arr, value)
+      arr.sort.select { |v| v < value }.last
+    end
+
+    sig { params(version: Integer).void }
+    def remove_version_from_table(version)
+      ActiveRecord::SchemaMigration.find_by!(version: version).destroy!
+    end
+
+    sig { abstract.params(version: Integer).void }
+    def up(version); end
+
+    sig { abstract.params(version: Integer).void }
+    def down(version); end
+
+    sig { abstract.params(version: Integer).void }
+    def redo(version); end
+
+    sig { abstract.params(version: Integer).void }
+    def migrate(version); end
+
+    sig { abstract.params(version: Integer).void }
+    def rollback(version); end
+
+    protected
+
+    sig { abstract.returns(T::Array[[String, String, String]]) }
+    def find_migration_tuples; end
+
+    sig { abstract.params(version: Integer).returns(T.nilable(Integer)) }
+    def find_previous_version(version); end
+
+    sig { abstract.params(migration: LazyMigrate::Migration).returns(T.nilable(String)) }
+    def find_filename_for_migration(migration); end
+
+    sig { abstract.returns(T.nilable(Integer)) }
+    def last_version; end
+  end
+end

data/lib/lazy_migrate/migrator_adapter_factory.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+require "lazy_migrate/old_migrator_adapter"
+require "lazy_migrate/new_migrator_adapter"
+
+module LazyMigrate
+  class MigratorAdapterFactory
+    class << self
+      # unfortunately the code is a little different from 5.2 onwards compared to previous
+      # versions, and we want to do more than just invoke the db:migrate rake
+      # commands so we're returning a different adapter depending on the rails
+      # version
+      def create_migrator_adapter
+        if Rails.version > '5.2.0'
+          LazyMigrate::NewMigratorAdapter.new
+        else
+          LazyMigrate::OldMigratorAdapter.new
+        end
+      end
+    end
+  end
+end
+

data/lib/lazy_migrate/new_migrator_adapter.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'lazy_migrate/migrator_adapter'
+require 'lazy_migrate/migration'
+
+module LazyMigrate
+  class NewMigratorAdapter < MigratorAdapter
+    extend T::Sig
+
+    sig { returns(ActiveRecord::MigrationContext) }
+    attr_accessor :context
+
+    sig { void }
+    def initialize
+      # TODO: consider making this a method rather than an instance variable
+      # considering how cheap it is to obtain
+      @context = T.let(
+        ActiveRecord::MigrationContext.instance_method(:initialize).arity == 2 ?
+          ActiveRecord::MigrationContext.new(Rails.root.join('db', 'migrate'), ActiveRecord::SchemaMigration) :
+          ActiveRecord::MigrationContext.new(Rails.root.join('db', 'migrate')),
+        ActiveRecord::MigrationContext,
+      )
+    end
+
+    sig { override.params(version: Integer).void }
+    def up(version)
+      context.run(:up, version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def down(version)
+      context.run(:down, version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def redo(version)
+      down(version)
+      up(version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def migrate(version)
+      context.up(version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def rollback(version)
+      # for some reason in https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/migration.rb#L1221
+      # we stop before the selected version. I have no idea why.
+
+      previous_version = find_previous_version(version)
+
+      if previous_version.nil?
+        # rails excludes the given version when calling .down so we need to
+        # just down this instead
+        down(version)
+      else
+        context.down(previous_version)
+      end
+    end
+
+    protected
+
+    # example: [['up', '20200715030339', 'Add unique index to table']]
+    sig { override.returns(T::Array[[String, String, String]]) }
+    def find_migration_tuples
+      context.migrations_status
+    end
+
+    sig { override.params(version: Integer).returns(T.nilable(Integer)) }
+    def find_previous_version(version)
+      versions = context.migrations.map(&:version)
+
+      return nil if version == versions.first
+
+      previous_value(versions, version)
+    end
+
+    sig { override.params(migration: LazyMigrate::Migration).returns(T.nilable(String)) }
+    def find_filename_for_migration(migration)
+      context.migrations.find { |m| m.version == migration.version }&.filename
+    end
+
+    sig { override.returns(T.nilable(Integer)) }
+    def last_version
+      context.migrations.last&.version
+    end
+  end
+end

data/lib/lazy_migrate/old_migrator_adapter.rb

@@ -0,0 +1,97 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'lazy_migrate/migrator_adapter'
+
+module ActiveRecord
+  class Migrator
+    module Compatibility
+      class V5_1 < ActiveRecord::Migrator
+      end
+    end
+  end
+end
+
+module LazyMigrate
+  class OldMigratorAdapter < MigratorAdapter
+    extend T::Sig
+
+    sig { override.params(version: Integer).void }
+    def up(version)
+      ActiveRecord::Migrator::Compatibility::V5_1.run(:up, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def down(version)
+      ActiveRecord::Migrator::Compatibility::V5_1.run(:down, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def redo(version)
+      down(version)
+      up(version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def migrate(version)
+      ActiveRecord::Migrator::Compatibility::V5_1.migrate(base_paths, version)
+    end
+
+    sig { override.params(version: Integer).void }
+    def rollback(version)
+      previous_version = find_previous_version(version)
+
+      if previous_version.nil?
+        # rails excludes the given version when calling .migrate so we need to
+        # just down this instead
+        down(version)
+      else
+        ActiveRecord::Migrator::Compatibility::V5_1.migrate(base_paths, previous_version)
+      end
+    end
+
+    protected
+
+    # example: [['up', '20200715030339', 'Add unique index to table']]
+    sig { override.returns(T::Array[[String, String, String]]) }
+    def find_migration_tuples
+      ActiveRecord::Migrator::Compatibility::V5_1.migrations_status(base_paths)
+    end
+
+    sig { override.params(version: Integer).returns(T.nilable(Integer)) }
+    def find_previous_version(version)
+      versions = ActiveRecord::Migrator::Compatibility::V5_1.get_all_versions
+
+      return nil if version == versions.first
+
+      previous_value(versions, version)
+    end
+
+    sig { override.params(migration: LazyMigrate::Migration).returns(T.nilable(String)) }
+    def find_filename_for_migration(migration)
+      migrations.find { |m| m.version == migration.version }&.filename
+    end
+
+    sig { override.returns(T.nilable(Integer)) }
+    def last_version
+      ActiveRecord::Migrator::Compatibility::V5_1.get_all_versions.last
+    end
+
+    private
+
+    sig { returns(T::Array[String]) }
+    def base_paths
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+    end
+
+    sig { returns(T::Array[String]) }
+    def migration_files
+      ActiveRecord::Migrator::Compatibility::V5_1.migration_files(base_paths)
+    end
+
+    sig { returns(T::Array[ActiveRecord::MigrationProxy]) }
+    def migrations
+      ActiveRecord::Migrator::Compatibility::V5_1.migrations(base_paths)
+    end
+  end
+end