ruby-lsp-rails 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6995848edfaf04a9ff896c3e5b26704ff27e32e459154da3cf5d1340acb032b3
-  data.tar.gz: 9af25b875fe37dab802e813a7018bef86cc9b5cad0163d8d2d7031f40083779f
+  metadata.gz: 76155fcaf046652d4e13655bf8f1d38764a0a755cd4e090a70a7e551e77dc598
+  data.tar.gz: d417e7a57d97dbd0a7b1b2aa2ec999793ef6a8fb3ada39a0c1ad06688af8fd3b
 SHA512:
-  metadata.gz: 1b1cffaabe1cfe7db5c063d79cefdedaf4c00f79d9f1af561a8dc45976e8b731b750642722cdd89a84891e28f721e8074f86a58934e2e728e60863f2122ba7a4
-  data.tar.gz: 617030501d5184109d42400bed761b213dcc8b66ccd9528bae1ab795c2f96e220710de3df94e4425e9e76c4a9584514bff67e220c8bdae27004b1fc001724165
+  metadata.gz: 5f53d2aebe48cb0ce755541d4af87e564d2ca5dcdd70f411390c4d685890f6d398da400f223a77678c56e915b6a34ea6330b4495a02f407967040c07d9a5a164
+  data.tar.gz: 063117bc235a4bf99f148d65c8170601a35b58b7d95ad8098114ccd213c930f0d9a8ea12f51b12022c7ad6284672209ae0eafbd475f079c325ff8bc236c08688

data/Rakefile

@@ -16,4 +16,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task default: [:"db:setup", :test]
+task default: :test

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -13,52 +13,53 @@ require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
 require_relative "definition"
+require_relative "rails_test_style"
 require_relative "completion"
 require_relative "indexing_enhancement"
 
 module RubyLsp
   module Rails
     class Addon < ::RubyLsp::Addon
-      extend T::Sig
-
       RUN_MIGRATIONS_TITLE = "Run Migrations"
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
         # We first initialize the client as a NullClient, so that we can start the server in a background thread. Until
         # the real client is initialized, features that depend on it will not be blocked by using the NullClient
-        @rails_runner_client = T.let(NullClient.new, RunnerClient)
-        @global_state = T.let(nil, T.nilable(GlobalState))
-        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
-        @settings = T.let(
-          {
-            enablePendingMigrationsPrompt: true,
-          },
-          T::Hash[Symbol, T.untyped],
-        )
-        @addon_mutex = T.let(Mutex.new, Mutex)
-        @client_mutex = T.let(Mutex.new, Mutex)
+        @rails_runner_client = NullClient.new #: RunnerClient
+        @global_state = nil #: GlobalState?
+        @outgoing_queue = nil #: Thread::Queue?
+        @settings = {
+          enablePendingMigrationsPrompt: true,
+        } #: Hash[Symbol, untyped],
+
+        @addon_mutex = Mutex.new #: Mutex
+        @client_mutex = Mutex.new #: Mutex
         @client_mutex.lock
 
         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
-              @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue), T.must(@global_state))
+              @rails_runner_client = RunnerClient.create_client(
+                @outgoing_queue, #: as !nil
+                @global_state, #: as !nil
+              )
             end
             offer_to_run_pending_migrations
           end
         end
       end
 
-      sig { returns(RunnerClient) }
+      #: -> RunnerClient
       def rails_runner_client
         @addon_mutex.synchronize { @rails_runner_client }
       end
 
-      sig { override.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         @outgoing_queue = outgoing_queue
@@ -73,82 +74,70 @@ module RubyLsp
         @client_mutex.unlock
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
         @rails_runner_client.shutdown
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
         VERSION
       end
 
-      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
+      # @override
+      #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def create_discover_tests_listener(response_builder, dispatcher, uri)
+        return unless @global_state
+
+        RailsTestStyle.new(@rails_runner_client, response_builder, @global_state, dispatcher, uri)
       end
+
+      # @override
+      #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+      def resolve_test_commands(items)
+        RailsTestStyle.resolve_test_commands(items)
+      end
+
+      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def create_code_lens_listener(response_builder, uri, dispatcher)
         return unless @global_state
 
         CodeLens.new(@rails_runner_client, @global_state, response_builder, uri, dispatcher)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::Hover,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      # @override
+      #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       def create_hover_listener(response_builder, node_context, dispatcher)
         return unless @global_state
 
         Hover.new(@rails_runner_client, response_builder, node_context, @global_state, dispatcher)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::DocumentSymbol,
-          dispatcher: Prism::Dispatcher,
-        ).returns(Object)
-      end
+      # @override
+      #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> Object
       def create_document_symbol_listener(response_builder, dispatcher)
         DocumentSymbol.new(response_builder, dispatcher)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          uri: URI::Generic,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       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)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
-      end
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def create_completion_listener(response_builder, node_context, dispatcher, uri)
         Completion.new(@rails_runner_client, response_builder, node_context, dispatcher, uri)
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
         if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }
           @rails_runner_client.trigger_reload
@@ -162,12 +151,14 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Ruby LSP Rails"
       end
 
-      sig { override.params(title: String).void }
+      # @override
+      #: (String title) -> void
       def handle_window_show_message_response(title)
         if title == RUN_MIGRATIONS_TITLE
 
@@ -194,7 +185,7 @@ module RubyLsp
 
       private
 
-      sig { params(id: String, title: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      #: (String id, String title, ?percentage: Integer?, ?message: String?) -> void
       def begin_progress(id, title, percentage: nil, message: nil)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
@@ -212,21 +203,21 @@ module RubyLsp
         )
       end
 
-      sig { params(id: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
-      def report_progress(id,  percentage: nil, message: nil)
+      #: (String id, ?percentage: Integer?, ?message: 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 }
+      #: (String id) -> 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 }
+      #: (global_state: GlobalState, outgoing_queue: Thread::Queue) -> void
       def register_additional_file_watchers(global_state:, outgoing_queue:)
         return unless global_state.client_capabilities.supports_watching_files
 
@@ -247,7 +238,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def structure_sql_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/*structure.sql",
@@ -255,7 +246,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def fixture_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/fixtures/**/*.{yml,yaml,yml.erb,yaml.erb}",
@@ -263,7 +254,7 @@ module RubyLsp
         )
       end
 
-      sig { void }
+      #: -> void
       def offer_to_run_pending_migrations
         return unless @outgoing_queue
         return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -72,27 +72,18 @@ module RubyLsp
     # Note: Complex routing configurations may not be supported.
     #
     class CodeLens
-      extend T::Sig
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      sig do
-        params(
-          client: RunnerClient,
-          global_state: GlobalState,
-          response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient client, GlobalState global_state, ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(client, global_state, response_builder, uri, dispatcher)
         @client = client
         @global_state = global_state
         @response_builder = response_builder
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
-        @group_id = T.let(1, Integer)
-        @group_id_stack = T.let([], T::Array[Integer])
-        @constant_name_stack = T.let([], T::Array[[String, T.nilable(String)]])
+        @path = uri.to_standardized_path #: String?
+        @group_id = 1 #: Integer
+        @group_id_stack = [] #: Array[Integer]
+        @constant_name_stack = [] #: Array[[String, String?]]
 
         dispatcher.register(
           self,
@@ -105,7 +96,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         content = extract_test_case_name(node)
 
@@ -117,7 +108,7 @@ module RubyLsp
       end
 
       # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         method_name = node.name.to_s
 
@@ -133,7 +124,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         class_name = node.constant_path.slice
         superclass_name = node.superclass&.slice
@@ -157,7 +148,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         class_name = node.constant_path.slice
 
@@ -168,19 +159,19 @@ module RubyLsp
         @constant_name_stack.pop
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         @constant_name_stack << [node.constant_path.slice, nil]
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         @constant_name_stack.pop
       end
 
       private
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def controller?
         class_name, superclass_name = @constant_name_stack.last
         return false unless class_name && superclass_name
@@ -188,7 +179,7 @@ module RubyLsp
         class_name.end_with?("Controller") && superclass_name.end_with?("Controller")
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_jump_to_view(node)
         class_name = @constant_name_stack.map(&:first).join("::")
         action_name = node.name
@@ -216,9 +207,9 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_route_code_lens_to_action(node)
-        class_name, _ = T.must(@constant_name_stack.last)
+        class_name, _ = @constant_name_stack.last #: as !nil
         route = @client.route(controller: class_name, action: node.name.to_s)
         return unless route
 
@@ -233,22 +224,24 @@ module RubyLsp
         )
       end
 
-      sig { returns(String) }
+      #: -> String
       def test_command
         "#{RbConfig.ruby} bin/rails test"
       end
 
-      sig { returns(String) }
+      #: -> String
       def migrate_command
         "#{RbConfig.ruby} bin/rails db:migrate"
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def migration_version
-        File.basename(T.must(@path)).split("_").first
+        File.basename(
+          @path, #: as !nil
+        ).split("_").first
       end
 
-      sig { params(node: Prism::Node, name: String, command: String).void }
+      #: (Prism::Node node, name: String, command: String) -> void
       def add_migrate_code_lens(node, name:, command:)
         return unless @path
 
@@ -261,7 +254,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
+      #: (Prism::Node node, name: String, command: String, kind: Symbol) -> void
       def add_test_code_lens(node, name:, command:, kind:)
         return unless @path
         return unless @global_state.test_library == "rails"

data/lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -4,18 +4,10 @@
 module RubyLsp
   module Rails
     class Completion
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        override.params(
-          client: RunnerClient,
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
-      end
+      # @override
+      #: (RunnerClient client, ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def initialize(client, response_builder, node_context, dispatcher, uri)
         @response_builder = response_builder
         @client = client
@@ -26,7 +18,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         call_node = @node_context.call_node
         return unless call_node
@@ -39,13 +31,13 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode, receiver: Prism::ConstantReadNode).void }
+      #: (node: Prism::CallNode, receiver: Prism::ConstantReadNode) -> void
       def handle_active_record_where_completions(node:, receiver:)
         resolved_class = @client.model(receiver.name.to_s)
         return if resolved_class.nil?
 
-        arguments = T.must(@node_context.call_node).arguments&.arguments
-        indexed_call_node_args = T.let({}, T::Hash[String, Prism::Node])
+        arguments = @node_context.call_node.arguments&.arguments
+        indexed_call_node_args = {} #: Hash[String, Prism::Node]
 
         if arguments
           indexed_call_node_args = index_call_node_args(arguments: arguments)
@@ -70,7 +62,7 @@ module RubyLsp
         end
       end
 
-      sig { params(arguments: T::Array[Prism::Node]).returns(T::Hash[String, Prism::Node]) }
+      #: (arguments: Array[Prism::Node]) -> Hash[String, Prism::Node]
       def index_call_node_args(arguments:)
         indexed_call_node_args = {}
         arguments.each do |argument|

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -28,41 +28,30 @@ module RubyLsp
     # - If using `constraints`, the route can only be found if the constraints are met.
     # - Changes to routes won't be picked up until the server is restarted.
     class Definition
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          client: RunnerClient,
-          response_builder: RubyLsp::ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          node_context: NodeContext,
-          index: RubyIndexer::Index,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (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)
         @client = client
         @response_builder = response_builder
         @node_context = node_context
-        @nesting = T.let(node_context.nesting, T::Array[String])
+        @nesting = node_context.nesting #: Array[String]
         @index = index
 
         dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
       end
 
-      sig { params(node: Prism::SymbolNode).void }
+      #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: Prism::StringNode).void }
+      #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: T.any(Prism::SymbolNode, Prism::StringNode)).void }
+      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
       def handle_possible_dsl(node)
         node = @node_context.call_node
         return unless node
@@ -79,7 +68,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return unless self_receiver?(node)
 
@@ -94,7 +83,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_callback(node)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -113,7 +102,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_association(node)
         first_argument = node.arguments&.arguments&.first
         return unless first_argument.is_a?(Prism::SymbolNode)
@@ -130,15 +119,17 @@ module RubyLsp
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_route(node)
-        result = @client.route_location(T.must(node.message))
+        result = @client.route_location(
+          node.message, #: as !nil
+        )
         return unless result
 
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def collect_definitions(name)
         methods = @index.resolve_method(name, @nesting.join("::"))
         return unless methods