ruby-lsp 0.3.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f1ed447e51909ada66f6bebceca82d807686a4889468838a797e2ed8afff50e
-  data.tar.gz: 7b429773bbdebc171debbe446adb868136bd15b5f493542898df0a9c82f3514e
+  metadata.gz: 65db08cd80bfe40116f70065b717ad88d1b1fd4fd86c6fcf1de2d5be9636ddce
+  data.tar.gz: 84a483aef0e88650a0b2bdbd0db0c3a5c1cd1cfff1e87508a09d7d4d8a616f36
 SHA512:
-  metadata.gz: 62e8a6ee36c43dec6ec0af16fd19830b6369446455a5fc16871c368c8bb4ccdb47c0d9c5678990a43604bf03c622c2ef13bb82c6a6e9f26fdcde72b3b18ec99e
-  data.tar.gz: e441a670c22bcdbfdc3afe99743fe6e1c4aa5f28edaedcf09f47255372322c52ead68988bc6d7ce09170e368e4059c94dac73b395a640c86f20b2969ae8e8095
+  metadata.gz: 1ff522bae2c2d469c1fb5817c1b9ed65867ad19d64e00c0b14d4faa6b38bd62321c3109292f1021174766e2da240bd17faea1f8185672164307d2dafe88845bb
+  data.tar.gz: 7e89c4c38b833269e9d9a09f55333d32f6e1ef4872174d92e7b92a048cf51f62a837b7d9d4c217f3cccb9a196bb6d3b004439e4de8cc9e588c9b445a2f0c46e8

data/README.md

@@ -4,6 +4,37 @@
 
 This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
 
+# Overview
+
+The intention of Ruby LSP is to provide a fast, robust and feature-rich coding environment for Ruby developers.
+
+It's part of a [wider Shopify goal](https://github.com/Shopify/vscode-shopify-ruby) to provide a state-of-the-art experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
+
+It provides many features, including:
+
+* Syntax highlighting
+* Linting and formatting
+* Code folding
+* Selection ranges
+
+It does not perform typechecking, so its features are implemented on a best-effort basis, aiming to be as accurate as possible.
+
+Planned future features include:
+
+* Auto-completion and navigation ("Go To Definition") ([prototype](https://github.com/Shopify/ruby-lsp/pull/429))
+* Support for plug-ins to extend behavior
+
+The Ruby LSP does not perform any type-checking or provide any type-related assistance, but it can be used alongside [Sorbet](https://github.com/sorbet/sorbet)'s LSP server.
+
+At the time of writing, these are the major differences between Ruby LSP and [Solargraph](https://solargraph.org/):
+
+* Solargraph [uses](https://solargraph.org/guides/yard) YARD documentation to gather information about your project and its gem dependencies. This provides functionality such as context-aware auto-completion and navigation ("Go To Definition")
+* Solargraph can be used as a globally installed gem, but Ruby LSP must be added to the Gemfile or gemspec if using RuboCop. (There are pros and cons to each approach)
+
+## Learn More
+
+* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+
 ## Usage
 
 Install the gem. There's no need to require it, since the server is used as a standalone executable.
@@ -17,7 +48,7 @@ end
 If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
 the editor.
 
-See the [documentation](https://shopify.github.io/ruby-lsp) for
+See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
 ## Contributing
@@ -105,6 +136,13 @@ The `launch.json` contains a 'Minitest - current file' configuration for the deb
 1. When the breakpoint is triggered, the process will pause and VS Code will connect to the debugger and activate the debugger UI.
 1. Open the Debug Console view to use the debugger's REPL.
 
+## Spell Checking
+
+VS Code users will be prompted to enable the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension.
+By default this will be enabled for all workspaces, but you can choose to selectively enable or disable it per workspace.
+
+If you introduce a word which the spell checker does not recognize, you can add it to the `cspell.json` configuration alongside your PR.
+
 ## License
 
 The gem is available as open source under the terms of the

data/VERSION

@@ -1 +1 @@
-0.3.8
+0.4.0

data/exe/ruby-lsp

@@ -18,4 +18,5 @@ rescue
   nil
 end
 
-require_relative "../lib/ruby_lsp/server"
+require_relative "../lib/ruby_lsp/internal"
+RubyLsp::Server.new.start

data/lib/ruby_lsp/executor.rb

@@ -0,0 +1,362 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # This class dispatches a request execution to the right request class. No IO should happen anywhere here!
+  class Executor
+    extend T::Sig
+
+    sig { params(store: Store).void }
+    def initialize(store)
+      # Requests that mutate the store must be run sequentially! Parallel requests only receive a temporary copy of the
+      # store
+      @store = store
+      @notifications = T.let([], T::Array[Notification])
+    end
+
+    sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
+    def execute(request)
+      response = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(Exception))
+
+      request_time = Benchmark.realtime do
+        response = run(request)
+      rescue StandardError, LoadError => e
+        error = e
+      end
+
+      Result.new(response: response, error: error, request_time: request_time, notifications: @notifications)
+    end
+
+    private
+
+    sig { params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def run(request)
+      uri = request.dig(:params, :textDocument, :uri)
+
+      case request[:method]
+      when "initialize"
+        initialize_request(request.dig(:params))
+      when "textDocument/didOpen"
+        text_document_did_open(uri, request.dig(:params, :textDocument, :text))
+      when "textDocument/didClose"
+        @notifications << Notification.new(
+          message: "textDocument/publishDiagnostics",
+          params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
+        )
+
+        text_document_did_close(uri)
+      when "textDocument/didChange"
+        text_document_did_change(uri, request.dig(:params, :contentChanges))
+      when "textDocument/foldingRange"
+        folding_range(uri)
+      when "textDocument/documentLink"
+        document_link(uri)
+      when "textDocument/selectionRange"
+        selection_range(uri, request.dig(:params, :positions))
+      when "textDocument/documentSymbol"
+        document_symbol(uri)
+      when "textDocument/semanticTokens/full"
+        semantic_tokens_full(uri)
+      when "textDocument/semanticTokens/range"
+        semantic_tokens_range(uri, request.dig(:params, :range))
+      when "textDocument/formatting"
+        begin
+          formatting(uri)
+        rescue StandardError => error
+          @notifications << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::ERROR,
+              message: "Formatting error: #{error.message}",
+            ),
+          )
+
+          nil
+        end
+      when "textDocument/documentHighlight"
+        document_highlight(uri, request.dig(:params, :position))
+      when "textDocument/onTypeFormatting"
+        on_type_formatting(uri, request.dig(:params, :position), request.dig(:params, :ch))
+      when "textDocument/hover"
+        hover(uri, request.dig(:params, :position))
+      when "textDocument/inlayHint"
+        inlay_hint(uri, request.dig(:params, :range))
+      when "textDocument/codeAction"
+        code_action(uri, request.dig(:params, :range), request.dig(:params, :context))
+      when "textDocument/diagnostic"
+        begin
+          diagnostic(uri)
+        rescue StandardError => error
+          @notifications << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::ERROR,
+              message: "Error running diagnostics: #{error.message}",
+            ),
+          )
+
+          nil
+        end
+      when "textDocument/completion"
+        completion(uri, request.dig(:params, :position))
+      end
+    end
+
+    sig { params(uri: String).returns(T::Array[Interface::FoldingRange]) }
+    def folding_range(uri)
+      @store.cache_fetch(uri, :folding_ranges) do |document|
+        Requests::FoldingRanges.new(document).run
+      end
+    end
+
+    sig do
+      params(
+        uri: String,
+        position: Document::PositionShape,
+      ).returns(T.nilable(Interface::Hover))
+    end
+    def hover(uri, position)
+      RubyLsp::Requests::Hover.new(@store.get(uri), position).run
+    end
+
+    sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
+    def document_link(uri)
+      @store.cache_fetch(uri, :document_link) do |document|
+        RubyLsp::Requests::DocumentLink.new(uri, document).run
+      end
+    end
+
+    sig { params(uri: String).returns(T::Array[Interface::DocumentSymbol]) }
+    def document_symbol(uri)
+      @store.cache_fetch(uri, :document_symbol) do |document|
+        Requests::DocumentSymbol.new(document).run
+      end
+    end
+
+    sig { params(uri: String, content_changes: T::Array[Document::EditShape]).returns(Object) }
+    def text_document_did_change(uri, content_changes)
+      @store.push_edits(uri, content_changes)
+      VOID
+    end
+
+    sig { params(uri: String, text: String).returns(Object) }
+    def text_document_did_open(uri, text)
+      @store.set(uri, text)
+      VOID
+    end
+
+    sig { params(uri: String).returns(Object) }
+    def text_document_did_close(uri)
+      @store.delete(uri)
+      VOID
+    end
+
+    sig do
+      params(
+        uri: String,
+        positions: T::Array[Document::PositionShape],
+      ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
+    end
+    def selection_range(uri, positions)
+      ranges = @store.cache_fetch(uri, :selection_ranges) do |document|
+        Requests::SelectionRanges.new(document).run
+      end
+
+      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
+      # every position in the positions array should have an element at the same index in the response
+      # array. For positions without a valid selection range, the corresponding element in the response
+      # array will be nil.
+
+      unless ranges.nil?
+        positions.map do |position|
+          ranges.find do |range|
+            range.cover?(position)
+          end
+        end
+      end
+    end
+
+    sig { params(uri: String).returns(Interface::SemanticTokens) }
+    def semantic_tokens_full(uri)
+      @store.cache_fetch(uri, :semantic_highlighting) do |document|
+        T.cast(
+          Requests::SemanticHighlighting.new(
+            document,
+            encoder: Requests::Support::SemanticTokenEncoder.new,
+          ).run,
+          Interface::SemanticTokens,
+        )
+      end
+    end
+
+    sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
+    def formatting(uri)
+      Requests::Formatting.new(uri, @store.get(uri)).run
+    end
+
+    sig do
+      params(
+        uri: String,
+        position: Document::PositionShape,
+        character: String,
+      ).returns(T::Array[Interface::TextEdit])
+    end
+    def on_type_formatting(uri, position, character)
+      Requests::OnTypeFormatting.new(@store.get(uri), position, character).run
+    end
+
+    sig do
+      params(
+        uri: String,
+        position: Document::PositionShape,
+      ).returns(T::Array[Interface::DocumentHighlight])
+    end
+    def document_highlight(uri, position)
+      Requests::DocumentHighlight.new(@store.get(uri), position).run
+    end
+
+    sig { params(uri: String, range: Document::RangeShape).returns(T::Array[Interface::InlayHint]) }
+    def inlay_hint(uri, range)
+      document = @store.get(uri)
+      start_line = range.dig(:start, :line)
+      end_line = range.dig(:end, :line)
+
+      Requests::InlayHints.new(document, start_line..end_line).run
+    end
+
+    sig do
+      params(
+        uri: String,
+        range: Document::RangeShape,
+        context: T::Hash[Symbol, T.untyped],
+      ).returns(T.nilable(T::Array[Interface::CodeAction]))
+    end
+    def code_action(uri, range, context)
+      start_line = range.dig(:start, :line)
+      end_line = range.dig(:end, :line)
+      document = @store.get(uri)
+
+      Requests::CodeActions.new(uri, document, start_line..end_line, context).run
+    end
+
+    sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
+    def diagnostic(uri)
+      response = @store.cache_fetch(uri, :diagnostics) do |document|
+        Requests::Diagnostics.new(uri, document).run
+      end
+
+      Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
+    end
+
+    sig { params(uri: String, range: Document::RangeShape).returns(Interface::SemanticTokens) }
+    def semantic_tokens_range(uri, range)
+      document = @store.get(uri)
+      start_line = range.dig(:start, :line)
+      end_line = range.dig(:end, :line)
+
+      T.cast(
+        Requests::SemanticHighlighting.new(
+          document,
+          range: start_line..end_line,
+          encoder: Requests::Support::SemanticTokenEncoder.new,
+        ).run,
+        Interface::SemanticTokens,
+      )
+    end
+
+    sig do
+      params(uri: String, position: Document::PositionShape).returns(T.nilable(T::Array[Interface::CompletionItem]))
+    end
+    def completion(uri, position)
+      Requests::PathCompletion.new(@store.get(uri), position).run
+    end
+
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
+    def initialize_request(options)
+      @store.clear
+      @store.encoding = options.dig(:capabilities, :general, :positionEncodings)
+      enabled_features = options.dig(:initializationOptions, :enabledFeatures) || []
+
+      document_symbol_provider = if enabled_features.include?("documentSymbols")
+        Interface::DocumentSymbolClientCapabilities.new(
+          hierarchical_document_symbol_support: true,
+          symbol_kind: {
+            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
+          },
+        )
+      end
+
+      document_link_provider = if enabled_features.include?("documentLink")
+        Interface::DocumentLinkOptions.new(resolve_provider: false)
+      end
+
+      hover_provider = if enabled_features.include?("hover")
+        Interface::HoverClientCapabilities.new(dynamic_registration: false)
+      end
+
+      folding_ranges_provider = if enabled_features.include?("foldingRanges")
+        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
+      end
+
+      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
+        Interface::SemanticTokensRegistrationOptions.new(
+          document_selector: { scheme: "file", language: "ruby" },
+          legend: Interface::SemanticTokensLegend.new(
+            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
+            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
+          ),
+          range: true,
+          full: { delta: false },
+        )
+      end
+
+      diagnostics_provider = if enabled_features.include?("diagnostics")
+        {
+          interFileDependencies: false,
+          workspaceDiagnostics: false,
+        }
+      end
+
+      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
+        Interface::DocumentOnTypeFormattingOptions.new(
+          first_trigger_character: "{",
+          more_trigger_character: ["\n", "|"],
+        )
+      end
+
+      inlay_hint_provider = if enabled_features.include?("inlayHint")
+        Interface::InlayHintOptions.new(resolve_provider: false)
+      end
+
+      completion_provider = if enabled_features.include?("completion")
+        Interface::CompletionOptions.new(
+          resolve_provider: false,
+          trigger_characters: ["/"],
+        )
+      end
+
+      Interface::InitializeResult.new(
+        capabilities: Interface::ServerCapabilities.new(
+          text_document_sync: Interface::TextDocumentSyncOptions.new(
+            change: Constant::TextDocumentSyncKind::INCREMENTAL,
+            open_close: true,
+          ),
+          selection_range_provider: enabled_features.include?("selectionRanges"),
+          hover_provider: hover_provider,
+          document_symbol_provider: document_symbol_provider,
+          document_link_provider: document_link_provider,
+          folding_range_provider: folding_ranges_provider,
+          semantic_tokens_provider: semantic_tokens_provider,
+          document_formatting_provider: enabled_features.include?("formatting"),
+          document_highlight_provider: enabled_features.include?("documentHighlights"),
+          code_action_provider: enabled_features.include?("codeActions"),
+          document_on_type_formatting_provider: on_type_formatting_provider,
+          diagnostic_provider: diagnostics_provider,
+          inlay_hint_provider: inlay_hint_provider,
+          completion_provider: completion_provider,
+        ),
+      )
+    end
+  end
+end

data/lib/ruby_lsp/internal.rb

@@ -4,6 +4,11 @@
 require "sorbet-runtime"
 require "syntax_tree"
 require "language_server-protocol"
+require "benchmark"
 
 require "ruby-lsp"
-require "ruby_lsp/handler"
+require "ruby_lsp/utils"
+require "ruby_lsp/server"
+require "ruby_lsp/executor"
+require "ruby_lsp/requests"
+require "ruby_lsp/store"

data/lib/ruby_lsp/requests/base_request.rb

@@ -10,8 +10,12 @@ module RubyLsp
 
       abstract!
 
-      sig { params(document: Document).void }
-      def initialize(document)
+      # We must accept rest keyword arguments here, so that the argument count matches when
+      # SyntaxTree::WithScope#initialize invokes `super` for Sorbet. We don't actually use these parameters for
+      # anything. We can remove these arguments once we drop support for Ruby 2.7
+      # https://github.com/ruby-syntax-tree/syntax_tree/blob/4dac90b53df388f726dce50ce638a1ba71cc59f8/lib/syntax_tree/with_scope.rb#L122
+      sig { params(document: Document, _kwargs: T.untyped).void }
+      def initialize(document, **_kwargs)
         @document = document
 
         # Parsing the document here means we're taking a lazy approach by only doing it when the first feature request
@@ -62,9 +66,10 @@ module RubyLsp
         params(
           node: SyntaxTree::Node,
           position: Integer,
+          node_types: T::Array[T.class_of(SyntaxTree::Node)],
         ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
       end
-      def locate(node, position)
+      def locate(node, position, node_types: [])
         queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
         closest = node
 
@@ -90,6 +95,8 @@ module RubyLsp
             parent = T.let(closest, SyntaxTree::Node)
             closest = candidate
           end
+
+          break if node_types.any? { |type| candidate.is_a?(type) }
         end
 
         [closest, parent]

data/lib/ruby_lsp/requests/code_actions.rb

@@ -24,24 +24,38 @@ module RubyLsp
           uri: String,
           document: Document,
           range: T::Range[Integer],
+          context: T::Hash[Symbol, T.untyped],
         ).void
       end
-      def initialize(uri, document, range)
+      def initialize(uri, document, range, context)
         super(document)
 
         @uri = uri
         @range = range
+        @context = context
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::CodeAction], Object))) }
       def run
-        diagnostics = @document.cache_fetch(:diagnostics) { Diagnostics.new(@uri, @document).run }
-        corrections = diagnostics.select do |diagnostic|
-          diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
+        diagnostics = @context[:diagnostics]
+        return if diagnostics.nil? || diagnostics.empty?
+
+        diagnostics.filter_map do |diagnostic|
+          code_action = diagnostic.dig(:data, :code_action)
+          next if code_action.nil?
+
+          # We want to return only code actions that are within range or that do not have any edits, such as refactor
+          # code actions
+          range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
+          code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
-        return [] if corrections.empty?
+      end
+
+      private
 
-        T.cast(corrections, T::Array[Support::RuboCopDiagnostic]).map!(&:to_lsp_code_action)
+      sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
+      def cover?(range)
+        range.nil? || @range.cover?(range.dig(:start, :line)..range.dig(:end, :line))
       end
     end
   end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -15,7 +15,7 @@ module RubyLsp
     #
     # ```ruby
     # def say_hello
-    # puts "Hello" # --> diagnostics: incorrect indentantion
+    # puts "Hello" # --> diagnostics: incorrect indentation
     # end
     # ```
     class Diagnostics < BaseRequest
@@ -28,17 +28,13 @@ module RubyLsp
         @uri = uri
       end
 
-      sig do
-        override.returns(
-          T.any(
-            T.all(T::Array[Support::RuboCopDiagnostic], Object),
-            T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
-          ),
-        )
-      end
+      sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
       def run
-        return [] if @document.syntax_error?
-        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
+        return if @document.syntax_error?
+        return unless defined?(Support::RuboCopDiagnosticsRunner)
+
+        # Don't try to run RuboCop diagnostics for files outside the current working directory
+        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/formatting.rb

@@ -32,8 +32,11 @@ module RubyLsp
         @uri = uri
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
+        # Don't try to format files outside the current working directory
+        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
+
         formatted_text = formatted_file
         return unless formatted_text
 
@@ -41,10 +44,10 @@ module RubyLsp
         return if formatted_text.size == size && formatted_text == @document.source
 
         [
-          LanguageServer::Protocol::Interface::TextEdit.new(
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(line: 0, character: 0),
-              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size),
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: 0, character: 0),
+              end: Interface::Position.new(line: size, character: size),
             ),
             new_text: formatted_text,
           ),

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -32,8 +32,8 @@ module RubyLsp
 
         scanner = document.create_scanner
         line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
-        line_end = scanner.find_char_position(position)
-        line = T.must(@document.source[line_begin..line_end])
+        @line_end = T.let(scanner.find_char_position(position), Integer)
+        line = T.must(@document.source[line_begin..@line_end])
 
         @indentation = T.let(find_indentation(line), Integer)
         @previous_line = T.let(line.strip.chomp, String)
@@ -42,7 +42,7 @@ module RubyLsp
         @trigger_character = trigger_character
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
       def run
         case @trigger_character
         when "{"
@@ -84,8 +84,30 @@ module RubyLsp
 
         indents = " " * @indentation
 
-        add_edit_with_text(" \n#{indents}end")
-        move_cursor_to(@position[:line], @indentation + 2)
+        if @previous_line.include?("\n")
+          # If the previous line has a line break, then it means there's content after the line break that triggered
+          # this completion. For these cases, we want to add the `end` after the content and move the cursor back to the
+          # keyword that triggered the completion
+
+          line = @position[:line]
+
+          # If there are enough lines in the document, we want to add the `end` token on the line below the extra
+          # content. Otherwise, we want to insert and extra line break ourselves
+          correction = if T.must(@document.source[@line_end..-1]).count("\n") >= 2
+            line -= 1
+            "#{indents}end"
+          else
+            "#{indents}\nend"
+          end
+
+          add_edit_with_text(correction, { line: @position[:line] + 1, character: @position[:character] })
+          move_cursor_to(line, @indentation + 3)
+        else
+          # If there's nothing after the new line break that triggered the completion, then we want to add the `end` and
+          # move the cursor to the body of the statement
+          add_edit_with_text(" \n#{indents}end")
+          move_cursor_to(@position[:line], @indentation + 2)
+        end
       end
 
       sig { params(spaces: String).void }
@@ -94,18 +116,15 @@ module RubyLsp
         move_cursor_to(@position[:line], @indentation + spaces.size + 1)
       end
 
-      sig { params(text: String).void }
-      def add_edit_with_text(text)
-        position = Interface::Position.new(
-          line: @position[:line],
-          character: @position[:character],
+      sig { params(text: String, position: Document::PositionShape).void }
+      def add_edit_with_text(text, position = @position)
+        pos = Interface::Position.new(
+          line: position[:line],
+          character: position[:character],
         )
 
         @edits << Interface::TextEdit.new(
-          range: Interface::Range.new(
-            start: position,
-            end: position,
-          ),
+          range: Interface::Range.new(start: pos, end: pos),
           new_text: text,
         )
       end