ruby-lsp 0.5.1 → 0.6.1

data/lib/ruby_lsp/requests/formatting.rb

@@ -13,7 +13,7 @@ module RubyLsp
     # registering the ruby-lsp as the Ruby formatter.
     #
     # The `rubyLsp.formatter` setting specifies which formatter to use.
-    # If set to `auto`` then it behaves as follows:
+    # If set to `auto` then it behaves as follows:
     # * It will use RuboCop if it is part of the bundle.
     # * If RuboCop is not available, and `syntax_tree` is a direct dependency, it will use that.
     # * Otherwise, no formatting will be applied.
@@ -29,6 +29,29 @@ module RubyLsp
       class Error < StandardError; end
       class InvalidFormatter < StandardError; end
 
+      @formatters = T.let(
+        {
+          "syntax_tree" => Support::SyntaxTreeFormattingRunner.instance,
+        },
+        T::Hash[String, Support::FormatterRunner],
+      )
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[String, Support::FormatterRunner]) }
+        attr_reader :formatters
+
+        sig { params(identifier: String, instance: Support::FormatterRunner).void }
+        def register_formatter(identifier, instance)
+          @formatters[identifier] = instance
+        end
+      end
+
+      if defined?(Support::RuboCopFormattingRunner)
+        register_formatter("rubocop", Support::RuboCopFormattingRunner.instance)
+      end
+
       extend T::Sig
 
       sig { params(document: Document, formatter: String).void }
@@ -41,6 +64,8 @@ module RubyLsp
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
+        return if @formatter == "none"
+
         # Don't try to format files outside the current working directory
         return unless @uri.sub("file://", "").start_with?(Dir.pwd)
 
@@ -67,16 +92,10 @@ module RubyLsp
 
       sig { returns(T.nilable(String)) }
       def formatted_file
-        case @formatter
-        when "rubocop"
-          if defined?(Support::RuboCopFormattingRunner)
-            Support::RuboCopFormattingRunner.instance.run(@uri, @document)
-          end
-        when "syntax_tree"
-          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
-        else
-          raise InvalidFormatter, "Unknown formatter: #{@formatter}"
-        end
+        formatter_runner = Formatting.formatters[@formatter]
+        raise InvalidFormatter, "Formatter is not available: #{@formatter}" unless formatter_runner
+
+        formatter_runner.run(@uri, @document)
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Inlay hint demo](../../inlay_hint.gif)
+    # ![Inlay hint demo](../../inlay_hints.gif)
     #
     # [Inlay hints](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
     # are labels added directly in the code that explicitly show the user something that might
@@ -18,39 +18,41 @@ module RubyLsp
     #   puts "handle some rescue"
     # end
     # ```
-    class InlayHints < BaseRequest
+    class InlayHints < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::InlayHint] } }
+
       RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
 
-      sig { params(document: Document, range: T::Range[Integer]).void }
-      def initialize(document, range)
-        super(document)
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
+      sig { params(range: T::Range[Integer], emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(range, emitter, message_queue)
+        super(emitter, message_queue)
 
-        @hints = T.let([], T::Array[Interface::InlayHint])
+        @response = T.let([], ResponseType)
         @range = range
-      end
 
-      sig { override.returns(T.all(T::Array[Interface::InlayHint], Object)) }
-      def run
-        visit(@document.tree) if @document.parsed?
-        @hints
+        emitter.register(self, :on_rescue)
       end
 
-      sig { override.params(node: SyntaxTree::Rescue).void }
-      def visit_rescue(node)
+      sig { params(node: SyntaxTree::Rescue).void }
+      def on_rescue(node)
         exception = node.exception
         return unless exception.nil? || exception.exceptions.nil?
 
         loc = node.location
         return unless visible?(node, @range)
 
-        @hints << Interface::InlayHint.new(
+        @response << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,
           tooltip: "StandardError is implied in a bare rescue",
         )
-
-        super
       end
     end
   end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -18,9 +18,11 @@ module RubyLsp
     #   var # --> semantic highlighting: local variable
     # end
     # ```
-    class SemanticHighlighting < BaseRequest
+    class SemanticHighlighting < Listener
       extend T::Sig
-      include SyntaxTree::WithScope
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[SemanticToken] } }
 
       TOKEN_TYPES = T.let(
         {
@@ -102,99 +104,91 @@ module RubyLsp
         end
       end
 
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
       sig do
         params(
-          document: Document,
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
           range: T.nilable(T::Range[Integer]),
-          encoder: T.nilable(Support::SemanticTokenEncoder),
         ).void
       end
-      def initialize(document, range: nil, encoder: nil)
-        super(document)
+      def initialize(emitter, message_queue, range: nil)
+        super(emitter, message_queue)
 
-        @encoder = encoder
-        @tokens = T.let([], T::Array[SemanticToken])
-        @tree = T.let(T.must(document.tree), SyntaxTree::Node)
+        @response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
-      end
 
-      sig do
-        override.returns(
-          T.any(
-            Interface::SemanticTokens,
-            T.all(T::Array[SemanticToken], Object),
-          ),
+        emitter.register(
+          self,
+          :after_binary,
+          :on_block_var,
+          :on_call,
+          :on_class,
+          :on_command,
+          :on_command_call,
+          :on_const,
+          :on_def,
+          :on_field,
+          :on_kw,
+          :on_lambda_var,
+          :on_module,
+          :on_params,
+          :on_var_field,
+          :on_var_ref,
+          :on_vcall,
         )
       end
-      def run
-        return @tokens unless @document.parsed?
 
-        visit(@tree)
-        return @tokens unless @encoder
-
-        @encoder.encode(@tokens)
-      end
-
-      sig { override.params(node: SyntaxTree::CallNode).void }
-      def visit_call(node)
-        return super unless visible?(node, @range)
-
-        visit(node.receiver)
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_call(node)
+        return unless visible?(node, @range)
 
         message = node.message
         if !message.is_a?(Symbol) && !special_method?(message.value)
           type = Support::Sorbet.annotation?(node) ? :type : :method
-
           add_token(message.location, type)
         end
-
-        visit(node.arguments)
       end
 
-      sig { override.params(node: SyntaxTree::Command).void }
-      def visit_command(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        return unless visible?(node, @range)
 
-        unless special_method?(node.message.value)
-          add_token(node.message.location, :method)
-        end
-        visit(node.arguments)
-        visit(node.block)
+        add_token(node.message.location, :method) unless special_method?(node.message.value)
       end
 
-      sig { override.params(node: SyntaxTree::CommandCall).void }
-      def visit_command_call(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::CommandCall).void }
+      def on_command_call(node)
+        return unless visible?(node, @range)
 
-        visit(node.receiver)
         message = node.message
         add_token(message.location, :method) unless message.is_a?(Symbol)
-        visit(node.arguments)
-        visit(node.block)
       end
 
-      sig { override.params(node: SyntaxTree::Const).void }
-      def visit_const(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        return unless visible?(node, @range)
+        # When finding a module or class definition, we will have already pushed a token related to this constant. We
+        # need to look at the previous two tokens and if they match this locatione exactly, avoid pushing another token
+        # on top of the previous one
+        return if @response.last(2).any? { |token| token.location == node.location }
 
         add_token(node.location, :namespace)
       end
 
-      sig { override.params(node: SyntaxTree::DefNode).void }
-      def visit_def(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
+        return unless visible?(node, @range)
 
         add_token(node.name.location, :method, [:declaration])
-        visit(node.params)
-        visit(node.bodystmt)
-        visit(node.target) if node.target
-        visit(node.operator) if node.operator
       end
 
-      sig { override.params(node: SyntaxTree::Kw).void }
-      def visit_kw(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::Kw).void }
+      def on_kw(node)
+        return unless visible?(node, @range)
 
         case node.value
         when "self"
@@ -202,9 +196,9 @@ module RubyLsp
         end
       end
 
-      sig { override.params(node: SyntaxTree::Params).void }
-      def visit_params(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::Params).void }
+      def on_params(node)
+        return unless visible?(node, @range)
 
         node.keywords.each do |keyword, *|
           location = keyword.location
@@ -220,22 +214,18 @@ module RubyLsp
           name = rest.name
           add_token(name.location, :parameter) if name
         end
-
-        super
       end
 
-      sig { override.params(node: SyntaxTree::Field).void }
-      def visit_field(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::Field).void }
+      def on_field(node)
+        return unless visible?(node, @range)
 
         add_token(node.name.location, :method)
-
-        super
       end
 
-      sig { override.params(node: SyntaxTree::VarField).void }
-      def visit_var_field(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::VarField).void }
+      def on_var_field(node)
+        return unless visible?(node, @range)
 
         value = node.value
 
@@ -243,18 +233,12 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
-        when Symbol
-          # do nothing
-        else
-          visit(value)
         end
-
-        super
       end
 
-      sig { override.params(node: SyntaxTree::VarRef).void }
-      def visit_var_ref(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::VarRef).void }
+      def on_var_ref(node)
+        return unless visible?(node, @range)
 
         value = node.value
 
@@ -262,35 +246,29 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
-        when Symbol
-          # do nothing
-        else
-          visit(value)
         end
       end
 
       # All block locals are variables. E.g.: [].each do |x; block_local|
-      sig { override.params(node: SyntaxTree::BlockVar).void }
-      def visit_block_var(node)
+      sig { params(node: SyntaxTree::BlockVar).void }
+      def on_block_var(node)
         node.locals.each { |local| add_token(local.location, :variable) }
-        super
       end
 
       # All lambda locals are variables. E.g.: ->(x; lambda_local) {}
-      sig { override.params(node: SyntaxTree::LambdaVar).void }
-      def visit_lambda_var(node)
+      sig { params(node: SyntaxTree::LambdaVar).void }
+      def on_lambda_var(node)
         node.locals.each { |local| add_token(local.location, :variable) }
-        super
       end
 
-      sig { override.params(node: SyntaxTree::VCall).void }
-      def visit_vcall(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::VCall).void }
+      def on_vcall(node)
+        return unless visible?(node, @range)
 
         # A VCall may exist as a local in the current_scope. This happens when used named capture groups in a regexp
         ident = node.value
         value = ident.value
-        local = current_scope.find_local(value)
+        local = @emitter.current_scope.find_local(value)
         return if local.nil? && special_method?(value)
 
         type = if local
@@ -304,11 +282,8 @@ module RubyLsp
         add_token(node.value.location, type)
       end
 
-      sig { override.params(node: SyntaxTree::Binary).void }
-      def visit_binary(node)
-        # It's important to visit the regexp first in the WithScope module
-        super
-
+      sig { params(node: SyntaxTree::Binary).void }
+      def after_binary(node)
         # You can only capture local variables with regexp by using the =~ operator
         return unless node.operator == :=~
 
@@ -324,38 +299,35 @@ module RubyLsp
 
         # For each capture name we find in the regexp, look for a local in the current_scope
         Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
-          local = current_scope.find_local(name)
+          local = @emitter.current_scope.find_local(name)
           next unless local
 
           local.definitions.each { |definition| add_token(definition, :variable) }
         end
       end
 
-      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
-      def visit_class(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
+        return unless visible?(node, @range)
 
         add_token(node.constant.location, :class, [:declaration])
 
         superclass = node.superclass
         add_token(superclass.location, :class) if superclass
-
-        visit(node.bodystmt)
       end
 
-      sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
-      def visit_module(node)
-        return super unless visible?(node, @range)
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      def on_module(node)
+        return unless visible?(node, @range)
 
-        add_token(node.constant.location, :class, [:declaration])
-        visit(node.bodystmt)
+        add_token(node.constant.location, :namespace, [:declaration])
       end
 
       sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
         length = location.end_char - location.start_char
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
-        @tokens.push(
+        @response.push(
           SemanticToken.new(
             location: location,
             length: length,
@@ -393,7 +365,7 @@ module RubyLsp
 
       sig { params(value: SyntaxTree::Ident).returns(Symbol) }
       def type_for_local(value)
-        local = current_scope.find_local(value.value)
+        local = @emitter.current_scope.find_local(value.value)
 
         if local.nil? || local.type == :variable
           :variable

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

@@ -5,6 +5,8 @@ module RubyLsp
   module Requests
     module Support
       module Common
+        # WARNING: Methods in this class may be used by Ruby LSP extensions such as https://github.com/Shopify/ruby-lsp-rails,
+        # or extensions by created by developers outside of Shopify, so be cautious of changing anything.
         extend T::Sig
 
         sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
@@ -55,25 +57,12 @@ module RubyLsp
             node: SyntaxTree::Node,
             title: String,
             command_name: String,
-            path: String,
-            name: String,
-            test_command: String,
-            type: String,
+            arguments: T.nilable(T::Array[T.untyped]),
+            data: T.nilable(T::Hash[T.untyped, T.untyped]),
           ).returns(Interface::CodeLens)
         end
-        def create_code_lens(node, title:, command_name:, path:, name:, test_command:, type:)
+        def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_syntax_tree_node(node)
-          arguments = [
-            path,
-            name,
-            test_command,
-            {
-              start_line: node.location.start_line - 1,
-              start_column: node.location.start_column,
-              end_line: node.location.end_line - 1,
-              end_column: node.location.end_column,
-            },
-          ]
 
           Interface::CodeLens.new(
             range: range,
@@ -82,7 +71,7 @@ module RubyLsp
               command: command_name,
               arguments: arguments,
             ),
-            data: { type: type },
+            data: data,
           )
         end
       end

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

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module DependencyDetector
+    class << self
+      extend T::Sig
+
+      sig { returns(String) }
+      def detected_formatter
+        # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
+        if direct_dependency?(/^rubocop/)
+          "rubocop"
+        elsif direct_dependency?(/^syntax_tree$/)
+          "syntax_tree"
+        else
+          "none"
+        end
+      end
+
+      sig { returns(String) }
+      def detected_test_library
+        if direct_dependency?(/^minitest/)
+          "minitest"
+        elsif direct_dependency?(/^test-unit/)
+          "test-unit"
+        elsif direct_dependency?(/^rspec/)
+          "rspec"
+        else
+          warn("WARNING: No test library detected. Assuming minitest.")
+          "minitest"
+        end
+      end
+
+      sig { params(gem_pattern: Regexp).returns(T::Boolean) }
+      def direct_dependency?(gem_pattern)
+        Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module FormatterRunner
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        sig { abstract.params(uri: String, document: Document).returns(T.nilable(String)) }
+        def run(uri, document); end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module RubyLsp
       class RuboCopFormattingRunner
         extend T::Sig
         include Singleton
+        include Support::FormatterRunner
 
         sig { void }
         def initialize
@@ -20,7 +21,7 @@ module RubyLsp
           @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { params(uri: String, document: Document).returns(String) }
+        sig { override.params(uri: String, document: Document).returns(String) }
         def run(uri, document)
           filename = CGI.unescape(URI.parse(uri).path)
 

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

@@ -78,7 +78,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, Class]) # rubocop:disable Style/ClassVars
+      @@schemes = T.let(@@schemes, T::Hash[String, T::Class[T.anything]]) # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end

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

@@ -11,6 +11,7 @@ module RubyLsp
       class SyntaxTreeFormattingRunner
         extend T::Sig
         include Singleton
+        include Support::FormatterRunner
 
         sig { void }
         def initialize
@@ -25,7 +26,7 @@ module RubyLsp
             )
         end
 
-        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { override.params(uri: String, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
           relative_path = Pathname.new(URI(uri).path).relative_path_from(T.must(WORKSPACE_URI.path))
           return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }

data/lib/ruby_lsp/requests.rb

@@ -49,6 +49,7 @@ module RubyLsp
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
       autoload :Common, "ruby_lsp/requests/support/common"
+      autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -27,6 +27,9 @@ module RubyLsp
       # The messages queue includes requests and notifications to be sent to the client
       @message_queue = T.let(Thread::Queue.new, Thread::Queue)
 
+      # The executor is responsible for executing requests
+      @executor = T.let(Executor.new(@store, @message_queue), Executor)
+
       # Create a thread to watch the messages queue and send them to the client
       @message_dispatcher = T.let(
         Thread.new do
@@ -62,7 +65,7 @@ module RubyLsp
       @reader.read do |request|
         case request[:method]
         when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
-          result = Executor.new(@store, @message_queue).execute(request)
+          result = @executor.execute(request)
           finalize_request(result, request)
         when "$/cancelRequest"
           # Cancel the job if it's still in the queue
@@ -126,7 +129,7 @@ module RubyLsp
             # We need to return nil to the client even if the request was cancelled
             Result.new(response: nil)
           else
-            Executor.new(@store, @message_queue).execute(request)
+            @executor.execute(request)
           end
 
           finalize_request(result, request)

data/lib/ruby_lsp/utils.rb

@@ -6,7 +6,7 @@ module RubyLsp
   VOID = T.let(Object.new.freeze, Object)
 
   # This freeze is not redundant since the interpolated string is mutable
-  WORKSPACE_URI = T.let(URI("file://#{Dir.pwd}".freeze), URI::Generic) # rubocop:disable Style/RedundantFreeze
+  WORKSPACE_URI = T.let(URI("file://#{Dir.pwd}".freeze), URI::Generic)
 
   # A notification to be sent to the client
   class Message