ruby-lsp 0.13.4 → 0.14.0

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -0,0 +1,199 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class SemanticHighlighting < ResponseBuilder
+      class UndefinedTokenType < StandardError; end
+
+      TOKEN_TYPES = T.let(
+        {
+          namespace: 0,
+          type: 1,
+          class: 2,
+          enum: 3,
+          interface: 4,
+          struct: 5,
+          typeParameter: 6,
+          parameter: 7,
+          variable: 8,
+          property: 9,
+          enumMember: 10,
+          event: 11,
+          function: 12,
+          method: 13,
+          macro: 14,
+          keyword: 15,
+          modifier: 16,
+          comment: 17,
+          string: 18,
+          number: 19,
+          regexp: 20,
+          operator: 21,
+          decorator: 22,
+        }.freeze,
+        T::Hash[Symbol, Integer],
+      )
+
+      TOKEN_MODIFIERS = T.let(
+        {
+          declaration: 0,
+          definition: 1,
+          readonly: 2,
+          static: 3,
+          deprecated: 4,
+          abstract: 5,
+          async: 6,
+          modification: 7,
+          documentation: 8,
+          default_library: 9,
+        }.freeze,
+        T::Hash[Symbol, Integer],
+      )
+
+      extend T::Sig
+
+      ResponseType = type_member { { fixed: Interface::SemanticTokens } }
+
+      sig { void }
+      def initialize
+        super
+        @stack = T.let([], T::Array[SemanticToken])
+      end
+
+      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      def add_token(location, type, modifiers = [])
+        length = location.end_offset - location.start_offset
+        modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
+        @stack.push(
+          SemanticToken.new(
+            location: location,
+            length: length,
+            type: T.must(TOKEN_TYPES[type]),
+            modifier: modifiers_indices,
+          ),
+        )
+      end
+
+      sig { returns(T.nilable(SemanticToken)) }
+      def last
+        @stack.last
+      end
+
+      sig { override.returns(Interface::SemanticTokens) }
+      def response
+        SemanticTokenEncoder.new.encode(@stack)
+      end
+
+      class SemanticToken
+        extend T::Sig
+
+        sig { returns(Prism::Location) }
+        attr_reader :location
+
+        sig { returns(Integer) }
+        attr_reader :length
+
+        sig { returns(Integer) }
+        attr_reader :type
+
+        sig { returns(T::Array[Integer]) }
+        attr_reader :modifier
+
+        sig { params(location: Prism::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
+        def initialize(location:, length:, type:, modifier:)
+          @location = location
+          @length = length
+          @type = type
+          @modifier = modifier
+        end
+
+        sig { params(type_symbol: Symbol).void }
+        def replace_type(type_symbol)
+          type_int = TOKEN_TYPES[type_symbol]
+          raise UndefinedTokenType, "Undefined token type: #{type_symbol}" unless type_int
+
+          @type = type_int
+        end
+
+        sig { params(modifier_symbols: T::Array[Symbol]).void }
+        def replace_modifier(modifier_symbols)
+          @modifier = modifier_symbols.filter_map do |modifier_symbol|
+            modifier_index = TOKEN_MODIFIERS[modifier_symbol]
+            raise UndefinedTokenType, "Undefined token modifier: #{modifier_symbol}" unless modifier_index
+
+            modifier_index
+          end
+        end
+      end
+
+      class SemanticTokenEncoder
+        extend T::Sig
+
+        sig { void }
+        def initialize
+          @current_row = T.let(0, Integer)
+          @current_column = T.let(0, Integer)
+        end
+
+        sig do
+          params(
+            tokens: T::Array[SemanticToken],
+          ).returns(Interface::SemanticTokens)
+        end
+        def encode(tokens)
+          sorted_tokens = tokens.sort_by.with_index do |token, index|
+            # Enumerable#sort_by is not deterministic when the compared values are equal.
+            # When that happens, we need to use the index as a tie breaker to ensure
+            # that the order of the tokens is always the same.
+            [token.location.start_line, token.location.start_column, index]
+          end
+
+          delta = sorted_tokens.flat_map do |token|
+            compute_delta(token)
+          end
+
+          Interface::SemanticTokens.new(data: delta)
+        end
+
+        # The delta array is computed according to the LSP specification:
+        # > The protocol for the token format relative uses relative
+        # > positions, because most tokens remain stable relative to
+        # > each other when edits are made in a file. This simplifies
+        # > the computation of a delta if a server supports it. So each
+        # > token is represented using 5 integers.
+
+        # For more information on how each number is calculated, read:
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
+        sig { params(token: SemanticToken).returns(T::Array[Integer]) }
+        def compute_delta(token)
+          row = token.location.start_line - 1
+          column = token.location.start_column
+
+          begin
+            delta_line = row - @current_row
+
+            delta_column = column
+            delta_column -= @current_column if delta_line == 0
+
+            [delta_line, delta_column, token.length, token.type, encode_modifiers(token.modifier)]
+          ensure
+            @current_row = row
+            @current_column = column
+          end
+        end
+
+        # Encode an array of modifiers to positions onto a bit flag
+        # For example, [:default_library] will be encoded as
+        # 0b1000000000, as :default_library is the 10th bit according
+        # to the token modifiers index map.
+        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
+        def encode_modifiers(modifiers)
+          modifiers.inject(0) do |encoded_modifiers, modifier|
+            encoded_modifiers | (1 << modifier)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class SignatureHelp < ResponseBuilder
+      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
+
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+        @signature_help = T.let(nil, ResponseType)
+      end
+
+      sig { params(signature_help: ResponseType).void }
+      def replace(signature_help)
+        @signature_help = signature_help
+      end
+
+      sig { override.returns(ResponseType) }
+      def response
+        @signature_help
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    autoload :CollectionResponseBuilder, "ruby_lsp/response_builders/collection_response_builder"
+    autoload :DocumentSymbol, "ruby_lsp/response_builders/document_symbol"
+    autoload :Hover, "ruby_lsp/response_builders/hover"
+    autoload :ResponseBuilder, "ruby_lsp/response_builders/response_builder"
+    autoload :SemanticHighlighting, "ruby_lsp/response_builders/semantic_highlighting"
+    autoload :SignatureHelp, "ruby_lsp/response_builders/signature_help"
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -58,7 +58,7 @@ module RubyLsp
 
     sig { void }
     def start
-      warn("Starting Ruby LSP v#{VERSION}...")
+      $stderr.puts("Starting Ruby LSP v#{VERSION}...")
 
       # Requests that have to be executed sequentially or in the main process are implemented here. All other requests
       # fall under the else branch which just pushes requests to the queue
@@ -73,7 +73,7 @@ module RubyLsp
         when "$/setTrace"
           VOID
         when "shutdown"
-          warn("Shutting down Ruby LSP...")
+          $stderr.puts("Shutting down Ruby LSP...")
 
           @message_queue.close
           # Close the queue so that we can no longer receive items
@@ -92,7 +92,7 @@ module RubyLsp
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
           # https://microsoft.github.io/language-server-protocol/specification/#exit
           status = @store.empty? ? 0 : 1
-          warn("Shutdown complete with status #{status}")
+          $stderr.puts("Shutdown complete with status #{status}")
           exit(status)
         else
           # Default case: push the request to the queue to be executed by the worker

data/lib/ruby_lsp/setup_bundler.rb

@@ -59,7 +59,9 @@ module RubyLsp
 
       # Do not setup a custom bundle if both `ruby-lsp` and `debug` are already in the Gemfile
       if @dependencies["ruby-lsp"] && @dependencies["debug"]
-        warn("Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in #{@gemfile}")
+        $stderr.puts(
+          "Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in #{@gemfile}",
+        )
 
         # If the user decided to add the `ruby-lsp` and `debug` to their Gemfile after having already run the Ruby LSP,
         # then we need to remove the `.ruby-lsp` folder, otherwise we will run `bundle install` for the top level and
@@ -76,7 +78,7 @@ module RubyLsp
       write_custom_gemfile
 
       unless @gemfile&.exist? && @lockfile&.exist?
-        warn("Ruby LSP> Skipping lockfile copies because there's no top level bundle")
+        $stderr.puts("Ruby LSP> Skipping lockfile copies because there's no top level bundle")
         return run_bundle_install(@custom_gemfile)
       end
 
@@ -84,11 +86,14 @@ module RubyLsp
       current_lockfile_hash = Digest::SHA256.hexdigest(lockfile_contents)
 
       if @custom_lockfile.exist? && @lockfile_hash_path.exist? && @lockfile_hash_path.read == current_lockfile_hash
-        warn("Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date")
+        $stderr.puts(
+          "Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date",
+        )
         return run_bundle_install(@custom_gemfile)
       end
 
       FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
+      correct_relative_remote_paths
       @lockfile_hash_path.write(current_lockfile_hash)
       run_bundle_install(@custom_gemfile)
     end
@@ -208,8 +213,8 @@ module RubyLsp
       command << "1>&2"
 
       # Add bundle update
-      warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
-      warn("Ruby LSP> Command: #{command}")
+      $stderr.puts("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
+      $stderr.puts("Ruby LSP> Command: #{command}")
       system(env, command)
       [bundle_gemfile.to_s, expanded_path, env["BUNDLE_APP_CONFIG"]]
     end
@@ -227,5 +232,25 @@ module RubyLsp
       # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update
       !@last_updated_path.exist? || Time.parse(@last_updated_path.read) < (Time.now - FOUR_HOURS)
     end
+
+    # When a lockfile has remote references based on relative file paths, we need to ensure that they are pointing to
+    # the correct place since after copying the relative path is no longer valid
+    sig { void }
+    def correct_relative_remote_paths
+      content = @custom_lockfile.read
+      content.gsub!(/remote: (.*)/) do |match|
+        path = T.must(Regexp.last_match)[1]
+
+        # We should only apply the correction if the remote is a relative path. It might also be a URI, like
+        # `https://rubygems.org` or an absolute path, in which case we shouldn't do anything
+        if path&.start_with?(".")
+          "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
+        else
+          match
+        end
+      end
+
+      @custom_lockfile.write(content)
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -23,6 +23,9 @@ module RubyLsp
     sig { returns(T::Hash[Symbol, RequestConfig]) }
     attr_accessor :features_configuration
 
+    sig { returns(String) }
+    attr_accessor :client_name
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
@@ -33,10 +36,6 @@ module RubyLsp
       @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,
@@ -45,6 +44,7 @@ module RubyLsp
         },
         T::Hash[Symbol, RequestConfig],
       )
+      @client_name = T.let("Unknown", String)
     end
 
     sig { params(uri: URI::Generic).returns(Document) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.13.4
+  version: 0.14.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-12 00:00:00.000000000 Z
+date: 2024-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -33,7 +33,7 @@ dependencies:
         version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
         version: 0.19.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.20'
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +97,6 @@ files:
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/executor.rb
 - lib/ruby_lsp/internal.rb
-- lib/ruby_lsp/listener.rb
 - lib/ruby_lsp/listeners/code_lens.rb
 - lib/ruby_lsp/listeners/completion.rb
 - lib/ruby_lsp/listeners/definition.rb
@@ -139,11 +138,17 @@ files:
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
-- lib/ruby_lsp/requests/support/semantic_token_encoder.rb
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
+- lib/ruby_lsp/response_builders.rb
+- lib/ruby_lsp/response_builders/collection_response_builder.rb
+- lib/ruby_lsp/response_builders/document_symbol.rb
+- lib/ruby_lsp/response_builders/hover.rb
+- lib/ruby_lsp/response_builders/response_builder.rb
+- lib/ruby_lsp/response_builders/semantic_highlighting.rb
+- lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/ruby_document.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
@@ -169,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.4
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby

data/lib/ruby_lsp/listener.rb

@@ -1,33 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # Listener is an abstract class to be used by requests for listening to events emitted when visiting an AST using the
-  # Prism::Dispatcher.
-  class Listener
-    extend T::Sig
-    extend T::Helpers
-    extend T::Generic
-    include Requests::Support::Common
-
-    ResponseType = type_member
-
-    abstract!
-
-    sig { params(dispatcher: Prism::Dispatcher).void }
-    def initialize(dispatcher)
-      super()
-      @dispatcher = dispatcher
-    end
-
-    sig { returns(ResponseType) }
-    def response
-      _response
-    end
-
-    # Override this method with an attr_reader that returns the response of your listener. The listener should
-    # accumulate results in a @response variable and then provide the reader so that it is accessible
-    sig { abstract.returns(ResponseType) }
-    def _response; end
-  end
-end

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

@@ -1,73 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    module Support
-      class SemanticTokenEncoder
-        extend T::Sig
-
-        sig { void }
-        def initialize
-          @current_row = T.let(0, Integer)
-          @current_column = T.let(0, Integer)
-        end
-
-        sig do
-          params(
-            tokens: T::Array[Listeners::SemanticHighlighting::SemanticToken],
-          ).returns(Interface::SemanticTokens)
-        end
-        def encode(tokens)
-          delta = tokens
-            .sort_by do |token|
-              [token.location.start_line, token.location.start_column]
-            end
-            .flat_map do |token|
-              compute_delta(token)
-            end
-
-          Interface::SemanticTokens.new(data: delta)
-        end
-
-        # The delta array is computed according to the LSP specification:
-        # > The protocol for the token format relative uses relative
-        # > positions, because most tokens remain stable relative to
-        # > each other when edits are made in a file. This simplifies
-        # > the computation of a delta if a server supports it. So each
-        # > token is represented using 5 integers.
-
-        # For more information on how each number is calculated, read:
-        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-        sig { params(token: Listeners::SemanticHighlighting::SemanticToken).returns(T::Array[Integer]) }
-        def compute_delta(token)
-          row = token.location.start_line - 1
-          column = token.location.start_column
-
-          begin
-            delta_line = row - @current_row
-
-            delta_column = column
-            delta_column -= @current_column if delta_line == 0
-
-            [delta_line, delta_column, token.length, token.type, encode_modifiers(token.modifier)]
-          ensure
-            @current_row = row
-            @current_column = column
-          end
-        end
-
-        # Encode an array of modifiers to positions onto a bit flag
-        # For example, [:default_library] will be encoded as
-        # 0b1000000000, as :default_library is the 10th bit according
-        # to the token modifiers index map.
-        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
-        def encode_modifiers(modifiers)
-          modifiers.inject(0) do |encoded_modifiers, modifier|
-            encoded_modifiers | (1 << modifier)
-          end
-        end
-      end
-    end
-  end
-end