ruby-lsp 0.3.8 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f1ed447e51909ada66f6bebceca82d807686a4889468838a797e2ed8afff50e
-  data.tar.gz: 7b429773bbdebc171debbe446adb868136bd15b5f493542898df0a9c82f3514e
+  metadata.gz: '0812eed9a874fa78fbe75cf2e8dc2bd58c2dfb67a61353f732aaba965ae9d66f'
+  data.tar.gz: 6d9a567aa54c95f5fd7ada3756d4b5575f068bee90f19f99f83f485d91de83a0
 SHA512:
-  metadata.gz: 62e8a6ee36c43dec6ec0af16fd19830b6369446455a5fc16871c368c8bb4ccdb47c0d9c5678990a43604bf03c622c2ef13bb82c6a6e9f26fdcde72b3b18ec99e
-  data.tar.gz: e441a670c22bcdbfdc3afe99743fe6e1c4aa5f28edaedcf09f47255372322c52ead68988bc6d7ce09170e368e4059c94dac73b395a640c86f20b2969ae8e8095
+  metadata.gz: 53311978b0c6d32a34e1e69ddeea1d4b154ee0e2bc1cd426fd7e4db6ab46eeb7a5dff7d0516b5c2c722f95f05a0c5051fe7caf874e14740b5023b5f0e79da962
+  data.tar.gz: ce04150602707622dd0d463a35a2a9c94fe7b24b1e376dbeeae4e45f4487438219f8ab48056658946e9f7cc56136714496fdfbddf7513b77fea334aac2687ae3

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.1

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/document.rb

@@ -21,9 +21,10 @@ module RubyLsp
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
+      @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
     rescue SyntaxTree::Parser::ParseError
-      # Do not raise if we failed to parse
+      @syntax_error = true
     end
 
     sig { params(other: Document).returns(T::Boolean) }
@@ -68,14 +69,15 @@ module RubyLsp
       return if @unparsed_edits.empty?
 
       @tree = SyntaxTree.parse(@source)
+      @syntax_error = false
       @unparsed_edits.clear
     rescue SyntaxTree::Parser::ParseError
-      # Do nothing if we fail parse
+      @syntax_error = true
     end
 
     sig { returns(T::Boolean) }
     def syntax_error?
-      @unparsed_edits.any?
+      @syntax_error
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/executor.rb

@@ -0,0 +1,390 @@
+# 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 "initialized"
+        warn("Ruby LSP is ready")
+        VOID
+      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 "codeAction/resolve"
+        code_action_resolve(request.dig(:params))
+      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)
+      document = @store.get(uri)
+
+      Requests::CodeActions.new(uri, document, range, context).run
+    end
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
+    def code_action_resolve(params)
+      uri = params.dig(:data, :uri)
+      document = @store.get(uri)
+      result = Requests::CodeActionResolve.new(document, params).run
+
+      case result
+      when Requests::CodeActionResolve::Error::EmptySelection
+        @notifications << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Invalid selection for Extract Variable refactor",
+          ),
+        )
+        raise Requests::CodeActionResolve::CodeActionError
+      else
+        result
+      end
+    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
+
+      code_action_provider = if enabled_features.include?("codeActions")
+        Interface::CodeActionOptions.new(resolve_provider: true)
+      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: code_action_provider,
+          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_action_resolve.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Code action resolve demo](../../misc/code_action_resolve.gif)
+    #
+    # The [code action resolve](https://microsoft.github.io/language-server-protocol/specification#codeAction_resolve)
+    # request is used to to resolve the edit field for a given code action, if it is not already provided in the
+    # textDocument/codeAction response. We can use it for scenarios that require more computation such as refactoring.
+    #
+    # # Example: Extract to variable
+    #
+    # ```ruby
+    # # Before:
+    # 1 + 1 # Select the text and use Refactor: Extract Variable
+    #
+    # # After:
+    # new_variable = 1 + 1
+    # new_variable
+    #
+    # ```
+    #
+    class CodeActionResolve < BaseRequest
+      extend T::Sig
+      NEW_VARIABLE_NAME = "new_variable"
+
+      class CodeActionError < StandardError; end
+
+      class Error < ::T::Enum
+        enums do
+          EmptySelection = new
+        end
+      end
+
+      sig { params(document: Document, code_action: T::Hash[Symbol, T.untyped]).void }
+      def initialize(document, code_action)
+        super(document)
+
+        @code_action = code_action
+      end
+
+      sig { override.returns(T.any(Interface::CodeAction, Error)) }
+      def run
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        scanner = @document.create_scanner
+        start_index = scanner.find_char_position(source_range[:start])
+        end_index = scanner.find_char_position(source_range[:end])
+        extraction_source = T.must(@document.source[start_index...end_index])
+        source_line_indentation = T.must(T.must(@document.source.lines[source_range.dig(:start, :line)])[/\A */]).size
+
+        Interface::CodeAction.new(
+          title: "Refactor: Extract Variable",
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: edits_to_extract_variable(source_range, extraction_source, source_line_indentation),
+              ),
+            ],
+          ),
+        )
+      end
+
+      private
+
+      sig do
+        params(range: Document::RangeShape, source: String, indentation: Integer)
+          .returns(T::Array[Interface::TextEdit])
+      end
+      def edits_to_extract_variable(range, source, indentation)
+        target_range = {
+          start: { line: range.dig(:start, :line), character: indentation },
+          end: { line: range.dig(:start, :line), character: indentation },
+        }
+
+        [
+          create_text_edit(range, NEW_VARIABLE_NAME),
+          create_text_edit(target_range, "#{NEW_VARIABLE_NAME} = #{source}\n#{" " * indentation}"),
+        ]
+      end
+
+      sig { params(range: Document::RangeShape, new_text: String).returns(Interface::TextEdit) }
+      def create_text_edit(range, new_text)
+        Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: range.dig(:start, :line), character: range.dig(:start, :character)),
+            end: Interface::Position.new(line: range.dig(:end, :line), character: range.dig(:end, :character)),
+          ),
+          new_text: new_text,
+        )
+      end
+    end
+  end
+end