ruby-lsp 0.8.1 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b43407d4d6309c7243a6c69aca8166f6ab3548bd47e939c016efe26c1d8a4a76
-  data.tar.gz: cc5f638aab3322054cc2a09b60fe22a6e5ee8196d88492b4139907c2495c7d5d
+  metadata.gz: '08f4db46a392926873115c77175be859ecdfc4c5093e003f913eec7288f05fac'
+  data.tar.gz: 2f34acc2fc69ab4dd6ad5fc9961a86c020d550284ed18aefd3221b0525af2628
 SHA512:
-  metadata.gz: dda98d73d8ba39cdfaffa3362177ef96887eccff10332012d43f79bdc78643d3bb79a9e43e05a5c21e4550cf9b86d8d00b5742fb51b124d2ed8c8112bc6f1d1a
-  data.tar.gz: 25a169a3eb717f5f11b5b911c91e11e578d33734f6f616c0c92fd6ebcc89d69ddda6abb13410ef231acc398ba0472e17c778d245b89f1285d64317df98c2299c
+  metadata.gz: 99a9e243c0dd2f763532a5a1c52241ac86c9a7ba2ccb0814932d8e08b17add78143566ac26ad609b59ff8d96e1d2844b53995b85b473cb736c5f87e2a30c5a26
+  data.tar.gz: 2a1669be7a054a5d19b0b7eff113347571928cb601e1b432c6f49bc3f349a530b6d0df45c7ea5dfa46add7b69fd347713ec33f95fdca9baa896855f958814209

data/VERSION

@@ -1 +1 @@
-0.8.1
+0.9.1

data/exe/ruby-lsp

@@ -33,7 +33,7 @@ parser = OptionParser.new do |opts|
 end
 
 begin
-  parser.parse!
+  parser.parse
 rescue OptionParser::InvalidOption => e
   warn(e)
   warn("")

data/lib/core_ext/uri.rb

@@ -6,8 +6,8 @@ module URI
     class << self
       extend T::Sig
 
-      sig { params(path: String, scheme: String).returns(URI::Generic) }
-      def from_path(path:, scheme: "file")
+      sig { params(path: String, fragment: T.nilable(String), scheme: String).returns(URI::Generic) }
+      def from_path(path:, fragment: nil, scheme: "file")
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
           DEFAULT_PARSER.escape("/#{path}")
@@ -15,7 +15,7 @@ module URI
           DEFAULT_PARSER.escape(path)
         end
 
-        build(scheme: scheme, path: escaped_path)
+        build(scheme: scheme, path: escaped_path, fragment: fragment)
       end
     end
 
@@ -26,7 +26,7 @@ module URI
       parsed_path = path
       return unless parsed_path
 
-      unescaped_path = CGI.unescape(parsed_path)
+      unescaped_path = DEFAULT_PARSER.unescape(parsed_path)
 
       # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
       # slash

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -11,20 +11,40 @@ module RubyIndexer
         "included_gems" => Array,
         "excluded_patterns" => Array,
         "included_patterns" => Array,
+        "excluded_magic_comments" => Array,
       }.freeze,
-      T::Hash[String, T::Class[Object]],
+      T::Hash[String, T.untyped],
     )
 
     sig { void }
     def initialize
-      development_only_dependencies = Bundler.definition.dependencies.filter_map do |dependency|
+      excluded_gem_names = Bundler.definition.dependencies.filter_map do |dependency|
         dependency.name if dependency.groups == [:development]
       end
 
-      @excluded_gems = T.let(development_only_dependencies, T::Array[String])
+      @excluded_gems = T.let(excluded_gem_names, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let(["*_test.rb"], T::Array[String])
+      @excluded_patterns = T.let(["**/*_test.rb"], T::Array[String])
+      path = Bundler.settings["path"]
+      @excluded_patterns << "#{File.expand_path(path, Dir.pwd)}/**/*.rb" if path
+
       @included_patterns = T.let(["#{Dir.pwd}/**/*.rb"], T::Array[String])
+      @excluded_magic_comments = T.let(
+        [
+          "frozen_string_literal:",
+          "typed:",
+          "compiled:",
+          "encoding:",
+          "shareable_constant_value:",
+          "warn_indent:",
+          "rubocop:",
+          "nodoc:",
+          "doc:",
+          "coding:",
+          "warn_past_scope:",
+        ],
+        T::Array[String],
+      )
     end
 
     sig { void }
@@ -43,26 +63,80 @@ module RubyIndexer
 
     sig { returns(T::Array[String]) }
     def files_to_index
-      files_to_index = $LOAD_PATH.flat_map { |p| Dir.glob("#{p}/**/*.rb", base: p) }
+      excluded_gems = @excluded_gems - @included_gems
+      locked_gems = Bundler.locked_gems&.specs
 
-      @included_patterns.each do |pattern|
-        files_to_index.concat(Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB))
-      end
+      # NOTE: indexing the patterns (both included and excluded) needs to happen before indexing gems, otherwise we risk
+      # having duplicates if BUNDLE_PATH is set to a folder inside the project structure
 
-      excluded_gem_paths = (@excluded_gems - @included_gems).filter_map do |gem_name|
-        Gem::Specification.find_by_name(gem_name).full_gem_path
-      rescue Gem::MissingSpecError
-        warn("Gem #{gem_name} is excluded in .index.yml, but that gem was not found in the bundle")
+      # Add user specified patterns
+      files_to_index = @included_patterns.flat_map do |pattern|
+        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
       end
 
+      # Remove user specified patterns
       files_to_index.reject! do |path|
-        @excluded_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) } ||
-          excluded_gem_paths.any? { |gem_path| File.fnmatch?("#{gem_path}/**/*.rb", path) }
+        @excluded_patterns.any? do |pattern|
+          File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        end
+      end
+
+      # Add default gems to the list of files to be indexed
+      Dir.glob("#{RbConfig::CONFIG["rubylibdir"]}/*").each do |default_path|
+        # The default_path might be a Ruby file or a folder with the gem's name. For example:
+        #   bundler/
+        #   bundler.rb
+        #   psych/
+        #   psych.rb
+        pathname = Pathname.new(default_path)
+        short_name = pathname.basename.to_s.delete_suffix(".rb")
+
+        # If the gem name is excluded, then we skip it
+        next if excluded_gems.include?(short_name)
+
+        # If the default gem is also a part of the bundle, we skip indexing the default one and index only the one in
+        # the bundle, which won't be in `default_path`, but will be in `Bundler.bundle_path` instead
+        next if locked_gems&.any? do |locked_spec|
+          locked_spec.name == short_name &&
+            !Gem::Specification.find_by_name(short_name).full_gem_path.start_with?(RbConfig::CONFIG["rubylibprefix"])
+        end
+
+        if pathname.directory?
+          # If the default_path is a directory, we index all the Ruby files in it
+          files_to_index.concat(Dir.glob("#{default_path}/**/*.rb", File::FNM_PATHNAME | File::FNM_EXTGLOB))
+        else
+          # If the default_path is a Ruby file, we index it
+          files_to_index << default_path
+        end
       end
+
+      # Add the locked gems to the list of files to be indexed
+      locked_gems&.each do |lazy_spec|
+        next if excluded_gems.include?(lazy_spec.name)
+
+        spec = Gem::Specification.find_by_name(lazy_spec.name)
+
+        # When working on a gem, it will be included in the locked_gems list. Since these are the project's own files,
+        # we have already included and handled exclude patterns for it and should not re-include or it'll lead to
+        # duplicates or accidentally ignoring exclude patterns
+        next if spec.full_gem_path == Dir.pwd
+
+        files_to_index.concat(Dir.glob("#{spec.full_gem_path}/{#{spec.require_paths.join(",")}}/**/*.rb"))
+      rescue Gem::MissingSpecError
+        # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
+        # are still listed in locked_gems. We can't index them because they are not installed for the platform, so we
+        # just ignore if they're missing
+      end
+
       files_to_index.uniq!
       files_to_index
     end
 
+    sig { returns(Regexp) }
+    def magic_comment_regex
+      /^\s*#\s*#{@excluded_magic_comments.join("|")}/
+    end
+
     private
 
     sig { params(config: T::Hash[String, T.untyped]).void }
@@ -86,6 +160,7 @@ module RubyIndexer
       @included_gems.concat(config["included_gems"]) if config["included_gems"]
       @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
       @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
+      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -5,6 +5,9 @@ module RubyIndexer
   class Index
     extend T::Sig
 
+    # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
+    ENTRY_SIMILARITY_THRESHOLD = 0.7
+
     sig { void }
     def initialize
       # Holds all entries in the index using the following format:
@@ -50,6 +53,21 @@ module RubyIndexer
       @entries[fully_qualified_name.delete_prefix("::")]
     end
 
+    # Fuzzy searches index entries based on Jaro-Winkler similarity. If no query is provided, all entries are returned
+    sig { params(query: T.nilable(String)).returns(T::Array[Entry]) }
+    def fuzzy_search(query)
+      return @entries.flat_map { |_name, entries| entries } unless query
+
+      normalized_query = query.gsub("::", "").downcase
+
+      results = @entries.filter_map do |name, entries|
+        similarity = DidYouMean::JaroWinkler.distance(name.gsub("::", "").downcase, normalized_query)
+        [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
+      end
+      results.sort_by!(&:last)
+      results.flat_map(&:first)
+    end
+
     # Try to find the entry based on the nesting from the most specific to the least specific. For example, if we have
     # the nesting as ["Foo", "Bar"] and the name as "Baz", we will try to find it in this order:
     # 1. Foo::Bar::Baz
@@ -77,6 +95,8 @@ module RubyIndexer
       content = source || File.read(path)
       visitor = IndexVisitor.new(self, YARP.parse(content), path)
       visitor.run
+    rescue Errno::EISDIR
+      # If `path` is a directory, just ignore it and continue indexing
     end
 
     class Entry
@@ -102,6 +122,11 @@ module RubyIndexer
         @comments = comments
       end
 
+      sig { returns(String) }
+      def file_name
+        File.basename(@file_path)
+      end
+
       class Namespace < Entry
         sig { returns(String) }
         def short_name

data/lib/ruby_indexer/lib/ruby_indexer/visitor.rb

@@ -35,9 +35,9 @@ module RubyIndexer
         add_index_entry(node, Index::Entry::Class)
       when YARP::ModuleNode
         add_index_entry(node, Index::Entry::Module)
-      when YARP::ConstantWriteNode, YARP::ConstantOperatorOrWriteNode
+      when YARP::ConstantWriteNode, YARP::ConstantOrWriteNode
         add_constant(node)
-      when YARP::ConstantPathWriteNode, YARP::ConstantPathOperatorOrWriteNode
+      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode
         add_constant_with_path(node)
       end
     end
@@ -52,7 +52,7 @@ module RubyIndexer
 
     sig do
       params(
-        node: T.any(YARP::ConstantWriteNode, YARP::ConstantOperatorOrWriteNode),
+        node: T.any(YARP::ConstantWriteNode, YARP::ConstantOrWriteNode),
       ).void
     end
     def add_constant(node)
@@ -62,7 +62,7 @@ module RubyIndexer
 
     sig do
       params(
-        node: T.any(YARP::ConstantPathWriteNode, YARP::ConstantPathOperatorOrWriteNode),
+        node: T.any(YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode),
       ).void
     end
     def add_constant_with_path(node)
@@ -70,10 +70,8 @@ module RubyIndexer
       return unless node.target.parent.nil? || node.target.parent.is_a?(YARP::ConstantReadNode)
 
       name = node.target.location.slice
-      fully_qualified_name = name.start_with?("::") ? name.delete_prefix("::") : fully_qualify_name(name)
-
       comments = collect_comments(node)
-      @index << Index::Entry::Constant.new(fully_qualified_name, @file_path, node.location, comments)
+      @index << Index::Entry::Constant.new(fully_qualify_name(name), @file_path, node.location, comments)
     end
 
     sig { params(node: T.any(YARP::ClassNode, YARP::ModuleNode), klass: T.class_of(Index::Entry)).void }
@@ -84,11 +82,8 @@ module RubyIndexer
         return visit_child_nodes(node)
       end
 
-      fully_qualified_name = name.start_with?("::") ? name : fully_qualify_name(name)
-      name.delete_prefix!("::")
-
       comments = collect_comments(node)
-      @index << klass.new(fully_qualified_name, @file_path, node.location, comments)
+      @index << klass.new(fully_qualify_name(name), @file_path, node.location, comments)
       @stack << name
       visit_child_nodes(node)
       @stack.pop
@@ -105,7 +100,12 @@ module RubyIndexer
         comment = @comments_by_line[line]
         break unless comment
 
-        comments.unshift(comment.location.slice)
+        comment_content = comment.location.slice.chomp
+        next if comment_content.match?(RubyIndexer.configuration.magic_comment_regex)
+
+        comment_content.delete_prefix!("#")
+        comment_content.delete_prefix!(" ")
+        comments.unshift(comment_content)
       end
 
       comments
@@ -113,9 +113,11 @@ module RubyIndexer
 
     sig { params(name: String).returns(String) }
     def fully_qualify_name(name)
-      return name if @stack.empty?
-
-      "#{@stack.join("::")}::#{name}"
+      if @stack.empty? || name.start_with?("::")
+        name
+      else
+        "#{@stack.join("::")}::#{name}"
+      end.delete_prefix("::")
     end
   end
 end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/visitor"
 require "ruby_indexer/lib/ruby_indexer/index"

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -162,10 +162,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
 
       bar_entry = @index["Bar"].first
-      assert_equal("# This Bar comment has 1 line padding\n", bar_entry.comments.join)
+      assert_equal("This Bar comment has 1 line padding", bar_entry.comments.join("\n"))
     end
 
     def test_comments_can_be_attached_to_a_namespaced_class
@@ -179,10 +179,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
 
       bar_entry = @index["Foo::Bar"].first
-      assert_equal("# This is a Bar comment\n", bar_entry.comments.join)
+      assert_equal("This is a Bar comment", bar_entry.comments.join("\n"))
     end
 
     def test_comments_can_be_attached_to_a_reopened_class
@@ -195,10 +195,26 @@ module RubyIndexer
       RUBY
 
       first_foo_entry = @index["Foo"][0]
-      assert_equal("# This is a Foo comment\n", first_foo_entry.comments.join)
+      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
 
       second_foo_entry = @index["Foo"][1]
-      assert_equal("# This is another Foo comment\n", second_foo_entry.comments.join)
+      assert_equal("This is another Foo comment", second_foo_entry.comments.join("\n"))
+    end
+
+    def test_comments_removes_the_leading_pound_and_space
+      index(<<~RUBY)
+        # This is a Foo comment
+        class Foo; end
+
+        #This is a Bar comment
+        class Bar; end
+      RUBY
+
+      first_foo_entry = @index["Foo"][0]
+      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+
+      second_foo_entry = @index["Bar"][0]
+      assert_equal("This is a Bar comment", second_foo_entry.comments.join("\n"))
     end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -15,6 +15,65 @@ module RubyIndexer
 
       assert(files_to_index.none? { |path| path.include?("test/fixtures") })
       assert(files_to_index.none? { |path| path.include?("minitest-reporters") })
+      assert(files_to_index.none? { |path| path == __FILE__ })
+    end
+
+    def test_files_to_index_only_includes_gem_require_paths
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      Bundler.locked_gems.specs.each do |lazy_spec|
+        next if lazy_spec.name == "ruby-lsp"
+
+        spec = Gem::Specification.find_by_name(lazy_spec.name)
+        assert(files_to_index.none? { |path| path.start_with?("#{spec.full_gem_path}/test/") })
+      rescue Gem::MissingSpecError
+        # Transitive dependencies might be missing when running tests on Windows
+      end
+    end
+
+    def test_files_to_index_does_not_include_default_gem_path_when_in_bundle
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
+    end
+
+    def test_files_to_index_includes_default_gems
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/abbrev.rb")
+    end
+
+    def test_files_to_index_includes_project_files
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
+        next if path.end_with?("_test.rb")
+
+        assert_includes(files_to_index, path)
+      end
+    end
+
+    def test_files_to_index_avoids_duplicates_if_bundle_path_is_inside_project
+      Bundler.settings.set_global("path", "vendor/bundle")
+      config = Configuration.new
+      config.load_config
+
+      assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
+    ensure
+      Bundler.settings.set_global("path", nil)
+    end
+
+    def test_files_to_index_does_not_include_gems_own_installed_files
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s) })
     end
 
     def test_paths_are_unique
@@ -31,5 +90,25 @@ module RubyIndexer
         @config.load_config
       end
     end
+
+    def test_magic_comments_regex
+      regex = RubyIndexer.configuration.magic_comment_regex
+
+      [
+        "# frozen_string_literal:",
+        "# typed:",
+        "# compiled:",
+        "# encoding:",
+        "# shareable_constant_value:",
+        "# warn_indent:",
+        "# rubocop:",
+        "# nodoc:",
+        "# doc:",
+        "# coding:",
+        "# warn_past_scope:",
+      ].each do |comment|
+        assert_match(regex, comment)
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/constant_test.rb

@@ -84,16 +84,16 @@ module RubyIndexer
       RUBY
 
       foo_comment = @index["FOO"].first.comments.join("\n")
-      assert_equal("# FOO comment\n", foo_comment)
+      assert_equal("FOO comment", foo_comment)
 
       a_foo_comment = @index["A::FOO"].first.comments.join("\n")
-      assert_equal("# A::FOO comment\n", a_foo_comment)
+      assert_equal("A::FOO comment", a_foo_comment)
 
       bar_comment = @index["BAR"].first.comments.join("\n")
-      assert_equal("# ::BAR comment\n", bar_comment)
+      assert_equal("::BAR comment", bar_comment)
 
       a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
-      assert_equal("# A::BAZ comment\n", a_baz_comment)
+      assert_equal("A::BAZ comment", a_baz_comment)
     end
 
     def test_variable_path_constants_are_ignored

data/lib/ruby_indexer/test/index_test.rb

@@ -90,5 +90,40 @@ module RubyIndexer
       refute_empty(entries)
       assert_equal("Foo::Baz::Something", entries.first.name)
     end
+
+    def test_fuzzy_search
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      result = @index.fuzzy_search("Bar")
+      assert_equal(1, result.length)
+      assert_equal(@index["Bar"].first, result.first)
+
+      result = @index.fuzzy_search("foobarsomeking")
+      assert_equal(5, result.length)
+      assert_equal(["Foo::Baz::Something", "Foo::Bar", "Foo::Baz", "Foo", "Bar"], result.map(&:name))
+
+      result = @index.fuzzy_search("FooBaz")
+      assert_equal(4, result.length)
+      assert_equal(["Foo::Baz", "Foo::Bar", "Foo", "Foo::Baz::Something"], result.map(&:name))
+    end
+
+    def test_index_single_ignores_directories
+      FileUtils.mkdir("lib/this_is_a_dir.rb")
+      @index.index_single("lib/this_is_a_dir.rb")
+    ensure
+      FileUtils.rm_r("lib/this_is_a_dir.rb")
+    end
   end
 end

data/lib/ruby_lsp/executor.rb

@@ -58,14 +58,7 @@ 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
-
+        perform_initial_indexing
         check_formatter_is_available
 
         warn("Ruby LSP is ready")
@@ -180,6 +173,8 @@ module RubyLsp
         definition(uri, request.dig(:params, :position))
       when "workspace/didChangeWatchedFiles"
         did_change_watched_files(request.dig(:params, :changes))
+      when "workspace/symbol"
+        workspace_symbol(request.dig(:params, :query))
       when "rubyLsp/textDocument/showSyntaxTree"
         show_syntax_tree(uri, request.dig(:params, :range))
       end
@@ -207,6 +202,36 @@ module RubyLsp
       VOID
     end
 
+    sig { void }
+    def perform_initial_indexing
+      return unless @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
+
+      begin
+        @index.index_all
+      rescue StandardError => error
+        @message_queue << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Error while indexing: #{error.message}",
+          ),
+        )
+      end
+
+      # Always end the progress notification even if indexing failed or else it never goes away and the user has no way
+      # of dismissing it
+      end_progress("indexing-progress")
+    end
+
+    sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
+    def workspace_symbol(query)
+      Requests::WorkspaceSymbol.new(query, @index).run
+    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 }
@@ -252,16 +277,20 @@ module RubyLsp
       document = @store.get(uri)
       return if document.syntax_error?
 
-      target, parent = document.locate_node(position)
+      target, parent, nesting = document.locate_node(
+        position,
+        node_types: Requests::Hover::ALLOWED_TARGETS,
+      )
 
-      if !Requests::Hover::ALLOWED_TARGETS.include?(target.class) &&
-          Requests::Hover::ALLOWED_TARGETS.include?(parent.class)
+      if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
+          !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+          (parent.is_a?(SyntaxTree::ConstPathRef) && target.is_a?(SyntaxTree::Const))
         target = parent
       end
 
       # Instantiate all listeners
       emitter = EventEmitter.new
-      hover = Requests::Hover.new(emitter, @message_queue)
+      hover = Requests::Hover.new(@index, nesting, emitter, @message_queue)
 
       # Emit events for all listeners
       emitter.emit_for_target(target)
@@ -667,6 +696,7 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
+          workspace_symbol_provider: enabled_features["workspaceSymbol"],
         ),
       )
     end

data/lib/ruby_lsp/requests/definition.rb

@@ -9,12 +9,13 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
     #
-    # Currently, only jumping to required files is supported.
+    # Currently, only jumping to classes, modules and required files is supported.
     #
     # # Example
     #
     # ```ruby
     # require "some_gem/file" # <- Request go to definition on this string will take you to the file
+    # Product.new # <- Request go to definition on this class name will take you to its declaration.
     # ```
     class Definition < Listener
       extend T::Sig
@@ -25,8 +26,6 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      HAS_TYPECHECKER = T.let(DependencyDetector.typechecker?, T::Boolean)
-
       sig do
         params(
           uri: URI::Generic,
@@ -107,17 +106,26 @@ module RubyLsp
         entries = @index.resolve(value, @nesting)
         return unless entries
 
-        workspace_path = T.must(WORKSPACE_URI.to_standardized_path)
+        bundle_path = begin
+          Bundler.bundle_path.to_s
+        rescue Bundler::GemfileNotFound
+          nil
+        end
 
         @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)
+          file_path = entry.file_path
+          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+            next
+          end
 
           Interface::Location.new(
-            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            uri: URI::Generic.from_path(path: 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),

data/lib/ruby_lsp/requests/hover.rb

@@ -3,19 +3,15 @@
 
 module RubyLsp
   module Requests
-    # ![Hover demo](../../rails_document_link_hover.gif)
+    # ![Hover demo](../../hover.gif)
     #
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
-    # renders a clickable link to the code's official documentation.
-    # It currently only supports Rails' documentation: when hovering over Rails DSLs/constants under certain paths,
-    # like `before_save :callback` in `models/post.rb`, it generates a link to `before_save`'s API documentation.
+    # displays the documentation for the symbol currently under the cursor.
     #
     # # Example
     #
     # ```ruby
-    # class Post < ApplicationRecord
-    #   before_save :do_something # when hovering on before_save, the link will be rendered
-    # end
+    # String # -> Hovering over the class reference will show all declaration locations and the documentation
     # ```
     class Hover < Listener
       extend T::Sig
@@ -25,6 +21,7 @@ module RubyLsp
 
       ALLOWED_TARGETS = T.let(
         [
+          SyntaxTree::Const,
           SyntaxTree::Command,
           SyntaxTree::CallNode,
           SyntaxTree::ConstPathRef,
@@ -35,15 +32,24 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(emitter, message_queue)
-        super
+      sig do
+        params(
+          index: RubyIndexer::Index,
+          nesting: T::Array[String],
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(index, nesting, emitter, message_queue)
+        super(emitter, message_queue)
 
+        @nesting = nesting
+        @index = index
         @external_listeners.concat(
           Extension.extensions.filter_map { |ext| ext.create_hover_listener(emitter, message_queue) },
         )
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_command, :on_const_path_ref, :on_call)
+        emitter.register(self, :on_const_path_ref, :on_const)
       end
 
       # Merges responses from other hover listeners
@@ -55,40 +61,57 @@ module RubyLsp
         if @response.nil?
           @response = other.response
         else
-          @response.contents.value << other_response.contents.value << "\n\n"
+          @response.contents.value << "\n\n" << other_response.contents.value
         end
 
         self
       end
 
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        message = node.message
-        @response = generate_rails_document_link_hover(message.value, message)
-      end
-
       sig { params(node: SyntaxTree::ConstPathRef).void }
       def on_const_path_ref(node)
-        @response = generate_rails_document_link_hover(full_constant_name(node), node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        generate_hover(name, node)
       end
 
-      sig { params(node: SyntaxTree::CallNode).void }
-      def on_call(node)
-        message = node.message
-        return if message.is_a?(Symbol)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        return if DependencyDetector::HAS_TYPECHECKER
 
-        @response = generate_rails_document_link_hover(message.value, message)
+        generate_hover(node.value, node)
       end
 
       private
 
-      sig { params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover)) }
-      def generate_rails_document_link_hover(name, node)
-        urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-        return if urls.empty?
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def generate_hover(name, node)
+        entries = @index.resolve(name, @nesting)
+        return unless entries
+
+        title = +"```ruby\n#{name}\n```"
+        definitions = []
+        content = +""
+        entries.each do |entry|
+          loc = entry.location
+
+          # We always handle locations as zero based. However, for file links in Markdown we need them to be one based,
+          # which is why instead of the usual subtraction of 1 to line numbers, we are actually adding 1 to columns. The
+          # format for VS Code file URIs is `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
+          uri = URI::Generic.from_path(
+            path: entry.file_path,
+            fragment: "L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}",
+          )
+
+          definitions << "[#{entry.file_name}](#{uri})"
+          content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
+        end
 
-        contents = Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
-        Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
+        contents = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: "#{title}\n\n**Definitions**: #{definitions.join(" | ")}\n\n#{content}",
+        )
+        @response = Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

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

@@ -49,5 +49,7 @@ module RubyLsp
         false
       end
     end
+
+    HAS_TYPECHECKER = T.let(typechecker?, T::Boolean)
   end
 end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Workspace symbol demo](../../workspace_symbol.gif)
+    #
+    # The [workspace symbol](https://microsoft.github.io/language-server-protocol/specification#workspace_symbol)
+    # request allows fuzzy searching declarations in the entire project. On VS Code, use CTRL/CMD + T to search for
+    # symbols.
+    #
+    # # Example
+    #
+    # ```ruby
+    # # Searching for `Floo` will fuzzy match and return all declarations according to the query, including this `Foo`
+    # class
+    # class Foo
+    # end
+    # ```
+    #
+    class WorkspaceSymbol
+      extend T::Sig
+
+      sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
+      def initialize(query, index)
+        @query = query
+        @index = index
+      end
+
+      sig { returns(T::Array[Interface::WorkspaceSymbol]) }
+      def run
+        bundle_path = begin
+          Bundler.bundle_path.to_s
+        rescue Bundler::GemfileNotFound
+          nil
+        end
+
+        @index.fuzzy_search(@query).filter_map do |entry|
+          # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
+          # we still return entries defined in gems to allow developers to jump directly to the source
+          file_path = entry.file_path
+          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+            next
+          end
+
+          kind = kind_for_entry(entry)
+          loc = entry.location
+
+          # We use the namespace as the container name, but we also use the full name as the regular name. The reason we
+          # do this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the
+          # short name `Bar`, then searching for `Foo::Bar` would not return any results
+          *container, _short_name = entry.name.split("::")
+
+          Interface::WorkspaceSymbol.new(
+            name: entry.name,
+            container_name: T.must(container).join("::"),
+            kind: kind,
+            location: Interface::Location.new(
+              uri: URI::Generic.from_path(path: file_path).to_s,
+              range:  Interface::Range.new(
+                start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
+                end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+              ),
+            ),
+          )
+        end
+      end
+
+      private
+
+      sig { params(entry: RubyIndexer::Index::Entry).returns(T.nilable(Integer)) }
+      def kind_for_entry(entry)
+        case entry
+        when RubyIndexer::Index::Entry::Class
+          Constant::SymbolKind::CLASS
+        when RubyIndexer::Index::Entry::Module
+          Constant::SymbolKind::NAMESPACE
+        when RubyIndexer::Index::Entry::Constant
+          Constant::SymbolKind::CONSTANT
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -21,6 +21,7 @@ module RubyLsp
   # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
   # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
   # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
+  # - [WorkspaceSymbol](rdoc-ref:RubyLsp::Requests::WorkspaceSymbol)
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -41,6 +42,7 @@ module RubyLsp
     autoload :CodeLens, "ruby_lsp/requests/code_lens"
     autoload :Definition, "ruby_lsp/requests/definition"
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
+    autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
 
     # :nodoc:
     module Support

data/lib/ruby_lsp/setup_bundler.rb

@@ -6,6 +6,7 @@ require "bundler"
 require "fileutils"
 require "pathname"
 require "digest"
+require "time"
 
 # This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
 # the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
@@ -17,6 +18,8 @@ module RubyLsp
 
     class BundleNotLocked < StandardError; end
 
+    FOUR_HOURS = T.let(4 * 60 * 60, Integer)
+
     sig { params(project_path: String, branch: T.nilable(String)).void }
     def initialize(project_path, branch: nil)
       @project_path = project_path
@@ -27,6 +30,7 @@ module RubyLsp
       @custom_gemfile = T.let(@custom_dir + "Gemfile", Pathname)
       @custom_lockfile = T.let(@custom_dir + "Gemfile.lock", Pathname)
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
+      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -173,15 +177,16 @@ module RubyLsp
       # custom `.ruby-lsp/Gemfile.lock` already exists and includes both gems
       command = +""
 
-      if (@dependencies["ruby-lsp"] && @dependencies["debug"]) ||
-          custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil?
+      if should_bundle_install?
         # Install gems using the custom bundle
-        command << "bundle install "
+        command << "(bundle check || bundle install) "
       else
         # If ruby-lsp or debug are not in the Gemfile, try to update them to the latest version
         command << "bundle update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
+
+        @last_updated_path.write(Time.now.iso8601)
       end
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
@@ -193,5 +198,12 @@ module RubyLsp
       system(env, command)
       [bundle_gemfile.to_s, expanded_path]
     end
+
+    sig { returns(T::Boolean) }
+    def should_bundle_install?
+      (!@dependencies["ruby-lsp"].nil? && !@dependencies["debug"].nil?) ||
+        custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil? ||
+        (@last_updated_path.exist? && Time.parse(@last_updated_path.read) > (Time.now - FOUR_HOURS))
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -62,16 +62,22 @@ dependencies:
   name: yarp
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.10'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -130,7 +136,6 @@ files:
 - lib/ruby_lsp/requests/support/formatter_runner.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
 - lib/ruby_lsp/requests/support/prefix_tree.rb
-- lib/ruby_lsp/requests/support/rails_document_client.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
@@ -140,6 +145,7 @@ files:
 - 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/server.rb
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb

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

@@ -1,122 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "net/http"
-
-module RubyLsp
-  module Requests
-    module Support
-      class RailsDocumentClient
-        RAILS_DOC_HOST = "https://api.rubyonrails.org"
-        SUPPORTED_RAILS_DOC_NAMESPACES = T.let(
-          Regexp.union(
-            /ActionDispatch/,
-            /ActionController/,
-            /AbstractController/,
-            /ActiveRecord/,
-            /ActiveModel/,
-            /ActiveStorage/,
-            /ActionText/,
-            /ActiveJob/,
-          ).freeze,
-          Regexp,
-        )
-
-        RAILTIES_VERSION = T.let(
-          [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].find do |s|
-            s.name == "railties"
-          end&.version&.to_s,
-          T.nilable(String),
-        )
-
-        class << self
-          extend T::Sig
-          sig do
-            params(name: String).returns(T::Array[String])
-          end
-          def generate_rails_document_urls(name)
-            docs = search_index&.fetch(name, nil)
-
-            return [] unless docs
-
-            docs.map do |doc|
-              owner = doc[:owner]
-
-              link_name =
-                # class/module name
-                if owner == name
-                  name
-                else
-                  "#{owner}##{name}"
-                end
-
-              "[Rails Document: `#{link_name}`](#{doc[:url]})"
-            end
-          end
-
-          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
-          private def search_index
-            @rails_documents ||= T.let(
-              build_search_index,
-              T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]]),
-            )
-          end
-
-          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
-          private def build_search_index
-            return unless RAILTIES_VERSION
-
-            warn("Fetching Rails Documents...")
-
-            response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
-
-            if response.code == "302"
-              # If the version's doc is not found, e.g. Rails main, it'll be redirected
-              # In this case, we just fetch the latest doc
-              response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
-            end
-
-            if response.code == "200"
-              process_search_index(response.body)
-            else
-              warn("Response failed: #{response.inspect}")
-              nil
-            end
-          rescue StandardError => e
-            warn("Exception occurred when fetching Rails document index: #{e.inspect}")
-          end
-
-          sig { params(js: String).returns(T::Hash[String, T::Array[T::Hash[Symbol, String]]]) }
-          private def process_search_index(js)
-            raw_data = js.sub("var search_data = ", "")
-            info = JSON.parse(raw_data).dig("index", "info")
-
-            # An entry looks like this:
-            #
-            # ["belongs_to",                                                              # method or module/class
-            #  "ActiveRecord::Associations::ClassMethods",                                # method owner
-            #  "classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to", # path to the document
-            #  "(name, scope = nil, **options)",                                          # method's parameters
-            #  "<p>Specifies a one-to-one association with another class..."]             # document preview
-            #
-            info.each_with_object({}) do |(method_or_class, method_owner, doc_path, _, doc_preview), table|
-              # If a method doesn't have documentation, there's no need to generate the link to it.
-              next if doc_preview.nil? || doc_preview.empty?
-
-              # If the method or class/module is not from the supported namespace, reject it
-              next unless [method_or_class, method_owner].any? do |elem|
-                            elem.match?(SUPPORTED_RAILS_DOC_NAMESPACES)
-                          end
-
-              owner = method_owner.empty? ? method_or_class : method_owner
-              table[method_or_class] ||= []
-              # It's possible to have multiple modules defining the same method name. For example,
-              # both `ActiveRecord::FinderMethods` and `ActiveRecord::Associations::CollectionProxy` defines `#find`
-              table[method_or_class] << { owner: owner, url: "#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/#{doc_path}" }
-            end
-          end
-        end
-      end
-    end
-  end
-end