ruby-lsp 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f2f2aa1083dcc700e709ebd0bc3d3aed8f08d80943595ba3c9df332d806709
-  data.tar.gz: a065d2f6be6539c81ad117bfba7c7b4f90ead0bbce37dd936733218e3135bc67
+  metadata.gz: 4d7205054d59bb5a292bc8e2d87a984663ce1f0dac527d6d69d3940bc6e86735
+  data.tar.gz: 9b760d79ca5406fe3e78e4bd1276cb507464d72d2fc2e68cf5abf1f9920df1a6
 SHA512:
-  metadata.gz: de010f852e08fd72ac60a12cbb9a8666a92945c49b8a14214f0e347c9a6fbacb65770322627db22a30b573ee61f34ec18be56d625768a6c954cf447dbda63368
-  data.tar.gz: 3f47e62896899091c4a9b166937720cc535f46004827a098bfb7eaf9c31fb39bb35261077b91a01a41baa18a50482d8ffe1b8ebddabaed1ea15bc0d023e76dae
+  metadata.gz: bf465a2d9af7e109b21ecd861cb88b556ee872e4d46e292e791f8f85ce131af7791254187bcc68216b9df0f1276296b5cf80e78be7193c11fdf16831b8da4f0f
+  data.tar.gz: 57fa298a96b7cd3eeb2be68d21261ae634f8e70d818a5c68b2e7cdcfa464d7d27b16e90aecbfb8192a4a3ff9fecc4fa8b94baa3b3b51d9c7c887f4fba2b07bd5

data/README.md

@@ -39,10 +39,14 @@ end
 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).
 
+For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
+documentation](SEMANTIC_HIGHLIGHTING.md).
+
 ## Learn More
 
 * [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
 * [Remote Ruby: Ruby Language Server with Vinicius Stock](https://remoteruby.com/221)
+* [RubyKaigi 2023: Code indexing - How language servers understand our code](https://www.youtube.com/watch?v=ks3tQojSJLU) ([Vinicius Stock](https://github.com/vinistock))
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/exe/ruby-lsp

@@ -20,7 +20,39 @@ end
 
 require_relative "../lib/ruby_lsp/internal"
 
-if ARGV.include?("--debug")
+require "optparse"
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: ruby-lsp [options]"
+
+  opts.on("--version", "Print ruby-lsp version") do
+    puts RubyLsp::VERSION
+    exit(0)
+  end
+
+  opts.on("--debug", "Launch the Ruby LSP with a debugger attached") do
+    options[:debug] = true
+  end
+
+  opts.on("-h", "--help", "Print this help") do
+    puts opts.help
+    puts
+    puts "See https://shopify.github.io/ruby-lsp/ for more information"
+    exit(0)
+  end
+end
+
+begin
+  parser.parse!
+rescue OptionParser::InvalidOption => e
+  warn(e)
+  warn("")
+  warn(parser.help)
+  exit(1)
+end
+
+if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     puts "Debugging is not supported on Windows"
     exit 1

data/lib/ruby_lsp/check_docs.rb

@@ -42,7 +42,7 @@ module RubyLsp
       # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
-        klass = T.cast(k, Class)
+        klass = T.cast(k, T::Class[T.anything])
         klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
       end
 

data/lib/ruby_lsp/event_emitter.rb

@@ -20,6 +20,7 @@ module RubyLsp
   # ```
   class EventEmitter < SyntaxTree::Visitor
     extend T::Sig
+    include SyntaxTree::WithScope
 
     sig { void }
     def initialize
@@ -73,6 +74,12 @@ module RubyLsp
       @listeners[:after_command]&.each { |l| T.unsafe(l).after_command(node) }
     end
 
+    sig { override.params(node: SyntaxTree::CommandCall).void }
+    def visit_command_call(node)
+      @listeners[:on_command_call]&.each { |l| T.unsafe(l).on_command_call(node) }
+      super
+    end
+
     sig { override.params(node: SyntaxTree::CallNode).void }
     def visit_call(node)
       @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
@@ -116,5 +123,59 @@ module RubyLsp
       @listeners[:on_comment]&.each { |l| T.unsafe(l).on_comment(node) }
       super
     end
+
+    sig { override.params(node: SyntaxTree::Rescue).void }
+    def visit_rescue(node)
+      @listeners[:on_rescue]&.each { |l| T.unsafe(l).on_rescue(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::Kw).void }
+    def visit_kw(node)
+      @listeners[:on_kw]&.each { |l| T.unsafe(l).on_kw(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::Params).void }
+    def visit_params(node)
+      @listeners[:on_params]&.each { |l| T.unsafe(l).on_params(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::Field).void }
+    def visit_field(node)
+      @listeners[:on_field]&.each { |l| T.unsafe(l).on_field(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::VarRef).void }
+    def visit_var_ref(node)
+      @listeners[:on_var_ref]&.each { |l| T.unsafe(l).on_var_ref(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::BlockVar).void }
+    def visit_block_var(node)
+      @listeners[:on_block_var]&.each { |l| T.unsafe(l).on_block_var(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::LambdaVar).void }
+    def visit_lambda_var(node)
+      @listeners[:on_lambda_var]&.each { |l| T.unsafe(l).on_lambda_var(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::Binary).void }
+    def visit_binary(node)
+      super
+      @listeners[:after_binary]&.each { |l| T.unsafe(l).after_binary(node) }
+    end
+
+    sig { override.params(node: SyntaxTree::Const).void }
+    def visit_const(node)
+      @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(node) }
+      super
+    end
   end
 end

data/lib/ruby_lsp/executor.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/dependency_detector"
+
 module RubyLsp
   # This class dispatches a request execution to the right request class. No IO should happen anywhere here!
   class Executor
@@ -11,6 +13,7 @@ module RubyLsp
       # Requests that mutate the store must be run sequentially! Parallel requests only receive a temporary copy of the
       # store
       @store = store
+      @test_library = T.let(DependencyDetector.detected_test_library, String)
       @message_queue = message_queue
     end
 
@@ -81,7 +84,8 @@ module RubyLsp
         folding_range(uri)
       when "textDocument/selectionRange"
         selection_range(uri, request.dig(:params, :positions))
-      when "textDocument/documentSymbol", "textDocument/documentLink", "textDocument/codeLens"
+      when "textDocument/documentSymbol", "textDocument/documentLink", "textDocument/codeLens",
+           "textDocument/semanticTokens/full"
         document = @store.get(uri)
 
         # If the response has already been cached by another request, return it
@@ -92,10 +96,11 @@ module RubyLsp
         emitter = EventEmitter.new
         document_symbol = Requests::DocumentSymbol.new(emitter, @message_queue)
         document_link = Requests::DocumentLink.new(uri, emitter, @message_queue)
-        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue)
+        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue, @test_library)
         code_lens_extensions_listeners = Requests::CodeLens.listeners.map do |l|
           T.unsafe(l).new(document.uri, emitter, @message_queue)
         end
+        semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
         emitter.visit(document.tree) if document.parsed?
 
         code_lens_extensions_listeners.each { |ext| code_lens.merge_response!(ext) }
@@ -105,9 +110,11 @@ module RubyLsp
         document.cache_set("textDocument/documentSymbol", document_symbol.response)
         document.cache_set("textDocument/documentLink", document_link.response)
         document.cache_set("textDocument/codeLens", code_lens.response)
+        document.cache_set(
+          "textDocument/semanticTokens/full",
+          Requests::Support::SemanticTokenEncoder.new.encode(semantic_highlighting.response),
+        )
         document.cache_get(request[:method])
-      when "textDocument/semanticTokens/full"
-        semantic_tokens_full(uri)
       when "textDocument/semanticTokens/range"
         semantic_tokens_range(uri, request.dig(:params, :range))
       when "textDocument/formatting"
@@ -245,19 +252,6 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String).returns(Interface::SemanticTokens) }
-    def semantic_tokens_full(uri)
-      @store.cache_fetch(uri, "textDocument/semanticTokens/full") 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)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
@@ -287,13 +281,18 @@ module RubyLsp
       Requests::DocumentHighlight.new(@store.get(uri), position).run
     end
 
-    sig { params(uri: String, range: Document::RangeShape).returns(T::Array[Interface::InlayHint]) }
+    sig { params(uri: String, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
     def inlay_hint(uri, range)
       document = @store.get(uri)
+      return if document.syntax_error?
+
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
-      Requests::InlayHints.new(document, start_line..end_line).run
+      emitter = EventEmitter.new
+      listener = Requests::InlayHints.new(start_line..end_line, emitter, @message_queue)
+      emitter.visit(document.tree)
+      listener.response
     end
 
     sig do
@@ -354,14 +353,15 @@ module RubyLsp
       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,
+      emitter = EventEmitter.new
+      listener = Requests::SemanticHighlighting.new(
+        emitter,
+        @message_queue,
+        range: start_line..end_line,
       )
+      emitter.visit(document.tree) if document.parsed?
+
+      Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
     end
 
     sig do
@@ -421,9 +421,9 @@ module RubyLsp
         encodings.first
       end
 
-      formatter = options.dig(:initializationOptions, :formatter)
+      formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
-        detected_formatter
+        DependencyDetector.detected_formatter
       else
         formatter
       end
@@ -536,23 +536,6 @@ module RubyLsp
       )
     end
 
-    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 { params(gem_pattern: Regexp).returns(T::Boolean) }
-    def direct_dependency?(gem_pattern)
-      Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
-    end
-
     sig { void }
     def check_formatter_is_available
       # Warn of an unavailable `formatter` setting, e.g. `rubocop` on a project which doesn't have RuboCop.
@@ -560,11 +543,13 @@ module RubyLsp
       return unless @store.formatter == "rubocop"
 
       unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
+        @store.formatter = "none"
+
         @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
-            message: "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the bundle.",
+            message: "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the Gemfile or gemspec.",
           ),
         )
       end

data/lib/ruby_lsp/internal.rb

@@ -6,6 +6,7 @@ require "syntax_tree"
 require "language_server-protocol"
 require "benchmark"
 require "bundler"
+require "uri"
 
 require "ruby-lsp"
 require "ruby_lsp/utils"

data/lib/ruby_lsp/requests/base_request.rb

@@ -11,12 +11,8 @@ module RubyLsp
 
       abstract!
 
-      # 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)
+      sig { params(document: Document).void }
+      def initialize(document)
         @document = document
         super()
       end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "shellwords"
+
 module RubyLsp
   module Requests
     # ![Code lens demo](../../code_lens.gif)
@@ -31,35 +33,63 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
+      def initialize(uri, emitter, message_queue, test_library)
         super(emitter, message_queue)
 
+        @test_library = T.let(test_library, String)
         @response = T.let([], ResponseType)
         @path = T.let(T.must(URI(uri).path), String)
-        @visibility = T.let("public", String)
-        @prev_visibility = T.let("public", String)
-
-        emitter.register(self, :on_class, :on_def, :on_command, :after_command, :on_call, :after_call, :on_vcall)
+        # visibility_stack is a stack of [current_visibility, previous_visibility]
+        @visibility_stack = T.let([["public", "public"]], T::Array[T::Array[T.nilable(String)]])
+        @class_stack = T.let([], T::Array[String])
+
+        emitter.register(
+          self,
+          :on_class,
+          :after_class,
+          :on_def,
+          :on_command,
+          :after_command,
+          :on_call,
+          :after_call,
+          :on_vcall,
+        )
       end
 
       sig { params(node: SyntaxTree::ClassDeclaration).void }
       def on_class(node)
+        @visibility_stack.push(["public", "public"])
         class_name = node.constant.constant.value
         if class_name.end_with?("Test")
-          add_code_lens(node, name: class_name, command: BASE_COMMAND + @path)
+          @class_stack.push(class_name)
+          add_test_code_lens(
+            node,
+            name: class_name,
+            command: generate_test_command(class_name: class_name),
+            kind: :group,
+          )
         end
       end
 
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def after_class(node)
+        @visibility_stack.pop
+        @class_stack.pop
+      end
+
       sig { params(node: SyntaxTree::DefNode).void }
       def on_def(node)
-        if @visibility == "public"
+        visibility, _ = @visibility_stack.last
+        if visibility == "public"
           method_name = node.name.value
           if method_name.start_with?("test_")
-            add_code_lens(
+            class_name = T.must(@class_stack.last)
+            add_test_code_lens(
               node,
               name: method_name,
-              command: BASE_COMMAND + @path + " --name " + method_name,
+              command: generate_test_command(method_name: method_name, class_name: class_name),
+              kind: :example,
             )
           end
         end
@@ -67,15 +97,22 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Command).void }
       def on_command(node)
-        if ACCESS_MODIFIERS.include?(node.message.value) && node.arguments.parts.any?
-          @prev_visibility = @visibility
-          @visibility = node.message.value
+        node_message = node.message.value
+        if ACCESS_MODIFIERS.include?(node_message) && node.arguments.parts.any?
+          visibility, _ = @visibility_stack.pop
+          @visibility_stack.push([node_message, visibility])
+        elsif @path.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
+          remote = resolve_gem_remote(node)
+          return unless remote
+
+          add_open_gem_remote_code_lens(node, remote)
         end
       end
 
       sig { params(node: SyntaxTree::Command).void }
       def after_command(node)
-        @visibility = @prev_visibility
+        _, prev_visibility = @visibility_stack.pop
+        @visibility_stack.push([prev_visibility, prev_visibility])
       end
 
       sig { params(node: SyntaxTree::CallNode).void }
@@ -85,15 +122,16 @@ module RubyLsp
         if ident
           ident_value = T.cast(ident, SyntaxTree::Ident).value
           if ACCESS_MODIFIERS.include?(ident_value)
-            @prev_visibility = @visibility
-            @visibility = ident_value
+            visibility, _ = @visibility_stack.pop
+            @visibility_stack.push([ident_value, visibility])
           end
         end
       end
 
       sig { params(node: SyntaxTree::CallNode).void }
       def after_call(node)
-        @visibility = @prev_visibility
+        _, prev_visibility = @visibility_stack.pop
+        @visibility_stack.push([prev_visibility, prev_visibility])
       end
 
       sig { params(node: SyntaxTree::VCall).void }
@@ -101,8 +139,8 @@ module RubyLsp
         vcall_value = node.value.value
 
         if ACCESS_MODIFIERS.include?(vcall_value)
-          @prev_visibility = vcall_value
-          @visibility = vcall_value
+          @visibility_stack.pop
+          @visibility_stack.push([vcall_value, vcall_value])
         end
       end
 
@@ -114,36 +152,86 @@ module RubyLsp
 
       private
 
-      sig { params(node: SyntaxTree::Node, name: String, command: String).void }
-      def add_code_lens(node, name:, command:)
+      sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
+      def add_test_code_lens(node, name:, command:, kind:)
+        arguments = [
+          @path,
+          name,
+          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,
+          },
+        ]
+
         @response << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
-          path: @path,
-          name: name,
-          test_command: command,
-          type: "test",
+          arguments: arguments,
+          data: { type: "test", kind: kind },
         )
 
         @response << create_code_lens(
           node,
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
-          path: @path,
-          name: name,
-          test_command: command,
-          type: "test_in_terminal",
+          arguments: arguments,
+          data: { type: "test_in_terminal", kind: kind },
         )
 
         @response << create_code_lens(
           node,
           title: "Debug",
           command_name: "rubyLsp.debugTest",
-          path: @path,
-          name: name,
-          test_command: command,
-          type: "debug",
+          arguments: arguments,
+          data: { type: "debug", kind: kind },
+        )
+      end
+
+      sig { params(node: SyntaxTree::Command).returns(T.nilable(String)) }
+      def resolve_gem_remote(node)
+        gem_name = node.arguments.parts.flat_map(&:child_nodes).first.value
+        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name }&.to_spec
+        return if spec.nil?
+
+        [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|
+          page.start_with?("https://github.com", "https://gitlab.com")
+        end
+      end
+
+      sig { params(class_name: String, method_name: T.nilable(String)).returns(String) }
+      def generate_test_command(class_name:, method_name: nil)
+        command = BASE_COMMAND + @path
+
+        case @test_library
+        when "minitest"
+          command += if method_name
+            " --name " + "/#{Shellwords.escape(class_name + "#" + method_name)}/"
+          else
+            " --name " + "/#{Shellwords.escape(class_name)}/"
+          end
+        when "test-unit"
+          command += " --testcase " + "/#{Shellwords.escape(class_name)}/"
+
+          if method_name
+            command += " --name " + Shellwords.escape(method_name)
+          end
+        end
+
+        command
+      end
+
+      sig { params(node: SyntaxTree::Command, remote: String).void }
+      def add_open_gem_remote_code_lens(node, remote)
+        @response << create_code_lens(
+          node,
+          title: "Open remote",
+          command_name: "rubyLsp.openLink",
+          arguments: [remote],
+          data: { type: "link" },
         )
       end
     end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -30,7 +30,9 @@ module RubyLsp
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
       def run
+        # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
         return if @document.syntax_error?
+
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -27,7 +27,6 @@ module RubyLsp
           SyntaxTree::For,
           SyntaxTree::HashLiteral,
           SyntaxTree::Heredoc,
-          SyntaxTree::IfNode,
           SyntaxTree::ModuleDeclaration,
           SyntaxTree::SClass,
           SyntaxTree::UnlessNode,
@@ -42,6 +41,7 @@ module RubyLsp
 
       NODES_WITH_STATEMENTS = T.let(
         [
+          SyntaxTree::IfNode,
           SyntaxTree::Elsif,
           SyntaxTree::In,
           SyntaxTree::Rescue,
@@ -52,6 +52,7 @@ module RubyLsp
 
       StatementNode = T.type_alias do
         T.any(
+          SyntaxTree::IfNode,
           SyntaxTree::Elsif,
           SyntaxTree::In,
           SyntaxTree::Rescue,