ruby-lsp 0.21.1 → 0.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c270ba4b6a7348ccb821e1bae776f4bd9ac704973b251791d2104d79861878c1
-  data.tar.gz: 5d27d76eca727dca7e439aa177db04fb3ec17e1169c19a267ba2cffc8f9e19a3
+  metadata.gz: f580352765054aabd1821330dab6fa4ce5fb65746dee3a96640589a511a047f0
+  data.tar.gz: 41b51b6a3c13116b64a116f50337df14624088d8c50b2d5675c753b0ae612220
 SHA512:
-  metadata.gz: 8502d09966be4e7ec79c276b4d078edc0f4e150c86ff24bb6e6f5b9c28e4f89393760983b7344c108e356a5bc79daa314806c69b81441338465b00f8bb693cc1
-  data.tar.gz: 0d84c86826022c8e71311bef8070f8b5364cd45f10f242fcb5b8cf96f9dd391a9a45a034b264ee8b2cec236ce69257a1a102d9e769bbdf3b8c0dc9baff8650e9
+  metadata.gz: 6801b771e4aec3f493211f8b50c5c6e2998cd7d2ff1061bbc8e7afb83c87e653fcf7dfd23c3b41ec2fa65cd1d1eec3fab840a9188936904c08c6f2745c12c5a8
+  data.tar.gz: 9b68fee2853275c1343fa2815c6fe4263e6c90277b5e6567dfb84d4e0dd9d112353d77f18055384d9cb9aeb6a263ce8ec1b4b66f8b1eb2950f800aedf73fba3a

data/VERSION

@@ -1 +1 @@
-0.21.1
+0.21.3

data/lib/ruby_lsp/client_capabilities.rb

@@ -10,7 +10,8 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_reader :supports_watching_files,
       :supports_request_delegation,
-      :window_show_message_supports_extra_properties
+      :window_show_message_supports_extra_properties,
+      :supports_progress
 
     sig { void }
     def initialize
@@ -28,6 +29,9 @@ module RubyLsp
 
       # Which resource operations the editor supports, like renaming files
       @supported_resource_operations = T.let([], T::Array[String])
+
+      # The editor supports displaying progress requests
+      @supports_progress = T.let(false, T::Boolean)
     end
 
     sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
@@ -50,6 +54,9 @@ module RubyLsp
         :additionalPropertiesSupport,
       )
       @window_show_message_supports_extra_properties = supports_additional_properties || false
+
+      progress = capabilities.dig(:window, :workDoneProgress)
+      @supports_progress = progress if progress
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -53,6 +53,7 @@ module RubyLsp
         T::Boolean,
       )
       @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
+      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -139,9 +140,17 @@ module RubyLsp
         @addon_settings.merge!(addon_settings)
       end
 
+      enabled_flags = options.dig(:initializationOptions, :enabledFeatureFlags)
+      @enabled_feature_flags = enabled_flags if enabled_flags
+
       notifications
     end
 
+    sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled_feature?(flag)
+      @enabled_feature_flags[flag]
+    end
+
     sig { returns(String) }
     def workspace_path
       T.must(@workspace_uri.to_standardized_path)

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -92,14 +92,15 @@ module RubyLsp
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
+          position: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(response_builder, target, parent, dispatcher)
+      def initialize(response_builder, target, parent, dispatcher, position)
         @response_builder = response_builder
 
         return unless target && parent
 
-        highlight_target =
+        highlight_target, highlight_target_value =
           case target
           when Prism::GlobalVariableReadNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
             Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode, Prism::GlobalVariableWriteNode,
@@ -116,13 +117,17 @@ module RubyLsp
             Prism::CallNode, Prism::BlockParameterNode, Prism::RequiredKeywordParameterNode,
             Prism::RequiredKeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
             Prism::RequiredParameterNode, Prism::RestParameterNode
+            [target, node_value(target)]
+          when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
+            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
             target
           end
 
         @target = T.let(highlight_target, T.nilable(Prism::Node))
-        @target_value = T.let(node_value(highlight_target), T.nilable(String))
+        @target_value = T.let(highlight_target_value, T.nilable(String))
+        @target_position = position
 
-        if @target && @target_value
+        if @target
           dispatcher.register(
             self,
             :on_call_node_enter,
@@ -172,6 +177,13 @@ module RubyLsp
             :on_global_variable_or_write_node_enter,
             :on_global_variable_and_write_node_enter,
             :on_global_variable_operator_write_node_enter,
+            :on_singleton_class_node_enter,
+            :on_case_node_enter,
+            :on_while_node_enter,
+            :on_until_node_enter,
+            :on_for_node_enter,
+            :on_if_node_enter,
+            :on_unless_node_enter,
           )
         end
       end
@@ -189,6 +201,8 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
+        add_matching_end_highlights(node.def_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::DefNode)
+
         return unless matches?(node, [Prism::CallNode, Prism::DefNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
@@ -252,6 +266,8 @@ module RubyLsp
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ClassNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ClassNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -259,6 +275,8 @@ module RubyLsp
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
+        add_matching_end_highlights(node.module_keyword_loc, node.end_keyword_loc) if @target.is_a?(Prism::ModuleNode)
+
         return unless matches?(node, CONSTANT_NODES + CONSTANT_PATH_NODES + [Prism::ModuleNode])
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.constant_path.location)
@@ -511,6 +529,55 @@ module RubyLsp
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
+        return unless @target.is_a?(Prism::SingletonClassNode)
+
+        add_matching_end_highlights(node.class_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::CaseNode).void }
+      def on_case_node_enter(node)
+        return unless @target.is_a?(Prism::CaseNode)
+
+        add_matching_end_highlights(node.case_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::WhileNode).void }
+      def on_while_node_enter(node)
+        return unless @target.is_a?(Prism::WhileNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::UntilNode).void }
+      def on_until_node_enter(node)
+        return unless @target.is_a?(Prism::UntilNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.closing_loc)
+      end
+
+      sig { params(node: Prism::ForNode).void }
+      def on_for_node_enter(node)
+        return unless @target.is_a?(Prism::ForNode)
+
+        add_matching_end_highlights(node.for_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::IfNode).void }
+      def on_if_node_enter(node)
+        return unless @target.is_a?(Prism::IfNode)
+
+        add_matching_end_highlights(node.if_keyword_loc, node.end_keyword_loc)
+      end
+
+      sig { params(node: Prism::UnlessNode).void }
+      def on_unless_node_enter(node)
+        return unless @target.is_a?(Prism::UnlessNode)
+
+        add_matching_end_highlights(node.keyword_loc, node.end_keyword_loc)
+      end
+
       private
 
       sig { params(node: Prism::Node, classes: T::Array[T.class_of(Prism::Node)]).returns(T.nilable(T::Boolean)) }
@@ -550,6 +617,26 @@ module RubyLsp
           node.constant_path.slice
         end
       end
+
+      sig { params(keyword_loc: T.nilable(Prism::Location), end_loc: T.nilable(Prism::Location)).void }
+      def add_matching_end_highlights(keyword_loc, end_loc)
+        return unless keyword_loc && end_loc && end_loc.length.positive?
+        return unless covers_target_position?(keyword_loc) || covers_target_position?(end_loc)
+
+        add_highlight(Constant::DocumentHighlightKind::TEXT, keyword_loc)
+        add_highlight(Constant::DocumentHighlightKind::TEXT, end_loc)
+      end
+
+      sig { params(location: Prism::Location).returns(T::Boolean) }
+      def covers_target_position?(location)
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        start_covered = start_line < @target_position[:line] ||
+          (start_line == @target_position[:line] && location.start_column <= @target_position[:character])
+        end_covered = end_line > @target_position[:line] ||
+          (end_line == @target_position[:line] && location.end_column >= @target_position[:character])
+        start_covered && end_covered
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -38,7 +38,13 @@ module RubyLsp
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
         )
-        Listeners::DocumentHighlight.new(@response_builder, node_context.node, node_context.parent, dispatcher)
+        Listeners::DocumentHighlight.new(
+          @response_builder,
+          node_context.node,
+          node_context.parent,
+          dispatcher,
+          position,
+        )
       end
 
       sig { override.returns(T::Array[Interface::DocumentHighlight]) }

data/lib/ruby_lsp/server.rb

@@ -81,8 +81,6 @@ module RubyLsp
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
         workspace_symbol(message)
-      when "window/showMessageRequest"
-        window_show_message_request(message)
       when "rubyLsp/textDocument/showSyntaxTree"
         text_document_show_syntax_tree(message)
       when "rubyLsp/workspace/dependencies"
@@ -108,6 +106,8 @@ module RubyLsp
         )
       when "$/cancelRequest"
         @mutex.synchronize { @cancelled_requests << message[:params][:id] }
+      when nil
+        process_response(message) if message[:result]
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
@@ -140,6 +140,15 @@ module RubyLsp
       send_log_message("Error processing #{message[:method]}: #{e.full_message}", type: Constant::MessageType::ERROR)
     end
 
+    # Process responses to requests that were sent to the client
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def process_response(message)
+      case message.dig(:result, :method)
+      when "window/showMessageRequest"
+        window_show_message_request(message)
+      end
+    end
+
     sig { params(include_project_addons: T::Boolean).void }
     def load_addons(include_project_addons: true)
       # If invoking Bundler.setup failed, then the load path will not be configured properly and trying to load add-ons
@@ -188,8 +197,6 @@ module RubyLsp
       client_name = options.dig(:clientInfo, :name)
       @store.client_name = client_name if client_name
 
-      progress = options.dig(:capabilities, :window, :workDoneProgress)
-      @store.supports_progress = progress.nil? ? true : progress
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
       configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
@@ -1105,7 +1112,7 @@ module RubyLsp
 
     sig { params(id: String, title: String, percentage: Integer).void }
     def begin_progress(id, title, percentage: 0)
-      return unless @store.supports_progress
+      return unless @global_state.client_capabilities.supports_progress
 
       send_message(Request.new(
         id: @current_request_id,
@@ -1113,52 +1120,21 @@ module RubyLsp
         params: Interface::WorkDoneProgressCreateParams.new(token: id),
       ))
 
-      send_message(Notification.new(
-        method: "$/progress",
-        params: Interface::ProgressParams.new(
-          token: id,
-          value: Interface::WorkDoneProgressBegin.new(
-            kind: "begin",
-            title: title,
-            percentage: percentage,
-            message: "#{percentage}% completed",
-          ),
-        ),
-      ))
+      send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
     end
 
     sig { params(id: String, percentage: Integer).void }
     def progress(id, percentage)
-      return unless @store.supports_progress
+      return unless @global_state.client_capabilities.supports_progress
 
-      send_message(
-        Notification.new(
-          method: "$/progress",
-          params: Interface::ProgressParams.new(
-            token: id,
-            value: Interface::WorkDoneProgressReport.new(
-              kind: "report",
-              percentage: percentage,
-              message: "#{percentage}% completed",
-            ),
-          ),
-        ),
-      )
+      send_message(Notification.progress_report(id, percentage: percentage, message: "#{percentage}% completed"))
     end
 
     sig { params(id: String).void }
     def end_progress(id)
-      return unless @store.supports_progress
+      return unless @global_state.client_capabilities.supports_progress
 
-      send_message(
-        Notification.new(
-          method: "$/progress",
-          params: Interface::ProgressParams.new(
-            token: id,
-            value: Interface::WorkDoneProgressEnd.new(kind: "end"),
-          ),
-        ),
-      )
+      send_message(Notification.progress_end(id))
     rescue ClosedQueueError
       # If the server was killed and the message queue is already closed, there's no way to end the progress
       # notification
@@ -1226,11 +1202,14 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def window_show_message_request(message)
-      addon_name = message[:addon_name]
+      result = message[:result]
+      return unless result
+
+      addon_name = result[:addon_name]
       addon = Addon.addons.find { |addon| addon.name == addon_name }
       return unless addon
 
-      addon.handle_window_show_message_response(message[:title])
+      addon.handle_window_show_message_response(result[:title])
     end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -7,9 +7,6 @@ module RubyLsp
 
     class NonExistingDocumentError < StandardError; end
 
-    sig { returns(T::Boolean) }
-    attr_accessor :supports_progress
-
     sig { returns(T::Hash[Symbol, RequestConfig]) }
     attr_accessor :features_configuration
 
@@ -19,7 +16,6 @@ module RubyLsp
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document[T.untyped]])
-      @supports_progress = T.let(true, T::Boolean)
       @features_configuration = T.let(
         {
           inlayHint: RequestConfig.new({

data/lib/ruby_lsp/utils.rb

@@ -87,6 +87,61 @@ module RubyLsp
           params: data,
         )
       end
+
+      sig do
+        params(
+          id: String,
+          title: String,
+          percentage: T.nilable(Integer),
+          message: T.nilable(String),
+        ).returns(Notification)
+      end
+      def progress_begin(id, title, percentage: nil, message: nil)
+        new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressBegin.new(
+              kind: "begin",
+              title: title,
+              percentage: percentage,
+              message: message,
+            ),
+          ),
+        )
+      end
+
+      sig do
+        params(
+          id: String,
+          percentage: T.nilable(Integer),
+          message: T.nilable(String),
+        ).returns(Notification)
+      end
+      def progress_report(id, percentage: nil, message: nil)
+        new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressReport.new(
+              kind: "report",
+              percentage: percentage,
+              message: message,
+            ),
+          ),
+        )
+      end
+
+      sig { params(id: String).returns(Notification) }
+      def progress_end(id)
+        Notification.new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressEnd.new(kind: "end"),
+          ),
+        )
+      end
     end
 
     extend T::Sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.21.1
+  version: 0.21.3
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-31 00:00:00.000000000 Z
+date: 2024-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol