ruby-lsp-rails 0.4.7 → 0.5.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc55b4c0d67bcf2d51cfece504e53483ce6cc744fa482042bf8c9cdc5b6713e6
-  data.tar.gz: aa657a320f52d7b97dff961045d2e8144e04a5390889c00c41ba65ab5b9c8112
+  metadata.gz: 45452e2ccad431e725e146db37fb0120542f809624e349d3aef928e2dc86ebe0
+  data.tar.gz: 71d467b0bc3909928f963c82b668974d3854de1520b8e477c8b2774fa4c63ee2
 SHA512:
-  metadata.gz: 6b9e0856f031b24d5d97569db824d7781c10d0243099614d1bace814e46f326e280342ef451cef46ac1a9d28f9974ea8487b3dd35cae353ad79be7147fca726e
-  data.tar.gz: e1d0e2840d2b41d3af0a139f45a1c4546dcd87130812764f1a0051285ff148c2b6ff5cbcbdfed7944e6e89f9ffd6e11267140fd208ec7669195fae5f351c6404
+  metadata.gz: d13a3bf8c9c1d54f78afae535b852e8158426a0df64adb6eedfca0b35e6f06c2ca3ab5b97df1faac4173d48c8aba836b476e87d38d9d2f7ba82ea2d5a834f52d
+  data.tar.gz: 3b08291bbb3696ed7a266b7e6d763f03a04ae1ac1ffc05d67733b44d6b74bb6c510d8e26d1a792e44dad7868f6a08aff8ffa356ed2789871eb942476b279510c

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -7,6 +7,7 @@ require_relative "../../ruby_lsp_rails/version"
 require_relative "support/active_support_test_case_helper"
 require_relative "support/associations"
 require_relative "support/callbacks"
+require_relative "support/validations"
 require_relative "support/location_builder"
 require_relative "runner_client"
 require_relative "hover"
@@ -15,7 +16,6 @@ require_relative "document_symbol"
 require_relative "definition"
 require_relative "rails_test_style"
 require_relative "completion"
-require_relative "indexing_enhancement"
 
 module RubyLsp
   module Rails
@@ -39,7 +39,7 @@ module RubyLsp
         @client_mutex = Mutex.new #: Mutex
         @client_mutex.lock
 
-        Thread.new do
+        @boot_thread = Thread.new do
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
             @client_mutex.synchronize do
@@ -50,7 +50,7 @@ module RubyLsp
             end
             offer_to_run_pending_migrations
           end
-        end
+        end #: Thread
       end
 
       #: -> RunnerClient
@@ -77,6 +77,7 @@ module RubyLsp
       # @override
       #: -> void
       def deactivate
+        @boot_thread.join
         @rails_runner_client.shutdown
       end
 
@@ -128,7 +129,7 @@ module RubyLsp
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
         return unless @global_state
 
-        Definition.new(@rails_runner_client, response_builder, node_context, @global_state.index, dispatcher)
+        Definition.new(@rails_runner_client, response_builder, node_context, @global_state.graph, dispatcher)
       end
 
       # @override
@@ -149,6 +150,10 @@ module RubyLsp
 
           offer_to_run_pending_migrations
         end
+
+        if changes.any? { |c| %r{config/locales/.*\.yml}.match?(c[:uri]) }
+          @rails_runner_client.trigger_i18n_reload
+        end
       end
 
       # @override
@@ -230,7 +235,7 @@ module RubyLsp
                 id: "workspace/didChangeWatchedFilesRails",
                 method: "workspace/didChangeWatchedFiles",
                 register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
-                  watchers: [structure_sql_file_watcher, fixture_file_watcher],
+                  watchers: [structure_sql_file_watcher, fixture_file_watcher, i18n_file_watcher],
                 ),
               ),
             ],
@@ -254,6 +259,14 @@ module RubyLsp
         )
       end
 
+      #: -> Interface::FileSystemWatcher
+      def i18n_file_watcher
+        Interface::FileSystemWatcher.new(
+          glob_pattern: "**/config/locales/**/*.{yml,yaml}",
+          kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+        )
+      end
+
       #: -> void
       def offer_to_run_pending_migrations
         return unless @outgoing_queue

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -30,13 +30,19 @@ module RubyLsp
     class Definition
       include Requests::Support::Common
 
-      #: (RunnerClient client, RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, NodeContext node_context, RubyIndexer::Index index, Prism::Dispatcher dispatcher) -> void
-      def initialize(client, response_builder, node_context, index, dispatcher)
+      #: (
+      #|   RunnerClient,
+      #|   RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)],
+      #|   NodeContext,
+      #|   Rubydex::Graph,
+      #|   Prism::Dispatcher
+      #| ) -> void
+      def initialize(client, response_builder, node_context, graph, dispatcher)
         @client = client
         @response_builder = response_builder
         @node_context = node_context
         @nesting = node_context.nesting #: Array[String]
-        @index = index
+        @graph = graph
 
         dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
       end
@@ -51,55 +57,78 @@ module RubyLsp
         handle_possible_dsl(node)
       end
 
-      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
-      def handle_possible_dsl(node)
-        node = @node_context.call_node
-        return unless node
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
         return unless self_receiver?(node)
 
         message = node.message
 
         return unless message
 
-        if Support::Associations::ALL.include?(message)
-          handle_association(node)
-        elsif Support::Callbacks::ALL.include?(message)
-          handle_callback(node)
+        if message.end_with?("_path") || message.end_with?("_url")
+          handle_route(node)
         end
       end
 
-      #: (Prism::CallNode node) -> void
-      def on_call_node_enter(node)
-        return unless self_receiver?(node)
+      private
 
-        message = node.message
+      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
+      def handle_possible_dsl(node)
+        call_node = @node_context.call_node
+        return unless call_node
+        return unless self_receiver?(call_node)
+
+        message = call_node.message
 
         return unless message
 
-        if message.end_with?("_path") || message.end_with?("_url")
-          handle_route(node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        if Support::Associations::ALL.include?(message)
+          handle_association(call_node)
+        elsif Support::Callbacks::ALL.include?(message)
+          handle_callback(node, call_node, arguments)
+          handle_if_unless_conditional(node, call_node, arguments)
+        elsif Support::Validations::ALL.include?(message)
+          handle_validation(node, call_node, arguments)
+          handle_if_unless_conditional(node, call_node, arguments)
         end
       end
 
-      private
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_callback(node, call_node, arguments)
+        focus_argument = arguments.find { |argument| argument == node }
 
-      #: (Prism::CallNode node) -> void
-      def handle_callback(node)
-        arguments = node.arguments&.arguments
-        return unless arguments&.any?
+        name = case focus_argument
+        when Prism::SymbolNode
+          focus_argument.value
+        when Prism::StringNode
+          focus_argument.content
+        end
 
-        arguments.each do |argument|
-          name = case argument
-          when Prism::SymbolNode
-            argument.value
-          when Prism::StringNode
-            argument.content
-          end
+        return unless name
 
-          next unless name
+        collect_definitions(name)
+      end
 
-          collect_definitions(name)
-        end
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_validation(node, call_node, arguments)
+        message = call_node.message
+        return unless message
+
+        focus_argument = arguments.find { |argument| argument == node }
+        return unless focus_argument
+
+        return unless node.is_a?(Prism::SymbolNode)
+
+        name = node.value
+        return unless name
+
+        # validates_with uses constants, not symbols - skip (handled by constant resolution)
+        return if message == "validates_with"
+
+        collect_definitions(name)
       end
 
       #: (Prism::CallNode node) -> void
@@ -109,7 +138,7 @@ module RubyLsp
 
         association_name = first_argument.unescaped
 
-        result = @client.association_target_location(
+        result = @client.association_target(
           model_name: @nesting.join("::"),
           association_name: association_name,
         )
@@ -131,16 +160,51 @@ module RubyLsp
 
       #: (String name) -> void
       def collect_definitions(name)
-        methods = @index.resolve_method(name, @nesting.join("::"))
-        return unless methods
-
-        methods.each do |target_method|
-          @response_builder << Interface::Location.new(
-            uri: target_method.uri.to_s,
-            range: range_from_location(target_method.location),
-          )
+        return if @nesting.empty?
+
+        owner = @graph.resolve_constant(
+          @nesting.last, #: as !nil
+          @nesting[0...-1], #: as !nil
+        )
+        return unless owner.is_a?(Rubydex::Namespace)
+
+        declaration = owner.find_member("#{name}()")
+        return unless declaration
+
+        declaration.definitions.each do |definition|
+          @response_builder << definition.to_lsp_selection_location
         end
       end
+
+      #: ((Prism::SymbolNode | Prism::StringNode) node, Prism::CallNode call_node, Array[Prism::Node] arguments) -> void
+      def handle_if_unless_conditional(node, call_node, arguments)
+        keyword_arguments = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) } #: as Prism::KeywordHashNode?
+        return unless keyword_arguments
+
+        element = keyword_arguments.elements.find do |element|
+          next false unless element.is_a?(Prism::AssocNode)
+
+          key = element.key
+          next false unless key.is_a?(Prism::SymbolNode)
+
+          key_value = key.value
+          next false unless key_value == "if" || key_value == "unless"
+
+          value = element.value
+          next false unless value.is_a?(Prism::SymbolNode)
+
+          value == node
+        end #: as Prism::AssocNode?
+
+        return unless element
+
+        value = element.value #: as Prism::SymbolNode
+        method_name = value.value
+
+        return unless method_name
+
+        collect_definitions(method_name)
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -16,10 +16,12 @@ module RubyLsp
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
         @namespace_stack = [] #: Array[String]
+        @inside_schema = false #: bool
 
         dispatcher.register(
           self,
           :on_call_node_enter,
+          :on_call_node_leave,
           :on_class_node_enter,
           :on_class_node_leave,
           :on_module_node_enter,
@@ -29,6 +31,13 @@ module RubyLsp
 
       #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
+        message = node.message
+        return unless message
+
+        @inside_schema = true if node_is_schema_define?(node)
+
+        handle_schema_table(node)
+
         return if @namespace_stack.empty?
 
         content = extract_test_case_name(node)
@@ -44,9 +53,6 @@ module RubyLsp
         receiver = node.receiver
         return if receiver && !receiver.is_a?(Prism::SelfNode)
 
-        message = node.message
-        return unless message
-
         case message
         when *Support::Callbacks::ALL, "validate"
           handle_all_arg_types(node, message)
@@ -58,6 +64,11 @@ module RubyLsp
         end
       end
 
+      #: (Prism::CallNode node) -> void
+      def on_call_node_leave(node)
+        @inside_schema = false if node_is_schema_define?(node)
+      end
+
       #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         add_to_namespace_stack(node)
@@ -213,6 +224,39 @@ module RubyLsp
         end
       end
 
+      #: (Prism::CallNode node) -> void
+      def handle_schema_table(node)
+        return unless @inside_schema
+        return unless node.message == "create_table"
+
+        table_name_argument = node.arguments&.arguments&.first
+
+        return unless table_name_argument
+
+        case table_name_argument
+        when Prism::SymbolNode
+          name = table_name_argument.value
+          return unless name
+
+          append_document_symbol(
+            name: name,
+            range: range_from_location(table_name_argument.location),
+            selection_range: range_from_location(
+              table_name_argument.value_loc, #: as !nil
+            ),
+          )
+        when Prism::StringNode
+          name = table_name_argument.content
+          return if name.empty?
+
+          append_document_symbol(
+            name: name,
+            range: range_from_location(table_name_argument.location),
+            selection_range: range_from_location(table_name_argument.content_loc),
+          )
+        end
+      end
+
       #: (name: String, range: RubyLsp::Interface::Range, selection_range: RubyLsp::Interface::Range) -> void
       def append_document_symbol(name:, range:, selection_range:)
         @response_builder.last.children << RubyLsp::Interface::DocumentSymbol.new(
@@ -222,6 +266,19 @@ module RubyLsp
           selection_range: selection_range,
         )
       end
+
+      #: (Prism::CallNode node) -> bool
+      def node_is_schema_define?(node)
+        return false if node.message != "define"
+
+        schema_node = node.receiver
+        return false unless schema_node.is_a?(Prism::CallNode)
+
+        active_record_node = schema_node.receiver
+        return false unless active_record_node.is_a?(Prism::ConstantPathNode)
+
+        constant_name(active_record_node) == "ActiveRecord::Schema"
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -21,28 +21,46 @@ module RubyLsp
       def initialize(client, response_builder, node_context, global_state, dispatcher)
         @client = client
         @response_builder = response_builder
+        @node_context = node_context
         @nesting = node_context.nesting #: Array[String]
-        @index = global_state.index #: RubyIndexer::Index
-        dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter)
+        @graph = global_state.graph #: Rubydex::Graph
+
+        dispatcher.register(
+          self,
+          :on_constant_path_node_enter,
+          :on_constant_read_node_enter,
+          :on_symbol_node_enter,
+          :on_string_node_enter,
+        )
       end
 
       #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
-        entries = @index.resolve(node.slice, @nesting)
-        item = entries&.first
-        return unless item
+        name = constant_name(node)
+        return unless name
+
+        declaration = @graph.resolve_constant(name, @nesting)
+        return unless declaration
 
-        name = item.name
-        generate_column_content(name)
+        generate_column_content(declaration.name)
       end
 
       #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
-        entries = @index.resolve(node.name.to_s, @nesting)
-        item = entries&.first
-        return unless item
+        declaration = @graph.resolve_constant(node.name.to_s, @nesting)
+        return unless declaration
+
+        generate_column_content(declaration.name)
+      end
+
+      #: (Prism::SymbolNode node) -> void
+      def on_symbol_node_enter(node)
+        handle_possible_dsl(node)
+      end
 
-        generate_column_content(item.name)
+      #: (Prism::StringNode node) -> void
+      def on_string_node_enter(node)
+        handle_possible_i18n(node)
       end
 
       private
@@ -86,7 +104,15 @@ module RubyLsp
           @response_builder.push(
             model[:indexes].map do |index|
               uniqueness = index[:unique] ? " (unique)" : ""
-              "- **#{index[:name]}** (#{index[:columns].join(",")})#{uniqueness}"
+              columns = case index[:columns]
+              when Array
+                index[:columns].join(",")
+              when String
+                index[:columns]
+              else
+                index[:name]
+              end
+              "- **#{index[:name]}** (#{columns})#{uniqueness}"
             end.join("\n"),
             category: :documentation,
           )
@@ -104,6 +130,90 @@ module RubyLsp
           default_value
         end
       end
+
+      #: (Prism::SymbolNode node) -> void
+      def handle_possible_dsl(node)
+        node = @node_context.call_node
+        return unless node
+        return unless self_receiver?(node)
+
+        message = node.message
+
+        return unless message
+
+        if Support::Associations::ALL.include?(message)
+          handle_association(node)
+        end
+      end
+
+      #: (Prism::CallNode node) -> void
+      def handle_association(node)
+        first_argument = node.arguments&.arguments&.first
+        return unless first_argument.is_a?(Prism::SymbolNode)
+
+        association_name = first_argument.unescaped
+
+        result = @client.association_target(
+          model_name: @nesting.join("::"),
+          association_name: association_name,
+        )
+
+        return unless result
+
+        generate_hover(result[:name])
+      end
+
+      #: (Prism::StringNode node) -> void
+      def handle_possible_i18n(node)
+        call_node = @node_context.call_node
+        return unless i18n_translate?(call_node)
+
+        first_argument = call_node #: as !nil
+          .arguments&.arguments&.first
+        return unless first_argument == node
+
+        i18n_key = first_argument.unescaped
+        return if i18n_key.empty?
+
+        result = @client.i18n(i18n_key)
+        return unless result
+
+        generate_i18n_hover(result)
+      end
+
+      #: (Prism::CallNode? call_node) -> bool
+      def i18n_translate?(call_node)
+        return false unless call_node
+
+        receiver = call_node.receiver
+        return false unless receiver.is_a?(Prism::ConstantReadNode)
+        return false unless receiver.name == :I18n
+
+        message = call_node.message
+        message == "t" || message == "translate"
+      end
+
+      #: (String name) -> void
+      def generate_hover(name)
+        declaration = @graph.resolve_constant(name, @node_context.nesting)
+        return unless declaration
+
+        # [RUBYDEX] TODO: once we have visibility exposed from Rubydex, we should only show hover for private constants
+        # if the constant is defined in the same ancestor chain as the reference
+        categorized_markdown_from_definitions(declaration.name, declaration.definitions).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
+      #: (Hash[Symbol, String] translations) -> void
+      def generate_i18n_hover(translations)
+        content = translations.map { |lang, translation| "#{lang}: #{translation}" }.join("\n")
+        content = "```yaml\n#{content}\n```"
+        @response_builder.push(
+          content,
+          category: :documentation,
+        )
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb

@@ -4,7 +4,7 @@
 module RubyLsp
   module Rails
     class RailsTestStyle < Listeners::TestDiscovery
-      BASE_COMMAND = "#{RbConfig.ruby} bin/rails test" #: String
+      BASE_COMMAND = "bundle exec ruby -r#{Listeners::TestStyle::MINITEST_REPORTER_PATH} bin/rails test" #: String
 
       class << self
         #: (Array[Hash[Symbol, untyped]]) -> Array[String]
@@ -26,17 +26,19 @@ module RubyLsp
 
             if tags.include?("test_dir")
               if children.empty?
-                full_files.concat(Dir.glob(
-                  "#{path}/**/{*_test,test_*}.rb",
-                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
-                ))
+                full_files.concat(
+                  Dir.glob(
+                    "#{path}/**/{*_test,test_*}.rb",
+                    File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                  ).map! { |f| Shellwords.escape(f) },
+                )
               end
             elsif tags.include?("test_file")
-              full_files << path if children.empty?
+              full_files << Shellwords.escape(path) if children.empty?
             elsif tags.include?("test_group")
-              commands << "#{BASE_COMMAND} #{path} --name \"/#{Shellwords.escape(item[:id])}(#|::)/\""
+              commands << "#{BASE_COMMAND} #{Shellwords.escape(path)} --name \"/#{Shellwords.escape(item[:id])}(#|::)/\""
             else
-              full_files << "#{path}:#{item.dig(:range, :start, :line) + 1}"
+              full_files << "#{Shellwords.escape(path)}:#{item.dig(:range, :start, :line) + 1}"
             end
 
             queue.concat(children)
@@ -67,9 +69,11 @@ module RubyLsp
       def on_class_node_enter(node)
         with_test_ancestor_tracking(node) do |name, ancestors|
           if declarative_minitest?(ancestors, name)
+            label = constant_name(node.constant_path) || name_with_dynamic_reference(node.constant_path)
+
             test_item = Requests::Support::TestItem.new(
               name,
-              name,
+              label,
               @uri,
               range_from_node(node),
               framework: :rails,
@@ -119,7 +123,7 @@ module RubyLsp
         # Rails uses at runtime, ensuring proper test discovery and execution.
         rails_normalized_name = "test_#{test_name.gsub(/\s+/, "_")}"
 
-        add_test_item(node, rails_normalized_name)
+        add_test_item(node, rails_normalized_name, test_name)
       end
 
       #: (Prism::DefNode node) -> void
@@ -129,30 +133,31 @@ module RubyLsp
         name = node.name.to_s
         return unless name.start_with?("test_")
 
-        add_test_item(node, name)
+        add_test_item(node, name, name)
       end
 
       private
 
-      #: (Array[String] attached_ancestors, String fully_qualified_name) -> bool
+      #: (Array[String], String) -> bool
       def declarative_minitest?(attached_ancestors, fully_qualified_name)
-        # The declarative test style is present as long as the class extends
-        # ActiveSupport::Testing::Declarative
-        name_parts = fully_qualified_name.split("::")
-        singleton_name = "#{name_parts.join("::")}::<Class:#{name_parts.last}>"
-        @index.linearized_ancestors_of(singleton_name).include?("ActiveSupport::Testing::Declarative")
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        false
+        # The declarative test style is present as long as the class extends ActiveSupport::Testing::Declarative
+        declaration = @graph[fully_qualified_name]
+        return false unless declaration.is_a?(Rubydex::Namespace)
+
+        singleton = declaration.singleton_class
+        return attached_ancestors.include?("ActiveSupport::TestCase") unless singleton
+
+        singleton.ancestors.map(&:name).include?("ActiveSupport::Testing::Declarative")
       end
 
-      #: (Prism::Node node, String test_name) -> void
-      def add_test_item(node, test_name)
+      #: (Prism::Node, String, String) -> void
+      def add_test_item(node, test_id, label)
         parent = @parent_stack.last
         return unless parent.is_a?(Requests::Support::TestItem)
 
         example_item = Requests::Support::TestItem.new(
-          "#{parent.id}##{test_name}",
-          test_name,
+          "#{parent.id}##{test_id}",
+          label,
           @uri,
           range_from_node(node),
           framework: :rails,

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -51,23 +51,12 @@ module RubyLsp
       def initialize(outgoing_queue, global_state)
         @outgoing_queue = outgoing_queue #: Thread::Queue
         @mutex = Mutex.new #: Mutex
-        # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
-        # parent ends, the spring process ends as well. If this is not set, Spring will throw an error while trying to
-        # set its own session ID
-        begin
-          Process.setpgrp
-          Process.setsid
-        rescue Errno::EPERM
-          # If we can't set the session ID, continue
-        rescue NotImplementedError
-          # setpgrp() may be unimplemented on some platform
-          # 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(
+            { "RUBY_LSP_RAILS_RUNNER" => "true" },
             "bundle",
             "exec",
             "rails",
@@ -95,27 +84,14 @@ module RubyLsp
         @rails_root = initialize_response[:root] #: String
         log_message("Finished booting Ruby LSP Rails server")
 
-        unless ENV["RAILS_ENV"] == "test"
-          at_exit do
-            if @wait_thread.alive?
-              sleep(0.5) # give the server a bit of time if we already issued a shutdown notification
-              force_kill
-            end
-          end
-        end
-
         # Responsible for transmitting notifications coming from the server to the outgoing queue, so that we can do
-        # things such as showing progress notifications initiated by the server
+        # things such as showing progress notifications initiated by the server. The loop exits naturally when the
+        # server closes its stderr write end (i.e., when the server process exits), at which point `read_notification`
+        # returns nil.
         @notifier_thread = Thread.new do
-          until @stderr.closed?
-            notification = read_notification
-
-            unless @outgoing_queue.closed? || !notification
-              @outgoing_queue << notification
-            end
+          while (notification = read_notification)
+            @outgoing_queue << notification unless @outgoing_queue.closed?
           end
-        rescue IOError
-          # The server was shutdown and stderr is already closed
         end #: Thread
       rescue StandardError
         raise InitializationError, @stderr.read
@@ -144,9 +120,9 @@ module RubyLsp
       end
 
       #: (model_name: String, association_name: String) -> Hash[Symbol, untyped]?
-      def association_target_location(model_name:, association_name:)
+      def association_target(model_name:, association_name:)
         make_request(
-          "association_target_location",
+          "association_target",
           model_name: model_name,
           association_name: association_name,
         )
@@ -180,6 +156,17 @@ module RubyLsp
         nil
       end
 
+      #: (String key) -> Hash[Symbol, untyped]?
+      def i18n(key)
+        make_request("i18n", key: key)
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to get i18n information",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
       # Delegates a notification to a server add-on
       #: (server_addon_name: String, request_name: String, **untyped params) -> void
       def delegate_notification(server_addon_name:, request_name:, **params)
@@ -239,20 +226,39 @@ module RubyLsp
         nil
       end
 
+      #: -> void
+      def trigger_i18n_reload
+        log_message("Reloading I18n translations")
+        send_notification("reload_i18n")
+      rescue MessageError
+        log_message(
+          "Ruby LSP Rails failed to trigger I18n reload",
+          type: RubyLsp::Constant::MessageType::ERROR,
+        )
+        nil
+      end
+
       #: -> void
       def shutdown
+        return if stopped?
+
         log_message("Ruby LSP Rails shutting down server")
         send_message("shutdown")
-        sleep(0.5) # give the server a bit of time to shutdown
-        [@stdin, @stdout, @stderr].each(&:close)
-      rescue IOError
-        # The server connection may have died
-        force_kill
+
+        @stdin.close unless @stdin.closed?
+
+        # Wait for the server to exit. Once it does, all handles it inherited (including its stderr write end) are
+        # released, which lets the notifier thread drain remaining bytes and observe EOF.
+        @wait_thread.join
+        @notifier_thread.join
+
+        @stdout.close unless @stdout.closed?
+        @stderr.close unless @stderr.closed?
       end
 
       #: -> bool
       def stopped?
-        [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
+        [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive? && !@notifier_thread.alive?
       end
 
       #: -> bool
@@ -313,15 +319,6 @@ module RubyLsp
         nil
       end
 
-      #: -> void
-      def force_kill
-        # Windows does not support the `TERM` signal, so we're forced to use `KILL` here
-        Process.kill(
-          Signal.list["KILL"], #: as !nil
-          @wait_thread.pid,
-        )
-      end
-
       #: (::String message, ?type: ::Integer) -> void
       def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         return if @outgoing_queue.closed?

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -289,11 +289,18 @@ module RubyLsp
         send_result({ message: "ok", root: ::Rails.root.to_s })
 
         while @running
-          headers = @stdin.gets("\r\n\r\n") #: as String
-          json = @stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i) #: as String
+          headers = @stdin.gets("\r\n\r\n")
+          break unless headers
+
+          length = headers[/Content-Length: (\d+)/i, 1]
+          break unless length
+
+          json = @stdin.read(length.to_i)
+          break unless json
 
           request = JSON.parse(json, symbolize_names: true)
           execute(request.fetch(:method), request[:params])
+          disconnect_from_database
         end
       end
 
@@ -306,7 +313,7 @@ module RubyLsp
           with_request_error_handling(request) do
             send_result(resolve_database_info_from_model(params.fetch(:name)))
           end
-        when "association_target_location"
+        when "association_target"
           with_request_error_handling(request) do
             send_result(resolve_association_target(params))
           end
@@ -332,6 +339,17 @@ module RubyLsp
           with_request_error_handling(request) do
             send_result(resolve_route_info(params))
           end
+        when "i18n"
+          with_request_error_handling(request) do
+            result = resolve_i18n_key(params.fetch(:key))
+            send_result(result)
+          end
+        when "reload_i18n"
+          with_progress("rails-reload-i18n", "Reloading Ruby LSP Rails I18n") do
+            with_notification_error_handling(request) do
+              I18n.reload! if defined?(I18n) && I18n.respond_to?(:reload!)
+            end
+          end
         when "server_addon/register"
           with_notification_error_handling(request) do
             require params[:server_addon_path]
@@ -431,12 +449,12 @@ module RubyLsp
         source_location = Object.const_source_location(association_klass.to_s)
         return unless source_location
 
-        { location: "#{source_location[0]}:#{source_location[1]}" }
+        { location: "#{source_location[0]}:#{source_location[1]}", name: association_klass.name }
       rescue NameError
         nil
       end
 
-      #: (Module?) -> bool
+      #: (Module[top]?) -> bool
       def active_record_model?(const)
         !!(
           const &&
@@ -493,6 +511,18 @@ module RubyLsp
         end
       end
 
+      # Keeping a connection to the database prevents it from being dropped in development. We don't actually need to
+      # to reuse database connections for the LSP server, the performance benefit of doing so only matters in production
+      # where there is latency, locally we're fine with the small overhead of establishing a new connection on each request.
+      #: -> void
+      def disconnect_from_database
+        return unless defined?(::ActiveRecord::Base)
+
+        with_notification_error_handling("disconnect_from_database") do
+          ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+        end
+      end
+
       #: (singleton(ActiveRecord::Base)) -> Array[String]
       def collect_model_foreign_keys(model)
         return [] unless model.connection.respond_to?(:supports_foreign_keys?) &&
@@ -525,10 +555,21 @@ module RubyLsp
       rescue NotImplementedError
         @database_supports_indexing = false
       end
+
+      #: (String) -> Hash[Symbol, String]
+      def resolve_i18n_key(key)
+        I18n.available_locales.each_with_object({}) do |locale, result|
+          result[locale] = I18n.t(key, locale: locale, default: "⚠️ translation missing")
+        end
+      end
     end
   end
 end
 
 if ARGV.first == "start"
   RubyLsp::Rails::Server.new(capabilities: JSON.parse(ARGV[1], symbolize_names: true)).start
+
+  # Ensure that we exit the process after finishing the server loop. This prevents child processes that may have been
+  # spawned by the user's Rails application from keeping this process alive
+  exit!(0)
 end

data/lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb

@@ -55,7 +55,13 @@ module RubyLsp
           "before_perform",
         ].freeze
 
-        ALL = (MODELS + CONTROLLERS + JOBS).freeze #: Array[String]
+        MAILBOX = [
+          "after_processing",
+          "before_processing",
+          "around_processing",
+        ].freeze
+
+        ALL = (MODELS + CONTROLLERS + JOBS + MAILBOX).freeze #: Array[String]
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/support/validations.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module Support
+      module Validations
+        ALL = [
+          "validate",
+          "validates",
+          "validates!",
+          "validates_each",
+          "validates_with",
+          "validates_absence_of",
+          "validates_acceptance_of",
+          "validates_comparison_of",
+          "validates_confirmation_of",
+          "validates_exclusion_of",
+          "validates_format_of",
+          "validates_inclusion_of",
+          "validates_length_of",
+          "validates_numericality_of",
+          "validates_presence_of",
+          "validates_size_of",
+        ].freeze
+      end
+    end
+  end
+end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.4.7"
+    VERSION = "0.5.0.beta1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.5.0.beta1
 platform: ruby
 authors:
 - Shopify
@@ -15,20 +15,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.27.0.beta2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.28.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.27.0.beta2
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.28.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com
@@ -46,7 +46,6 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/definition.rb
 - lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
-- lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb
 - lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb
 - lib/ruby_lsp/ruby_lsp_rails/runner_client.rb
 - lib/ruby_lsp/ruby_lsp_rails/server.rb
@@ -54,6 +53,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/support/associations.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb
 - lib/ruby_lsp/ruby_lsp_rails/support/location_builder.rb
+- lib/ruby_lsp/ruby_lsp_rails/support/validations.rb
 - lib/ruby_lsp_rails/version.rb
 - lib/tasks/ruby_lsp_rails_tasks.rake
 homepage: https://github.com/Shopify/ruby-lsp-rails
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A Ruby LSP addon for Rails
 test_files: []

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -1,96 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Rails
-    class IndexingEnhancement < RubyIndexer::Enhancement
-      # @override
-      #: (Prism::CallNode call_node) -> void
-      def on_call_node_enter(call_node)
-        owner = @listener.current_owner
-        return unless owner
-
-        case call_node.name
-        when :extend
-          handle_concern_extend(owner, call_node)
-        when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
-          handle_association(owner, call_node)
-        # for `class_methods do` blocks within concerns
-        when :class_methods
-          handle_class_methods(owner, call_node)
-        end
-      end
-
-      # @override
-      #: (Prism::CallNode call_node) -> void
-      def on_call_node_leave(call_node)
-        if call_node.name == :class_methods && call_node.block
-          @listener.pop_namespace_stack
-        end
-      end
-
-      private
-
-      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
-      def handle_association(owner, call_node)
-        arguments = call_node.arguments&.arguments
-        return unless arguments
-
-        name_arg = arguments.first
-
-        name = case name_arg
-        when Prism::StringNode
-          name_arg.content
-        when Prism::SymbolNode
-          name_arg.value
-        end
-
-        return unless name
-
-        loc = name_arg.location
-
-        # Reader
-        reader_signatures = [RubyIndexer::Entry::Signature.new([])]
-        @listener.add_method(name, loc, reader_signatures)
-
-        # Writer
-        writer_signatures = [
-          RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)]),
-        ]
-        @listener.add_method("#{name}=", loc, writer_signatures)
-      end
-
-      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
-      def handle_concern_extend(owner, call_node)
-        arguments = call_node.arguments&.arguments
-        return unless arguments
-
-        arguments.each do |node|
-          next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
-
-          module_name = node.full_name
-          next unless module_name == "ActiveSupport::Concern"
-
-          @listener.register_included_hook do |index, base|
-            class_methods_name = "#{owner.name}::ClassMethods"
-
-            if index.indexed?(class_methods_name)
-              singleton = index.existing_or_new_singleton_class(base.name)
-              singleton.mixin_operations << RubyIndexer::Entry::Include.new(class_methods_name)
-            end
-          end
-        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
-               Prism::ConstantPathNode::MissingNodesInConstantPathError
-          # Do nothing
-        end
-      end
-
-      #: (RubyIndexer::Entry::Namespace owner, Prism::CallNode call_node) -> void
-      def handle_class_methods(owner, call_node)
-        return unless call_node.block
-
-        @listener.add_module("ClassMethods", call_node.location, call_node.location)
-      end
-    end
-  end
-end