ruby-lsp 0.8.0 → 0.8.1

data/lib/ruby_indexer/test/configuration_test.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class ConfigurationTest < Minitest::Test
+    def setup
+      @config = Configuration.new
+    end
+
+    def test_load_configuration_executes_configure_block
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.include?("test/fixtures") })
+      assert(files_to_index.none? { |path| path.include?("minitest-reporters") })
+    end
+
+    def test_paths_are_unique
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert_equal(files_to_index.uniq.length, files_to_index.length)
+    end
+
+    def test_configuration_raises_for_unknown_keys
+      Psych::Nodes::Document.any_instance.expects(:to_ruby).returns({ "unknown_config" => 123 })
+
+      assert_raises(ArgumentError) do
+        @config.load_config
+      end
+    end
+  end
+end

data/lib/ruby_indexer/test/constant_test.rb

@@ -0,0 +1,108 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ConstantTest < TestCase
+    def test_constant_writes
+      index(<<~RUBY)
+        FOO = 1
+
+        class ::Bar
+          FOO = 2
+        end
+      RUBY
+
+      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-6")
+      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-8")
+    end
+
+    def test_constant_or_writes
+      index(<<~RUBY)
+        FOO ||= 1
+
+        class ::Bar
+          FOO ||= 2
+        end
+      RUBY
+
+      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-8")
+      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-10")
+    end
+
+    def test_constant_path_writes
+      index(<<~RUBY)
+        class A
+          FOO = 1
+          ::BAR = 1
+
+          module B
+            FOO = 1
+          end
+        end
+
+        A::BAZ = 1
+      RUBY
+
+      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-8")
+      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-10")
+      assert_entry("A::B::FOO", Index::Entry::Constant, "/fake/path/foo.rb:5-4:5-10")
+      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:9-0:9-9")
+    end
+
+    def test_constant_path_or_writes
+      index(<<~RUBY)
+        class A
+          FOO ||= 1
+          ::BAR ||= 1
+        end
+
+        A::BAZ ||= 1
+      RUBY
+
+      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-10")
+      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-12")
+      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:5-0:5-11")
+    end
+
+    def test_comments_for_constants
+      index(<<~RUBY)
+        # FOO comment
+        FOO = 1
+
+        class A
+          # A::FOO comment
+          FOO = 1
+
+          # ::BAR comment
+          ::BAR = 1
+        end
+
+        # A::BAZ comment
+        A::BAZ = 1
+      RUBY
+
+      foo_comment = @index["FOO"].first.comments.join("\n")
+      assert_equal("# FOO comment\n", foo_comment)
+
+      a_foo_comment = @index["A::FOO"].first.comments.join("\n")
+      assert_equal("# A::FOO comment\n", a_foo_comment)
+
+      bar_comment = @index["BAR"].first.comments.join("\n")
+      assert_equal("# ::BAR comment\n", bar_comment)
+
+      a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
+      assert_equal("# A::BAZ comment\n", a_baz_comment)
+    end
+
+    def test_variable_path_constants_are_ignored
+      index(<<~RUBY)
+        var::FOO = 1
+        self.class::FOO = 1
+      RUBY
+
+      assert_no_entry
+    end
+  end
+end

data/lib/ruby_indexer/test/index_test.rb

@@ -0,0 +1,94 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class IndexTest < TestCase
+    def test_deleting_one_entry_for_a_class
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+      @index.index_single("/fake/path/other_foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      entries = @index["Foo"]
+      assert_equal(2, entries.length)
+
+      @index.delete("/fake/path/other_foo.rb")
+      entries = @index["Foo"]
+      assert_equal(1, entries.length)
+    end
+
+    def test_deleting_all_entries_for_a_class
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      entries = @index["Foo"]
+      assert_equal(1, entries.length)
+
+      @index.delete("/fake/path/foo.rb")
+      entries = @index["Foo"]
+      assert_nil(entries)
+    end
+
+    def test_index_resolve
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      entries = @index.resolve("Something", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Baz::Something", entries.first.name)
+
+      entries = @index.resolve("Bar", ["Foo"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("Bar", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("Foo::Bar", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      assert_nil(@index.resolve("DoesNotExist", ["Foo"]))
+    end
+
+    def test_accessing_with_colon_colon_prefix
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      entries = @index["::Foo::Baz::Something"]
+      refute_empty(entries)
+      assert_equal("Foo::Baz::Something", entries.first.name)
+    end
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class TestCase < Minitest::Test
+    def setup
+      @index = Index.new
+    end
+
+    private
+
+    def index(source)
+      @index.index_single("/fake/path/foo.rb", source)
+    end
+
+    def assert_entry(expected_name, type, expected_location)
+      entries = @index[expected_name]
+      refute_empty(entries, "Expected #{expected_name} to be indexed")
+
+      entry = entries.first
+      assert_instance_of(type, entry, "Expected #{expected_name} to be a #{type}")
+
+      location = entry.location
+      location_string =
+        "#{entry.file_path}:#{location.start_line - 1}-#{location.start_column}" \
+          ":#{location.end_line - 1}-#{location.end_column}"
+
+      assert_equal(expected_location, location_string)
+    end
+
+    def refute_entry(expected_name)
+      entries = @index[expected_name]
+      assert_nil(entries, "Expected #{expected_name} to not be indexed")
+    end
+
+    def assert_no_entry
+      assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
+    end
+  end
+end

data/lib/ruby_lsp/executor.rb

@@ -15,6 +15,7 @@ module RubyLsp
       @store = store
       @test_library = T.let(DependencyDetector.detected_test_library, String)
       @message_queue = message_queue
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
     end
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
@@ -57,6 +58,14 @@ module RubyLsp
           warn(errored_extensions.map(&:backtraces).join("\n\n"))
         end
 
+        if @store.experimental_features
+          # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
+          # stuck indexing files
+          RubyIndexer.configuration.load_config
+          @index.index_all
+          end_progress("indexing-progress")
+        end
+
         check_formatter_is_available
 
         warn("Ruby LSP is ready")
@@ -169,25 +178,59 @@ module RubyLsp
         completion(uri, request.dig(:params, :position))
       when "textDocument/definition"
         definition(uri, request.dig(:params, :position))
+      when "workspace/didChangeWatchedFiles"
+        did_change_watched_files(request.dig(:params, :changes))
       when "rubyLsp/textDocument/showSyntaxTree"
         show_syntax_tree(uri, request.dig(:params, :range))
       end
     end
 
+    sig { params(changes: T::Array[{ uri: String, type: Integer }]).returns(Object) }
+    def did_change_watched_files(changes)
+      changes.each do |change|
+        # File change events include folders, but we're only interested in files
+        uri = URI(change[:uri])
+        file_path = uri.to_standardized_path
+        next if file_path.nil? || File.directory?(file_path)
+
+        case change[:type]
+        when Constant::FileChangeType::CREATED
+          @index.index_single(file_path)
+        when Constant::FileChangeType::CHANGED
+          @index.delete(file_path)
+          @index.index_single(file_path)
+        when Constant::FileChangeType::DELETED
+          @index.delete(file_path)
+        end
+      end
+
+      VOID
+    end
+
     sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
       { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
     end
 
-    sig { params(uri: URI::Generic, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
+    sig do
+      params(
+        uri: URI::Generic,
+        position: Document::PositionShape,
+      ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
+    end
     def definition(uri, position)
       document = @store.get(uri)
       return if document.syntax_error?
 
-      target, _parent = document.locate_node(position, node_types: [SyntaxTree::Command])
+      target, parent, nesting = document.locate_node(
+        position,
+        node_types: [SyntaxTree::Command, SyntaxTree::Const, SyntaxTree::ConstPathRef],
+      )
+
+      target = parent if target.is_a?(SyntaxTree::Const) && parent.is_a?(SyntaxTree::ConstPathRef)
 
       emitter = EventEmitter.new
-      base_listener = Requests::Definition.new(uri, emitter, @message_queue)
+      base_listener = Requests::Definition.new(uri, nesting, @index, emitter, @message_queue)
       emitter.emit_for_target(target)
       base_listener.response
     end
@@ -436,6 +479,37 @@ module RubyLsp
       listener.response
     end
 
+    sig { params(id: String, title: String).void }
+    def begin_progress(id, title)
+      return unless @store.supports_progress
+
+      @message_queue << Request.new(
+        message: "window/workDoneProgress/create",
+        params: Interface::WorkDoneProgressCreateParams.new(token: id),
+      )
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressBegin.new(kind: "begin", title: title),
+        ),
+      )
+    end
+
+    sig { params(id: String).void }
+    def end_progress(id)
+      return unless @store.supports_progress
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressEnd.new(kind: "end"),
+        ),
+      )
+    end
+
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
     def initialize_request(options)
       @store.clear
@@ -449,6 +523,7 @@ module RubyLsp
         encodings.first
       end
 
+      @store.supports_progress = options.dig(:capabilities, :window, :workDoneProgress) || true
       formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
         DependencyDetector.detected_formatter
@@ -457,9 +532,7 @@ module RubyLsp
       end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
-
-      # Uncomment the line below and use the variable to gate features behind the experimental flag
-      # experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
+      @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
       enabled_features = case configured_features
       when Array
@@ -541,6 +614,37 @@ module RubyLsp
         )
       end
 
+      if @store.experimental_features
+        # Dynamically registered capabilities
+        file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
+
+        # Not every client supports dynamic registration or file watching
+        if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+          @message_queue << Request.new(
+            message: "client/registerCapability",
+            params: Interface::RegistrationParams.new(
+              registrations: [
+                # Register watching Ruby files
+                Interface::Registration.new(
+                  id: "workspace/didChangeWatchedFiles",
+                  method: "workspace/didChangeWatchedFiles",
+                  register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                    watchers: [
+                      Interface::FileSystemWatcher.new(
+                        glob_pattern: "**/*.rb",
+                        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+          )
+        end
+
+        begin_progress("indexing-progress", "Ruby LSP: indexing files")
+      end
+
       Interface::InitializeResult.new(
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(

data/lib/ruby_lsp/internal.rb

@@ -3,6 +3,7 @@
 
 require "sorbet-runtime"
 require "syntax_tree"
+require "yarp"
 require "language_server-protocol"
 require "benchmark"
 require "bundler"
@@ -10,6 +11,7 @@ require "uri"
 require "cgi"
 
 require "ruby-lsp"
+require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/server"

data/lib/ruby_lsp/requests/definition.rb

@@ -20,18 +20,41 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Location) } }
+      ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
 
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      HAS_TYPECHECKER = T.let(DependencyDetector.typechecker?, T::Boolean)
+
+      sig do
+        params(
+          uri: URI::Generic,
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(uri, nesting, index, emitter, message_queue)
         super(emitter, message_queue)
 
         @uri = uri
+        @nesting = nesting
+        @index = index
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_command)
+        emitter.register(self, :on_command, :on_const, :on_const_path_ref)
+      end
+
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        name = full_constant_name(node)
+        find_in_index(name)
+      end
+
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        find_in_index(node.value)
       end
 
       sig { params(node: SyntaxTree::Command).void }
@@ -79,6 +102,30 @@ module RubyLsp
 
       private
 
+      sig { params(value: String).void }
+      def find_in_index(value)
+        entries = @index.resolve(value, @nesting)
+        return unless entries
+
+        workspace_path = T.must(WORKSPACE_URI.to_standardized_path)
+
+        @response = entries.filter_map do |entry|
+          location = entry.location
+          # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
+          # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
+          # in the project, even if the files are typed false
+          next if HAS_TYPECHECKER && entry.file_path.start_with?(workspace_path)
+
+          Interface::Location.new(
+            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
+      end
+
       sig { params(file: String).returns(T.nilable(String)) }
       def find_file_in_load_path(file)
         return unless file.include?("/")

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -67,12 +67,10 @@ module RubyLsp
 
         line = T.must(current_line)
 
-        # If the current character is a pipe and both previous ones are pipes too, then we autocompleted a pipe and the
-        # user inserted a third one. In this case, we need to avoid adding a fourth and remove the previous one
-        if line[@position[:character] - 2] == "|" &&
-            line[@position[:character] - 1] == "|" &&
-            line[@position[:character]] == "|"
-
+        # If the user inserts the closing pipe manually to the end of the block argument, we need to avoid adding
+        # an additional one and remove the previous one.  This also helps to remove the user who accidentally
+        # inserts another pipe after the autocompleted one.
+        if line[..@position[:character]] =~ /(do|{)\s+\|[^|]*\|\|$/
           @edits << Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(

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

@@ -36,6 +36,11 @@ module RubyLsp
         end
       end
 
+      sig { returns(T::Boolean) }
+      def typechecker?
+        direct_dependency?(/^sorbet/) || direct_dependency?(/^sorbet-static-and-runtime/)
+      end
+
       sig { params(gem_pattern: Regexp).returns(T::Boolean) }
       def direct_dependency?(gem_pattern)
         Bundler.with_original_env { Bundler.default_gemfile } &&

data/lib/ruby_lsp/setup_bundler.rb

@@ -17,9 +17,10 @@ module RubyLsp
 
     class BundleNotLocked < StandardError; end
 
-    sig { params(project_path: String).void }
-    def initialize(project_path)
+    sig { params(project_path: String, branch: T.nilable(String)).void }
+    def initialize(project_path, branch: nil)
       @project_path = project_path
+      @branch = branch
 
       # Custom bundle paths
       @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
@@ -119,7 +120,9 @@ module RubyLsp
       end
 
       unless @dependencies["ruby-lsp"]
-        parts << 'gem "ruby-lsp", require: false, group: :development'
+        ruby_lsp_entry = +'gem "ruby-lsp", require: false, group: :development'
+        ruby_lsp_entry << ", github: \"Shopify/ruby-lsp\", branch: \"#{@branch}\"" if @branch
+        parts << ruby_lsp_entry
       end
 
       unless @dependencies["debug"]
@@ -156,11 +159,12 @@ module RubyLsp
       # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
       # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
       path = Bundler.settings["path"]
+      expanded_path = File.expand_path(path, Dir.pwd) if path
 
       # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
       env = {}
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
-      env["BUNDLE_PATH"] = File.expand_path(path, Dir.pwd) if path
+      env["BUNDLE_PATH"] = expanded_path if expanded_path
 
       # If both `ruby-lsp` and `debug` are already in the Gemfile, then we shouldn't try to upgrade them or else we'll
       # produce undesired source control changes. If the custom bundle was just created and either `ruby-lsp` or `debug`
@@ -187,7 +191,7 @@ module RubyLsp
       # Add bundle update
       warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
       system(env, command)
-      [bundle_gemfile.to_s, path]
+      [bundle_gemfile.to_s, expanded_path]
     end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -13,34 +13,40 @@ module RubyLsp
     sig { returns(String) }
     attr_accessor :formatter
 
+    sig { returns(T::Boolean) }
+    attr_accessor :supports_progress
+
+    sig { returns(T::Boolean) }
+    attr_accessor :experimental_features
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
       @encoding = T.let(Constant::PositionEncodingKind::UTF8, String)
       @formatter = T.let("auto", String)
+      @supports_progress = T.let(true, T::Boolean)
+      @experimental_features = T.let(false, T::Boolean)
     end
 
     sig { params(uri: URI::Generic).returns(Document) }
     def get(uri)
-      path = uri.to_standardized_path
-      return T.must(@state[T.must(uri.opaque)]) unless path
-
-      document = @state[path]
+      document = @state[uri.to_s]
       return document unless document.nil?
 
-      set(uri: uri, source: File.binread(CGI.unescape(path)), version: 0)
-      T.must(@state[path])
+      path = T.must(uri.to_standardized_path)
+      set(uri: uri, source: File.binread(path), version: 0)
+      T.must(@state[uri.to_s])
     end
 
     sig { params(uri: URI::Generic, source: String, version: Integer).void }
     def set(uri:, source:, version:)
       document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
-      @state[uri.storage_key] = document
+      @state[uri.to_s] = document
     end
 
     sig { params(uri: URI::Generic, edits: T::Array[Document::EditShape], version: Integer).void }
     def push_edits(uri:, edits:, version:)
-      T.must(@state[uri.storage_key]).push_edits(edits, version: version)
+      T.must(@state[uri.to_s]).push_edits(edits, version: version)
     end
 
     sig { void }
@@ -55,7 +61,7 @@ module RubyLsp
 
     sig { params(uri: URI::Generic).void }
     def delete(uri)
-      @state.delete(uri.storage_key)
+      @state.delete(uri.to_s)
     end
 
     sig do