ruby-lsp-rails 0.3.21 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feb1936ab1a1b20409425b3d644ab0e3c158b6f21a6bdf024d73013ccac28120
-  data.tar.gz: f32daf2f444a0ca0fa2a55b0d2bdef2d67abfcf40b4bae5cd351eede9b50dc11
+  metadata.gz: 03f59a93f09d79b974b5a46176ef8d2745e361bce2247ca19bef22e72aa697f8
+  data.tar.gz: 7e65330c616d0db49d4d54f084284ac8fd9d181b271e68dce3f3408a66d81daf
 SHA512:
-  metadata.gz: 72082ba3519fec8b3453201b9ffa9a270d745bdb4abff0e70edce58ad82024aae836a604bcdbdcec73f54faaae8b28e5a646ffec4bd0910c88099d425f3a6606
-  data.tar.gz: 4c53919cae2b20d3dbd6402721ebe9470ba89ab4a2db24cbc61f04484d8b19c23c7c99017042ac09fff55e4f3cf34c2830890a270245b89011a0691ba6ab11f1
+  metadata.gz: 1d92c385c3e6b7e1615213434791295bc2e6488d6e3dd853946c2c1f59345a2e0dd44a1e3019ca46293b8f48423a656f6e756941fc4da5eb371fd084735b5bce
+  data.tar.gz: ac372a79150173f46c8ec6d72e686785f41b98d1d986502c360e91d5fb461e8b2a7bd4a348f617365fd42c4863b7c008e140d545c06639dbcb5946dd2ed33a10

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -20,6 +20,8 @@ module RubyLsp
     class Addon < ::RubyLsp::Addon
       extend T::Sig
 
+      RUN_MIGRATIONS_TITLE = "Run Migrations"
+
       sig { void }
       def initialize
         super
@@ -37,6 +39,7 @@ module RubyLsp
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
             @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue)) }
+            offer_to_run_pending_migrations
           end
         end
       end
@@ -53,7 +56,7 @@ module RubyLsp
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
-        @global_state.index.register_enhancement(IndexingEnhancement.new)
+        @global_state.index.register_enhancement(IndexingEnhancement.new(@global_state.index))
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock
@@ -119,16 +122,85 @@ module RubyLsp
 
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
       def workspace_did_change_watched_files(changes)
-        if changes.any? do |change|
-             change[:uri].end_with?("db/schema.rb") || change[:uri].end_with?("structure.sql")
-           end
+        if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }
           @rails_runner_client.trigger_reload
         end
+
+        if changes.any? do |c|
+             %r{db/migrate/.*\.rb}.match?(c[:uri]) && c[:type] != Constant::FileChangeType::CHANGED
+           end
+
+          offer_to_run_pending_migrations
+        end
+      end
+
+      sig { override.returns(String) }
+      def name
+        "Ruby LSP Rails"
+      end
+
+      sig { override.params(title: String).void }
+      def handle_window_show_message_response(title)
+        if title == RUN_MIGRATIONS_TITLE
+
+          begin_progress("run-migrations", "Running Migrations")
+          response = @rails_runner_client.run_migrations
+
+          if response && @outgoing_queue
+            if response[:status] == 0
+              # Both log the message and show it as part of progress because sometimes running migrations is so fast you
+              # can't see the progress notification
+              @outgoing_queue << Notification.window_log_message(response[:message])
+              report_progress("run-migrations", message: response[:message])
+            else
+              @outgoing_queue << Notification.window_show_message(
+                "Migrations failed to run\n\n#{response[:message]}",
+                type: Constant::MessageType::ERROR,
+              )
+            end
+          end
+
+          end_progress("run-migrations")
+        end
+      end
+
+      private
+
+      sig { params(id: String, title: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      def begin_progress(id, title, percentage: nil, message: nil)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
+
+        @outgoing_queue << Request.new(
+          id: "progress-request-#{id}",
+          method: "window/workDoneProgress/create",
+          params: Interface::WorkDoneProgressCreateParams.new(token: id),
+        )
+
+        @outgoing_queue << Notification.progress_begin(
+          id,
+          title,
+          percentage: percentage,
+          message: "#{percentage}% completed",
+        )
+      end
+
+      sig { params(id: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      def report_progress(id,  percentage: nil, message: nil)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
+
+        @outgoing_queue << Notification.progress_report(id, percentage: percentage, message: message)
+      end
+
+      sig { params(id: String).void }
+      def end_progress(id)
+        return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
+
+        @outgoing_queue << Notification.progress_end(id)
       end
 
       sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
       def register_additional_file_watchers(global_state:, outgoing_queue:)
-        return unless global_state.supports_watching_files
+        return unless global_state.client_capabilities.supports_watching_files
 
         outgoing_queue << Request.new(
           id: "ruby-lsp-rails-file-watcher",
@@ -152,9 +224,26 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(String) }
-      def name
-        "Ruby LSP Rails"
+      sig { void }
+      def offer_to_run_pending_migrations
+        return unless @outgoing_queue
+        return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties
+
+        migration_message = @rails_runner_client.pending_migrations_message
+        return unless migration_message
+
+        @outgoing_queue << Request.new(
+          id: "rails-pending-migrations",
+          method: "window/showMessageRequest",
+          params: {
+            type: Constant::MessageType::INFO,
+            message: migration_message,
+            actions: [
+              { title: RUN_MIGRATIONS_TITLE, addon_name: name, method: "window/showMessageRequest" },
+              { title: "Cancel", addon_name: name, method: "window/showMessageRequest" },
+            ],
+          },
+        )
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -67,13 +67,29 @@ module RubyLsp
         ) if schema_file
 
         @response_builder.push(
-          model[:columns].map do |name, type|
+          model[:columns].map do |name, type, default_value, nullable|
             primary_key_suffix = " (PK)" if model[:primary_keys].include?(name)
-            "**#{name}**: #{type}#{primary_key_suffix}\n"
+            suffixes = []
+            suffixes << "default: #{format_default(default_value, type)}" if default_value
+            suffixes << "not null" unless nullable || primary_key_suffix
+            suffix_string = " - #{suffixes.join(" - ")}" if suffixes.any?
+            "**#{name}**: #{type}#{primary_key_suffix}#{suffix_string}\n"
           end.join("\n"),
           category: :documentation,
         )
       end
+
+      sig { params(default_value: String, type: String).returns(String) }
+      def format_default(default_value, type)
+        case type
+        when "boolean"
+          default_value == "true" ? "true" : "false"
+        when "string"
+          default_value.inspect
+        else
+          default_value
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -3,13 +3,11 @@
 
 module RubyLsp
   module Rails
-    class IndexingEnhancement
+    class IndexingEnhancement < RubyIndexer::Enhancement
       extend T::Sig
-      include RubyIndexer::Enhancement
 
       sig do
         override.params(
-          index: RubyIndexer::Index,
           owner: T.nilable(RubyIndexer::Entry::Namespace),
           node: Prism::CallNode,
           file_path: String,
@@ -19,16 +17,16 @@ module RubyLsp
           ),
         ).void
       end
-      def on_call_node(index, owner, node, file_path, code_units_cache)
+      def on_call_node_enter(owner, node, file_path, code_units_cache)
         return unless owner
 
         name = node.name
 
         case name
         when :extend
-          handle_concern_extend(index, owner, node)
+          handle_concern_extend(owner, node)
         when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
-          handle_association(index, owner, node, file_path, code_units_cache)
+          handle_association(owner, node, file_path, code_units_cache)
         end
       end
 
@@ -36,7 +34,6 @@ module RubyLsp
 
       sig do
         params(
-          index: RubyIndexer::Index,
           owner: RubyIndexer::Entry::Namespace,
           node: Prism::CallNode,
           file_path: String,
@@ -46,7 +43,7 @@ module RubyLsp
           ),
         ).void
       end
-      def handle_association(index, owner, node, file_path, code_units_cache)
+      def handle_association(owner, node, file_path, code_units_cache)
         arguments = node.arguments&.arguments
         return unless arguments
 
@@ -64,7 +61,7 @@ module RubyLsp
         loc = RubyIndexer::Location.from_prism_location(name_arg.location, code_units_cache)
 
         # Reader
-        index.add(RubyIndexer::Entry::Method.new(
+        @index.add(RubyIndexer::Entry::Method.new(
           name,
           file_path,
           loc,
@@ -76,7 +73,7 @@ module RubyLsp
         ))
 
         # Writer
-        index.add(RubyIndexer::Entry::Method.new(
+        @index.add(RubyIndexer::Entry::Method.new(
           "#{name}=",
           file_path,
           loc,
@@ -90,12 +87,11 @@ module RubyLsp
 
       sig do
         params(
-          index: RubyIndexer::Index,
           owner: RubyIndexer::Entry::Namespace,
           node: Prism::CallNode,
         ).void
       end
-      def handle_concern_extend(index, owner, node)
+      def handle_concern_extend(owner, node)
         arguments = node.arguments&.arguments
         return unless arguments
 
@@ -105,7 +101,7 @@ module RubyLsp
           module_name = node.full_name
           next unless module_name == "ActiveSupport::Concern"
 
-          index.register_included_hook(owner.name) do |index, base|
+          @index.register_included_hook(owner.name) do |index, base|
             class_methods_name = "#{owner.name}::ClassMethods"
 
             if index.indexed?(class_methods_name)

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -46,8 +46,6 @@ module RubyLsp
       class IncompleteMessageError < StandardError; end
       class EmptyMessageError < StandardError; end
 
-      MAX_RETRIES = 5
-
       extend T::Sig
 
       sig { returns(String) }
@@ -70,6 +68,8 @@ module RubyLsp
           # https://github.com/Shopify/ruby-lsp-rails/issues/348
         end
 
+        log_message("Ruby LSP Rails booting server")
+
         stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
           Open3.popen3("bundle", "exec", "rails", "runner", "#{__dir__}/server.rb", "start")
         end
@@ -77,6 +77,9 @@ module RubyLsp
         @stdin = T.let(stdin, IO)
         @stdout = T.let(stdout, IO)
         @stderr = T.let(stderr, IO)
+        @stdin.sync = true
+        @stdout.sync = true
+        @stderr.sync = true
         @wait_thread = T.let(wait_thread, Process::Waiter)
 
         # We set binmode for Windows compatibility
@@ -84,18 +87,8 @@ module RubyLsp
         @stdout.binmode
         @stderr.binmode
 
-        log_message("Ruby LSP Rails booting server")
-        count = 0
-
-        begin
-          count += 1
-          initialize_response = T.must(read_response)
-          @rails_root = T.let(initialize_response[:root], String)
-        rescue EmptyMessageError
-          log_message("Ruby LSP Rails is retrying initialize (#{count})")
-          retry if count < MAX_RETRIES
-        end
-
+        initialize_response = T.must(read_response)
+        @rails_root = T.let(initialize_response[:root], String)
         log_message("Finished booting Ruby LSP Rails server")
 
         unless ENV["RAILS_ENV"] == "test"
@@ -194,6 +187,29 @@ module RubyLsp
         )
       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(
@@ -274,11 +290,9 @@ module RubyLsp
       sig { overridable.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def read_response
         raw_response = @mutex.synchronize do
-          headers = @stdout.gets("\r\n\r\n")
-          raise IncompleteMessageError unless headers
-
-          content_length = headers[/Content-Length: (\d+)/i, 1].to_i
-          raise EmptyMessageError if content_length.zero?
+          content_length = read_content_length
+          content_length = read_content_length unless content_length
+          raise EmptyMessageError unless content_length
 
           @stdout.read(content_length)
         end
@@ -311,6 +325,17 @@ module RubyLsp
 
         @outgoing_queue << RubyLsp::Notification.window_log_message(message, type: type)
       end
+
+      sig { returns(T.nilable(Integer)) }
+      def read_content_length
+        headers = @stdout.gets("\r\n\r\n")
+        return unless headers
+
+        length = headers[/Content-Length: (\d+)/i, 1]
+        return unless length
+
+        length.to_i
+      end
     end
 
     class NullClient < RunnerClient

data/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 @@ module RubyLsp
           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"
@@ -167,6 +172,11 @@ module RubyLsp
       if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&
           ActionDispatch::Routing::Mapper.route_source_locations
         def route_location(name)
+          # In Rails 8, Rails.application.routes.named_routes is not populated by default
+          if ::Rails.application.respond_to?(:reload_routes_unless_loaded)
+            ::Rails.application.reload_routes_unless_loaded
+          end
+
           match_data = name.match(/^(.+)(_path|_url)$/)
           return { result: nil } unless match_data
 
@@ -200,7 +210,7 @@ module RubyLsp
 
         info = {
           result: {
-            columns: const.columns.map { |column| [column.name, column.type] },
+            columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
             primary_keys: Array(const.primary_key),
           },
         }
@@ -247,6 +257,26 @@ module RubyLsp
           !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

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.21"
+    VERSION = "0.3.23"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.21
+  version: 0.3.23
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-23 00:00:00.000000000 Z
+date: 2024-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.21.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 0.21.2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: 0.22.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com