ruby-lsp 0.17.4 → 0.17.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71204369ec5201376f1af11875a2e1bf16df56a31719ea78932a7f5f6e9c7e5c
-  data.tar.gz: d83e299ade275415fe4cac25abe78f7ee7ec622c47cc1699d42b3b772816fdba
+  metadata.gz: 042725d7afce428b5c024933a7101151f2f69c57cbb40b4f938384c13d6c974b
+  data.tar.gz: bec8636d402451e1009e87ddd98e6fdedc062643e614b596a0698ffcfcc9b271
 SHA512:
-  metadata.gz: f3ac517cb1c711dc1a5ddf2c4027f705e393e30028b9ae7063b18a5f51362fd4d7277607d19d8ca7a9a3c9146960bd612a02ed4a8933c8223a42daf3dfe5e63b
-  data.tar.gz: 0c4408865d1894547aeedfc0441fa558a8281f54e7e26c38b619e67fd67bfc3bed49aa27dc06d8b89924c7ee8db4452b5cd2f810c0dfb01157eef127910b2182
+  metadata.gz: 6a6adb40a9ccaaf916f46c041f3eb2cc7a81be73c5d3bf7c05a45472cd9d08e5a9dd04d804b8e15f091645d420037e324368ccbcc619311a1c60c81f241c1b89
+  data.tar.gz: d6b19c8d02cfab8dca9e4d675e8ee549e8b392631a6080757c0413da29a07d1db411d9360b7553a798805d9e6faac7318863e35ba664488c5eb41c869a7e734a

data/README.md

@@ -33,7 +33,7 @@ The Ruby LSP features include
 - Completion for classes, modules, constants and require paths
 - Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
 
-Adding method support for definition, completion, hover and workspace symbol is partially supported, but not yet complete. Follow progress in https://github.com/Shopify/ruby-lsp/issues/899
+As of July 2024, Ruby LSP has received significant enhancements to its code navigation features. For an in-depth look at these improvements, including video demonstrations, check out this [article](https://railsatscale.com/2024-07-18-mastering-ruby-code-navigation-major-enhancements-in-ruby-lsp-2024/). Despite these advancements, we plan to continue enhancing its code navigation support even further. You can follow our progress on this [GitHub issue](https://github.com/Shopify/ruby-lsp/issues/899).
 
 See complete information about features [here](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
@@ -78,7 +78,12 @@ default gems, except for
 - Gems that only appear under the `:development` group
 - All Ruby files under `test/**/*.rb`
 
-By creating a `.index.yml` file, these configurations can be overridden and tuned. Note that indexing dependent behavior, such as definition, hover, completion or workspace symbol will be impacted by the configurations placed here.
+This behaviour can be overridden and tuned. Learn how to configure it [for VS Code](vscode/README.md#Indexing-Configuration) or [for other editors](EDITORS.md#Indexing-Configuration).
+
+Note that indexing-dependent behavior, such as definition, hover, completion or workspace symbol will be impacted by
+the configuration changes.
+
+The older approach of using a `.index.yml` file has been deprecated and will be removed in a future release.
 
 ```yaml
 # Exclude files based on a given pattern. Often used to exclude test files or fixtures
@@ -109,6 +114,10 @@ features. This is the mechanism that powers addons like
 - [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 - [Ruby LSP rubyfmt](https://github.com/jscharf/ruby-lsp-rubyfmt)
 
+Additionally, some tools may include a Ruby LSP addon directly, like
+
+- [Standard Ruby (from v1.39.1)](https://github.com/standardrb/standard/wiki/IDE:-vscode#using-ruby-lsp)
+
 Other community driven addons can be found in [rubygems](https://rubygems.org/search?query=name%3A+ruby-lsp) by
 searching for the `ruby-lsp` prefix.
 

data/VERSION

@@ -1 +1 @@
-0.17.4
+0.17.13

data/exe/ruby-lsp

@@ -36,6 +36,10 @@ parser = OptionParser.new do |opts|
     options[:experimental] = true
   end
 
+  opts.on("--doctor", "Run troubleshooting steps") do
+    options[:doctor] = true
+  end
+
   opts.on("-h", "--help", "Print this help") do
     puts opts.help
     puts
@@ -102,9 +106,30 @@ if options[:time_index]
 
   puts <<~MSG
     Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
-    - #{entries_by_entry_type.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
+    - #{entries_by_entry_type.sort_by { |k, _| k.to_s }.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
   MSG
   return
 end
 
+if options[:doctor]
+  index = RubyIndexer::Index.new
+
+  if File.exist?(".index.yml")
+    begin
+      config = YAML.parse_file(".index.yml").to_ruby
+    rescue => e
+      abort("Error parsing config: #{e.message}")
+    end
+    index.configuration.apply_config(config)
+  end
+
+  puts "Globbing for indexable files"
+
+  index.configuration.indexables.each do |indexable|
+    puts "indexing: #{indexable.full_path}"
+    index.index_single(indexable)
+  end
+  return
+end
+
 RubyLsp::Server.new.start

data/exe/ruby-lsp-check

@@ -44,7 +44,7 @@ puts "\n"
 puts "Verifying that indexing executes successfully. This may take a while..."
 
 index = RubyIndexer::Index.new
-indexables = RubyIndexer.configuration.indexables
+indexables = index.configuration.indexables
 
 indexables.each_with_index do |indexable, i|
   index.index_single(indexable)

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -8,12 +8,22 @@ module RubyIndexer
     OBJECT_NESTING = T.let(["Object"].freeze, T::Array[String])
     BASIC_OBJECT_NESTING = T.let(["BasicObject"].freeze, T::Array[String])
 
+    sig { returns(T::Array[String]) }
+    attr_reader :indexing_errors
+
     sig do
-      params(index: Index, dispatcher: Prism::Dispatcher, parse_result: Prism::ParseResult, file_path: String).void
+      params(
+        index: Index,
+        dispatcher: Prism::Dispatcher,
+        parse_result: Prism::ParseResult,
+        file_path: String,
+        enhancements: T::Array[Enhancement],
+      ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path)
+    def initialize(index, dispatcher, parse_result, file_path, enhancements: [])
       @index = index
       @file_path = file_path
+      @enhancements = enhancements
       @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
@@ -29,6 +39,7 @@ module RubyIndexer
 
       # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
       @owner_stack = T.let([], T::Array[Entry::Namespace])
+      @indexing_errors = T.let([], T::Array[String])
 
       dispatcher.register(
         self,
@@ -64,13 +75,14 @@ module RubyIndexer
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
       @visibility_stack.push(Entry::Visibility::PUBLIC)
-      name = node.constant_path.location.slice
+      constant_path = node.constant_path
+      name = constant_path.slice
 
       comments = collect_comments(node)
 
       superclass = node.superclass
 
-      nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
+      nesting = actual_nesting(name)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -93,6 +105,7 @@ module RubyIndexer
         nesting,
         @file_path,
         node.location,
+        constant_path.location,
         comments,
         parent_class,
       )
@@ -112,12 +125,12 @@ module RubyIndexer
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
       @visibility_stack.push(Entry::Visibility::PUBLIC)
-      name = node.constant_path.location.slice
+      constant_path = node.constant_path
+      name = constant_path.slice
 
       comments = collect_comments(node)
 
-      nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
-      entry = Entry::Module.new(nesting, @file_path, node.location, comments)
+      entry = Entry::Module.new(actual_nesting(name), @file_path, node.location, constant_path.location, comments)
 
       @owner_stack << entry
       @index.add(entry)
@@ -145,9 +158,16 @@ module RubyIndexer
 
         if existing_entries
           entry = T.must(existing_entries.first)
-          entry.update_singleton_information(node.location, collect_comments(node))
+          entry.update_singleton_information(node.location, expression.location, collect_comments(node))
         else
-          entry = Entry::SingletonClass.new(@stack, @file_path, node.location, collect_comments(node), nil)
+          entry = Entry::SingletonClass.new(
+            @stack,
+            @file_path,
+            node.location,
+            expression.location,
+            collect_comments(node),
+            nil,
+          )
           @index.add(entry, skip_prefix_tree: true)
         end
 
@@ -270,6 +290,12 @@ module RubyIndexer
       when :private
         @visibility_stack.push(Entry::Visibility::PRIVATE)
       end
+
+      @enhancements.each do |enhancement|
+        enhancement.on_call_node(@index, @owner_stack.last, node, @file_path)
+      rescue StandardError => e
+        @indexing_errors << "Indexing error in #{@file_path} with '#{enhancement.class.name}' enhancement: #{e.message}"
+      end
     end
 
     sig { params(node: Prism::CallNode).void }
@@ -297,25 +323,29 @@ module RubyIndexer
           method_name,
           @file_path,
           node.location,
+          node.name_loc,
           comments,
-          list_params(node.parameters),
+          [Entry::Signature.new(list_params(node.parameters))],
           current_visibility,
           @owner_stack.last,
         ))
       when Prism::SelfNode
-        singleton = singleton_klass
-
-        @index.add(Entry::Method.new(
-          method_name,
-          @file_path,
-          node.location,
-          comments,
-          list_params(node.parameters),
-          current_visibility,
-          singleton,
-        ))
+        owner = @owner_stack.last
+
+        if owner
+          singleton = @index.existing_or_new_singleton_class(owner.name)
+
+          @index.add(Entry::Method.new(
+            method_name,
+            @file_path,
+            node.location,
+            node.name_loc,
+            comments,
+            [Entry::Signature.new(list_params(node.parameters))],
+            current_visibility,
+            singleton,
+          ))
 
-        if singleton
           @owner_stack << singleton
           @stack << "<Class:#{@stack.last}>"
         end
@@ -393,7 +423,12 @@ module RubyIndexer
 
       # When instance variables are declared inside the class body, they turn into class instance variables rather than
       # regular instance variables
-      owner = @inside_def ? @owner_stack.last : singleton_klass
+      owner = @owner_stack.last
+
+      if owner && !@inside_def
+        owner = @index.existing_or_new_singleton_class(owner.name)
+      end
+
       @index.add(Entry::InstanceVariable.new(name, @file_path, loc, collect_comments(node), owner))
     end
 
@@ -486,17 +521,17 @@ module RubyIndexer
       @index.add(
         case value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          Entry::UnresolvedAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.slice, @stack.dup, name, @file_path, node.location, comments)
         when Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
         Prism::ConstantOperatorWriteNode
 
           # If the right hand side is another constant assignment, we need to visit it because that constant has to be
           # indexed too
-          Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
         when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-          Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
+          Entry::UnresolvedConstantAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
         else
           Entry::Constant.new(name, @file_path, node.location, comments)
         end,
@@ -517,7 +552,7 @@ module RubyIndexer
         comment_content = comment.location.slice.chomp
 
         # invalid encodings would raise an "invalid byte sequence" exception
-        if !comment_content.valid_encoding? || comment_content.match?(RubyIndexer.configuration.magic_comment_regex)
+        if !comment_content.valid_encoding? || comment_content.match?(@index.configuration.magic_comment_regex)
           next
         end
 
@@ -593,7 +628,8 @@ module RubyIndexer
         when :prepend
           owner.mixin_operations << Entry::Prepend.new(node.full_name)
         when :extend
-          owner.mixin_operations << Entry::Extend.new(node.full_name)
+          singleton = @index.existing_or_new_singleton_class(owner.name)
+          singleton.mixin_operations << Entry::Include.new(node.full_name)
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
              Prism::ConstantPathNode::MissingNodesInConstantPathError
@@ -690,23 +726,18 @@ module RubyIndexer
       end
     end
 
-    sig { returns(T.nilable(Entry::Class)) }
-    def singleton_klass
-      attached_class = @owner_stack.last
-      return unless attached_class
+    sig { params(name: String).returns(T::Array[String]) }
+    def actual_nesting(name)
+      nesting = @stack + [name]
+      corrected_nesting = []
 
-      # Return the existing singleton class if available
-      owner = T.cast(
-        @index["#{attached_class.name}::<Class:#{attached_class.name}>"],
-        T.nilable(T::Array[Entry::SingletonClass]),
-      )
-      return owner.first if owner
+      nesting.reverse_each do |name|
+        corrected_nesting.prepend(name.delete_prefix("::"))
+
+        break if name.start_with?("::")
+      end
 
-      # If not available, create the singleton class lazily
-      nesting = @stack + ["<Class:#{@stack.last}>"]
-      entry = Entry::SingletonClass.new(nesting, @file_path, attached_class.location, [], nil)
-      @index.add(entry, skip_prefix_tree: true)
-      entry
+      corrected_nesting
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  module Enhancement
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    requires_ancestor { Object }
+
+    # The `on_extend` indexing enhancement is invoked whenever an extend is encountered in the code. It can be used to
+    # register for an included callback, similar to what `ActiveSupport::Concern` does in order to auto-extend the
+    # `ClassMethods` modules
+    sig do
+      abstract.params(
+        index: Index,
+        owner: T.nilable(Entry::Namespace),
+        node: Prism::CallNode,
+        file_path: String,
+      ).void
+    end
+    def on_call_node(index, owner, node, file_path); end
+  end
+end