ruby-lsp 0.12.5 → 0.13.1

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -20,8 +20,8 @@ module RubyLsp
 
       END_REGEXES = T.let(
         [
-          /(if|unless|for|while|class|module|until|def|case).*/,
-          /.*\sdo/,
+          /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
+          /.*\s\bdo\b/,
         ],
         T::Array[Regexp],
       )
@@ -60,6 +60,8 @@ module RubyLsp
               handle_statement_end
             end
           end
+        when "d"
+          auto_indent_after_end_keyword
         end
 
         @edits
@@ -118,7 +120,7 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         next_line = @lines[@position[:line] + 1]
 
-        if current_line.nil? || current_line.strip.empty?
+        if current_line.nil? || current_line.strip.empty? || current_line.include?(")") || current_line.include?("]")
           add_edit_with_text("\n")
           add_edit_with_text("#{indents}end")
           move_cursor_to(@position[:line], @indentation + 2)
@@ -139,7 +141,6 @@ module RubyLsp
       sig { params(spaces: String).void }
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")
-        move_cursor_to(@position[:line], @indentation + spaces.size + 1)
       end
 
       sig { params(text: String, position: Document::PositionShape).void }
@@ -186,6 +187,32 @@ module RubyLsp
 
         count
       end
+
+      sig { void }
+      def auto_indent_after_end_keyword
+        current_line = @lines[@position[:line]]
+        return unless current_line&.strip == "end"
+
+        target, _parent, _nesting = @document.locate_node({
+          line: @position[:line],
+          character: @position[:character] - 1,
+        })
+
+        statements = case target
+        when Prism::IfNode, Prism::UnlessNode, Prism::ForNode, Prism::WhileNode, Prism::UntilNode
+          target.statements
+        end
+        return unless statements
+
+        statements.body.each do |node|
+          loc = node.location
+          next unless loc.start_column == @indentation
+
+          add_edit_with_text("  ", { line: loc.start_line - 1, character: 0 })
+        end
+
+        move_cursor_to(@position[:line], @position[:character])
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -107,20 +107,15 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig do
-        params(
-          dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
-          range: T.nilable(T::Range[Integer]),
-        ).void
-      end
-      def initialize(dispatcher, message_queue, range: nil)
-        super(dispatcher, message_queue)
+      sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
+      def initialize(dispatcher, range: nil)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
         @current_scope = T.let(ParameterScope.new, ParameterScope)
+        @inside_regex_capture = T.let(false, T::Boolean)
 
         dispatcher.register(
           self,
@@ -152,6 +147,8 @@ module RubyLsp
           :on_local_variable_or_write_node_enter,
           :on_local_variable_target_node_enter,
           :on_block_local_variable_node_enter,
+          :on_match_write_node_enter,
+          :on_match_write_node_leave,
         )
       end
 
@@ -165,14 +162,28 @@ module RubyLsp
         # We can't push a semantic token for [] and []= because the argument inside the brackets is a part of
         # the message_loc
         return if message.start_with?("[") && (message.end_with?("]") || message.end_with?("]="))
-
-        return process_regexp_locals(node) if message == "=~"
+        return if message == "=~"
         return if special_method?(message)
 
         type = Support::Sorbet.annotation?(node) ? :type : :method
         add_token(T.must(node.message_loc), type)
       end
 
+      sig { params(node: Prism::MatchWriteNode).void }
+      def on_match_write_node_enter(node)
+        call = node.call
+
+        if call.message == "=~"
+          @inside_regex_capture = true
+          process_regexp_locals(call)
+        end
+      end
+
+      sig { params(node: Prism::MatchWriteNode).void }
+      def on_match_write_node_leave(node)
+        @inside_regex_capture = true if node.call.message == "=~"
+      end
+
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
         return unless visible?(node, @range)
@@ -359,6 +370,12 @@ module RubyLsp
 
       sig { params(node: Prism::LocalVariableTargetNode).void }
       def on_local_variable_target_node_enter(node)
+        # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.
+        # Unfortunately, if the regex contains a backslash, the location will be incorrect and we'll end up highlighting
+        # the entire regex as a local variable. We process these captures in process_regexp_locals instead and then
+        # prevent pushing local variable target tokens. See https://github.com/ruby/prism/issues/1912
+        return if @inside_regex_capture
+
         return unless visible?(node, @range)
 
         add_token(node.location, @current_scope.type_for(node.name))

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -19,30 +19,23 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
-        sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
-        def initialize(offense, uri)
+        # TODO: avoid passing document once we have alternative ways to get at
+        # encoding and file source
+        sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        def initialize(document, offense, uri)
+          @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(Interface::CodeAction) }
-        def to_lsp_code_action
-          Interface::CodeAction.new(
-            title: "Autocorrect #{@offense.cop_name}",
-            kind: Constant::CodeActionKind::QUICK_FIX,
-            edit: Interface::WorkspaceEdit.new(
-              document_changes: [
-                Interface::TextDocumentEdit.new(
-                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri.to_s,
-                    version: nil,
-                  ),
-                  edits: @offense.correctable? ? offense_replacements : [],
-                ),
-              ],
-            ),
-            is_preferred: true,
-          )
+        sig { returns(T::Array[Interface::CodeAction]) }
+        def to_lsp_code_actions
+          code_actions = []
+
+          code_actions << autocorrect_action if @offense.correctable?
+          code_actions << disable_line_action
+
+          code_actions
         end
 
         sig { returns(Interface::Diagnostic) }
@@ -65,7 +58,7 @@ module RubyLsp
             ),
             data: {
               correctable: @offense.correctable?,
-              code_action: to_lsp_code_action,
+              code_actions: to_lsp_code_actions,
             },
           )
         end
@@ -90,6 +83,26 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
+        sig { returns(Interface::CodeAction) }
+        def autocorrect_action
+          Interface::CodeAction.new(
+            title: "Autocorrect #{@offense.cop_name}",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: @offense.correctable? ? offense_replacements : [],
+                ),
+              ],
+            ),
+            is_preferred: true,
+          )
+        end
+
         sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
@@ -102,6 +115,64 @@ module RubyLsp
             )
           end
         end
+
+        sig { returns(Interface::CodeAction) }
+        def disable_line_action
+          Interface::CodeAction.new(
+            title: "Disable #{@offense.cop_name} for this line",
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
+              document_changes: [
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri.to_s,
+                    version: nil,
+                  ),
+                  edits: line_disable_comment,
+                ),
+              ],
+            ),
+          )
+        end
+
+        sig { returns(T::Array[Interface::TextEdit]) }
+        def line_disable_comment
+          new_text = if @offense.source_line.include?(" # rubocop:disable ")
+            ",#{@offense.cop_name}"
+          else
+            " # rubocop:disable #{@offense.cop_name}"
+          end
+
+          eol = Interface::Position.new(
+            line: @offense.line - 1,
+            character: length_of_line(@offense.source_line),
+          )
+
+          # TODO: fails for multiline strings - may be preferable to use block
+          # comments to disable some offenses
+          inline_comment = Interface::TextEdit.new(
+            range: Interface::Range.new(start: eol, end: eol),
+            new_text: new_text,
+          )
+
+          [inline_comment]
+        end
+
+        sig { params(line: String).returns(Integer) }
+        def length_of_line(line)
+          if @document.encoding == Constant::PositionEncodingKind::UTF16
+            line_length = 0
+            line.codepoints.each do |codepoint|
+              line_length += 1
+              if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+                line_length += 1
+              end
+            end
+            line_length
+          else
+            line.length
+          end
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb

@@ -25,7 +25,7 @@ module RubyLsp
           @runner.run(filename, document.source)
 
           @runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(offense, uri)
+            Support::RuboCopDiagnostic.new(document, offense, uri)
           end
         end
       end

data/lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb

@@ -34,15 +34,10 @@ module RubyLsp
 
         sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
-          relative_path = Pathname.new(T.must(uri.to_standardized_path || uri.opaque))
-            .relative_path_from(T.must(WORKSPACE_URI.to_standardized_path))
-          return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }
+          path = uri.to_standardized_path
+          return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
 
-          SyntaxTree.format(
-            document.source,
-            @options.print_width,
-            options: @options.formatter_options,
-          )
+          SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
       end
     end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -75,6 +75,8 @@ module RubyLsp
           Constant::SymbolKind::CONSTANT
         when RubyIndexer::Entry::Method
           entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
+        when RubyIndexer::Entry::Accessor
+          Constant::SymbolKind::PROPERTY
         end
       end
     end

data/lib/ruby_lsp/store.rb

@@ -17,6 +17,12 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_accessor :experimental_features
 
+    sig { returns(URI::Generic) }
+    attr_accessor :workspace_uri
+
+    sig { returns(T::Hash[Symbol, RequestConfig]) }
+    attr_accessor :features_configuration
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
@@ -24,6 +30,21 @@ module RubyLsp
       @formatter = T.let("auto", String)
       @supports_progress = T.let(true, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
+      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+      @features_configuration = T.let(
+        {
+          codeLens: RequestConfig.new({
+            enableAll: false,
+            gemfileLinks: true,
+          }),
+          inlayHint: RequestConfig.new({
+            enableAll: false,
+            implicitRescue: false,
+            implicitHashValue: false,
+          }),
+        },
+        T::Hash[Symbol, RequestConfig],
+      )
     end
 
     sig { params(uri: URI::Generic).returns(Document) }

data/lib/ruby_lsp/utils.rb

@@ -4,10 +4,6 @@
 module RubyLsp
   # Used to indicate that a request shouldn't return a response
   VOID = T.let(Object.new.freeze, Object)
-
-  # This freeze is not redundant since the interpolated string is mutable
-  WORKSPACE_URI = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
-
   BUNDLE_PATH = T.let(
     begin
       Bundler.bundle_path.to_s
@@ -78,4 +74,22 @@ module RubyLsp
       @cancelled = true
     end
   end
+
+  # A request configuration, to turn on/off features
+  class RequestConfig
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T::Boolean]) }
+    attr_accessor :configuration
+
+    sig { params(configuration: T::Hash[Symbol, T::Boolean]).void }
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    sig { params(feature: Symbol).returns(T.nilable(T::Boolean)) }
+    def enabled?(feature)
+      @configuration[:enableAll] || @configuration[feature]
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.13.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-24 00:00:00.000000000 Z
+date: 2023-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.18.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.18.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -157,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby