Add support for checking for pending migrations and running them (#503)

Add the ability to check for pending migrations and run them through the Rails runner client.

For checking if something is pending, we use the Rails API directly, which raises if there are any pending migrations.

For running them, we can't do it in process. The code that runs migrations is not designed to be invoked repeatedly and uses `load`, which means that we could end up with a memory bloat. I used `Open3.capture2` to run in a child process and grab the results.

Author: vinistock

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -187,6 +187,29 @@ def delegate_notification(server_addon_name:, request_name:, **params)
         )
       end
 
+      sig { returns(T.nilable(String)) }
+      def pending_migrations_message
+        response = make_request("pending_migrations_message")
+        response[:pending_migrations_message] if response
+      rescue IncompleteMessageError
+        log_message(
+          "Ruby LSP Rails failed when checking for pending migrations",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
+      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def run_migrations
+        make_request("run_migrations")
+      rescue IncompleteMessageError
+        log_message(
+          "Ruby LSP Rails failed to run migrations",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
       # Delegates a request to a server add-on
       sig do
         params(

lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "open3"
 
 # NOTE: We should avoid printing to stderr since it causes problems. We never read the standard error pipe from the
 # client, so it will become full and eventually hang or crash. Instead, return a response with an `error` key.
@@ -109,6 +110,10 @@ def execute(request, params)
           send_message(resolve_database_info_from_model(params.fetch(:name)))
         when "association_target_location"
           send_message(resolve_association_target(params))
+        when "pending_migrations_message"
+          send_message({ result: { pending_migrations_message: pending_migrations_message } })
+        when "run_migrations"
+          send_message({ result: run_migrations })
         when "reload"
           ::Rails.application.reloader.reload!
         when "route_location"
@@ -252,6 +257,26 @@ def active_record_model?(const)
           !const.abstract_class?
         )
       end
+
+      def pending_migrations_message
+        return unless defined?(ActiveRecord)
+
+        ActiveRecord::Migration.check_all_pending!
+        nil
+      rescue ActiveRecord::PendingMigrationError => e
+        e.message
+      end
+
+      def run_migrations
+        # Running migrations invokes `load` which will repeatedly load the same files. It's not designed to be invoked
+        # multiple times within the same process. To avoid any memory bloat, we run migrations in a separate process
+        stdout, status = Open3.capture2(
+          { "VERBOSE" => "true" },
+          "bundle exec rails db:migrate",
+        )
+
+        { message: stdout, status: status.exitstatus }
+      end
     end
   end
 end

test/ruby_lsp_rails/server_test.rb

@@ -176,6 +176,28 @@ def resolve_route_info(requirements)
     assert_equal("Hello\n", stderr)
   end
 
+  test "checking for pending migrations" do
+    capture_subprocess_io do
+      system("bundle exec rails g migration CreateStudents name:string")
+    end
+
+    @server.execute("pending_migrations_message", {})
+    message = response.dig(:result, :pending_migrations_message)
+    assert_match("You have 1 pending migration", message)
+    assert_match(%r{db/migrate/[\d]+_create_students\.rb}, message)
+  ensure
+    FileUtils.rm_rf("db") if File.directory?("db")
+  end
+
+  test "running migrations happens in a child process" do
+    Open3.expects(:capture2)
+      .with({ "VERBOSE" => "true" }, "bundle exec rails db:migrate")
+      .returns(["Running migrations...", mock(exitstatus: 0)])
+
+    @server.execute("run_migrations", {})
+    assert_equal({ message: "Running migrations...", status: 0 }, response[:result])
+  end
+
   private
 
   def response