ruby-lsp 0.19.1 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d900634d5328c8b4b5fcf799f807456bec3cdb94d6294c80fa9152bcf45aedde
-  data.tar.gz: b7661867d38331ec158312b10c7f530cbd58994ee94e8ff592f478e7e05efcb7
+  metadata.gz: 58327a9f9a3d85375cbbf81e3e170a948d5c8dfbdcdcac0a1fdef5f685d20c95
+  data.tar.gz: 45572eb6645bce73d2079bed65f0d92c98921517926b968bba96788769a3aada
 SHA512:
-  metadata.gz: 8f7955f676bc5f231f990f04d8aea1a767165d4f2cac1e9514928014cd8a09eb68c60b4cd226a94b554dac88d77c2117ae3a3ea76bb66e68980974f1685d8970
-  data.tar.gz: 1b914d5607e5730139780cd1f172923db7878a7a0a4098daa1e17df8a1a7a2d8b6731b092baf7eeefc9f55605305e4d70d8cca8489f68a17bab532026c38e8b2
+  metadata.gz: c506eeff4d24060e3afdb4ad9da319c12b725050c8f25a9348ec7dea9082f8adced7671b7b1eb8f7f09412942139e47a2df5059b5672d2b6a75f0ffc5a59885d
+  data.tar.gz: d9a89ce24946e5f9cc47b5a48086f6fd977176d31332a0b634950dc00a41fc9a36e4753eae2896e2da0129e92bff4278265eaa970252a5292c783e5bc82258e9

data/VERSION

@@ -1 +1 @@
-0.19.1
+0.20.1

data/exe/ruby-lsp

@@ -63,7 +63,13 @@ if ENV["BUNDLE_GEMFILE"].nil?
     exit(78)
   end
 
-  exit exec(env, "bundle exec ruby-lsp #{original_args.join(" ")}")
+  base_bundle = if env["BUNDLER_VERSION"]
+    "bundle _#{env["BUNDLER_VERSION"]}_"
+  else
+    "bundle"
+  end
+
+  exit exec(env, "#{base_bundle} exec ruby-lsp #{original_args.join(" ")}")
 end
 
 require "ruby_lsp/load_sorbet"

data/lib/core_ext/uri.rb

@@ -3,6 +3,8 @@
 
 module URI
   class Generic
+    extend T::Sig
+
     # Avoid a deprecation warning with Ruby 3.4 where the default parser was changed to RFC3986.
     # This condition must remain even after support for 3.4 has been dropped for users that have
     # `uri` in their lockfile, decoupling it from the ruby version.
@@ -27,8 +29,6 @@ module URI
       end
     end
 
-    extend T::Sig
-
     sig { returns(T.nilable(String)) }
     def to_standardized_path
       parsed_path = path

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

@@ -28,7 +28,17 @@ module RubyIndexer
       @encoding = T.let(Encoding::UTF_8, Encoding)
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("tmp", "**", "*")], T::Array[String])
+
+      @excluded_patterns = T.let(
+        [
+          File.join("**", "*_test.rb"),
+          File.join("node_modules", "**", "*"),
+          File.join("spec", "**", "*"),
+          File.join("test", "**", "*"),
+          File.join("tmp", "**", "*"),
+        ],
+        T::Array[String],
+      )
 
       path = Bundler.settings["path"]
       if path
@@ -56,6 +66,21 @@ module RubyIndexer
       )
     end
 
+    sig { returns(String) }
+    def merged_excluded_file_pattern
+      # This regex looks for @excluded_patterns that follow the format of "something/**/*", where
+      # "something" is one or more non-"/"
+      #
+      # Returns "/path/to/workspace/{tmp,node_modules}/**/*"
+      @excluded_patterns
+        .filter_map do |pattern|
+          next if File.absolute_path?(pattern)
+
+          pattern.match(%r{\A([^/]+)/\*\*/\*\z})&.captures&.first
+        end
+        .then { |dirs| File.join(@workspace_path, "{#{dirs.join(",")}}/**/*") }
+    end
+
     sig { returns(T::Array[IndexablePath]) }
     def indexables
       excluded_gems = @excluded_gems - @included_gems
@@ -64,21 +89,47 @@ module RubyIndexer
       # 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
 
+      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+      # In order to speed up indexing, only traverse into top-level directories that are not entirely excluded.
+      # For example, if "tmp/**/*" is excluded, we don't need to traverse into "tmp" at all. However, if
+      # "vendor/bundle/**/*" is excluded, we will traverse all of "vendor" and `reject!` out all "vendor/bundle" entries
+      # later.
+      excluded_pattern = merged_excluded_file_pattern
+      included_paths = Dir.glob(File.join(@workspace_path, "*/"), flags)
+        .filter_map do |included_path|
+          next if File.fnmatch?(excluded_pattern, included_path, flags)
+
+          relative_path = included_path
+            .delete_prefix(@workspace_path)
+            .tap { |path| path.delete_prefix!("/") }
+
+          [included_path, relative_path]
+        end
+
+      indexables = T.let([], T::Array[IndexablePath])
+
       # Add user specified patterns
-      indexables = @included_patterns.flat_map do |pattern|
+      @included_patterns.each do |pattern|
         load_path_entry = T.let(nil, T.nilable(String))
 
-        Dir.glob(File.join(@workspace_path, pattern), File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
-          path = File.expand_path(path)
-          # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
-          # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
-          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the current
-          # workspace directory, but each one of them belongs to a different $LOAD_PATH entry
-          if load_path_entry.nil? || !path.start_with?(load_path_entry)
-            load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
-          end
+        included_paths.each do |included_path, relative_path|
+          relative_pattern = pattern.delete_prefix(File.join(relative_path, "/"))
+
+          next unless pattern.start_with?("**") || pattern.start_with?(relative_path)
 
-          IndexablePath.new(load_path_entry, path)
+          Dir.glob(File.join(included_path, relative_pattern), flags).each do |path|
+            path = File.expand_path(path)
+            # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
+            # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This
+            # happens on repositories that define multiple gems, like Rails. All frameworks are defined inside the
+            # current workspace directory, but each one of them belongs to a different $LOAD_PATH entry
+            if load_path_entry.nil? || !path.start_with?(load_path_entry)
+              load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+            end
+
+            indexables << IndexablePath.new(load_path_entry, path)
+          end
         end
       end
 

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

@@ -33,6 +33,10 @@ module RubyIndexer
         T::Hash[Integer, Prism::Comment],
       )
       @inside_def = T.let(false, T::Boolean)
+      @code_units_cache = T.let(
+        parse_result.code_units_cache(@index.configuration.encoding),
+        T.any(T.proc.params(arg0: Integer).returns(Integer), Prism::CodeUnitsCache),
+      )
 
       # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
       # stored by unresolved aliases which need the original nesting to be lazily resolved
@@ -65,6 +69,11 @@ module RubyIndexer
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
         :on_constant_operator_write_node_enter,
+        :on_global_variable_and_write_node_enter,
+        :on_global_variable_operator_write_node_enter,
+        :on_global_variable_or_write_node_enter,
+        :on_global_variable_target_node_enter,
+        :on_global_variable_write_node_enter,
         :on_instance_variable_write_node_enter,
         :on_instance_variable_and_write_node_enter,
         :on_instance_variable_operator_write_node_enter,
@@ -106,10 +115,9 @@ module RubyIndexer
       entry = Entry::Class.new(
         nesting,
         @file_path,
-        node.location,
-        constant_path.location,
+        Location.from_prism_location(node.location, @code_units_cache),
+        Location.from_prism_location(constant_path.location, @code_units_cache),
         comments,
-        @index.configuration.encoding,
         parent_class,
       )
 
@@ -136,10 +144,9 @@ module RubyIndexer
       entry = Entry::Module.new(
         actual_nesting(name),
         @file_path,
-        node.location,
-        constant_path.location,
+        Location.from_prism_location(node.location, @code_units_cache),
+        Location.from_prism_location(constant_path.location, @code_units_cache),
         comments,
-        @index.configuration.encoding,
       )
 
       @owner_stack << entry
@@ -170,19 +177,17 @@ module RubyIndexer
         if existing_entries
           entry = T.must(existing_entries.first)
           entry.update_singleton_information(
-            node.location,
-            expression.location,
+            Location.from_prism_location(node.location, @code_units_cache),
+            Location.from_prism_location(expression.location, @code_units_cache),
             collect_comments(node),
-            @index.configuration.encoding,
           )
         else
           entry = Entry::SingletonClass.new(
             real_nesting,
             @file_path,
-            node.location,
-            expression.location,
+            Location.from_prism_location(node.location, @code_units_cache),
+            Location.from_prism_location(expression.location, @code_units_cache),
             collect_comments(node),
-            @index.configuration.encoding,
             nil,
           )
           @index.add(entry, skip_prefix_tree: true)
@@ -310,7 +315,7 @@ module RubyIndexer
       end
 
       @enhancements.each do |enhancement|
-        enhancement.on_call_node(@index, @owner_stack.last, node, @file_path)
+        enhancement.on_call_node(@index, @owner_stack.last, node, @file_path, @code_units_cache)
       rescue StandardError => e
         @indexing_errors << "Indexing error in #{@file_path} with '#{enhancement.class.name}' enhancement: #{e.message}"
       end
@@ -340,10 +345,9 @@ module RubyIndexer
         @index.add(Entry::Method.new(
           method_name,
           @file_path,
-          node.location,
-          node.name_loc,
+          Location.from_prism_location(node.location, @code_units_cache),
+          Location.from_prism_location(node.name_loc, @code_units_cache),
           comments,
-          @index.configuration.encoding,
           [Entry::Signature.new(list_params(node.parameters))],
           current_visibility,
           @owner_stack.last,
@@ -357,10 +361,9 @@ module RubyIndexer
           @index.add(Entry::Method.new(
             method_name,
             @file_path,
-            node.location,
-            node.name_loc,
+            Location.from_prism_location(node.location, @code_units_cache),
+            Location.from_prism_location(node.name_loc, @code_units_cache),
             comments,
-            @index.configuration.encoding,
             [Entry::Signature.new(list_params(node.parameters))],
             current_visibility,
             singleton,
@@ -382,6 +385,31 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+    def on_global_variable_and_write_node_enter(node)
+      handle_global_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+    def on_global_variable_operator_write_node_enter(node)
+      handle_global_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+    def on_global_variable_or_write_node_enter(node)
+      handle_global_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::GlobalVariableTargetNode).void }
+    def on_global_variable_target_node_enter(node)
+      handle_global_variable(node, node.location)
+    end
+
+    sig { params(node: Prism::GlobalVariableWriteNode).void }
+    def on_global_variable_write_node_enter(node)
+      handle_global_variable(node, node.name_loc)
+    end
+
     sig { params(node: Prism::InstanceVariableWriteNode).void }
     def on_instance_variable_write_node_enter(node)
       handle_instance_variable(node, node.name_loc)
@@ -417,15 +445,38 @@ module RubyIndexer
           node.old_name.slice,
           @owner_stack.last,
           @file_path,
-          node.new_name.location,
+          Location.from_prism_location(node.new_name.location, @code_units_cache),
           comments,
-          @index.configuration.encoding,
         ),
       )
     end
 
     private
 
+    sig do
+      params(
+        node: T.any(
+          Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableTargetNode,
+          Prism::GlobalVariableWriteNode,
+        ),
+        loc: Prism::Location,
+      ).void
+    end
+    def handle_global_variable(node, loc)
+      name = node.name.to_s
+      comments = collect_comments(node)
+
+      @index.add(Entry::GlobalVariable.new(
+        name,
+        @file_path,
+        Location.from_prism_location(loc, @code_units_cache),
+        comments,
+      ))
+    end
+
     sig do
       params(
         node: T.any(
@@ -453,9 +504,8 @@ module RubyIndexer
       @index.add(Entry::InstanceVariable.new(
         name,
         @file_path,
-        loc,
+        Location.from_prism_location(loc, @code_units_cache),
         collect_comments(node),
-        @index.configuration.encoding,
         owner,
       ))
     end
@@ -518,9 +568,8 @@ module RubyIndexer
           old_name_value,
           @owner_stack.last,
           @file_path,
-          new_name.location,
+          Location.from_prism_location(new_name.location, @code_units_cache),
           comments,
-          @index.configuration.encoding,
         ),
       )
     end
@@ -555,9 +604,8 @@ module RubyIndexer
             @stack.dup,
             name,
             @file_path,
-            node.location,
+            Location.from_prism_location(node.location, @code_units_cache),
             comments,
-            @index.configuration.encoding,
           )
         when Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
         Prism::ConstantOperatorWriteNode
@@ -569,9 +617,8 @@ module RubyIndexer
             @stack.dup,
             name,
             @file_path,
-            node.location,
+            Location.from_prism_location(node.location, @code_units_cache),
             comments,
-            @index.configuration.encoding,
           )
         when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
@@ -581,12 +628,16 @@ module RubyIndexer
             @stack.dup,
             name,
             @file_path,
-            node.location,
+            Location.from_prism_location(node.location, @code_units_cache),
             comments,
-            @index.configuration.encoding,
           )
         else
-          Entry::Constant.new(name, @file_path, node.location, comments, @index.configuration.encoding)
+          Entry::Constant.new(
+            name,
+            @file_path,
+            Location.from_prism_location(node.location, @code_units_cache),
+            comments,
+          )
         end,
       )
     end
@@ -652,9 +703,8 @@ module RubyIndexer
           @index.add(Entry::Accessor.new(
             name,
             @file_path,
-            loc,
+            Location.from_prism_location(loc, @code_units_cache),
             comments,
-            @index.configuration.encoding,
             current_visibility,
             @owner_stack.last,
           ))
@@ -665,9 +715,8 @@ module RubyIndexer
         @index.add(Entry::Accessor.new(
           "#{name}=",
           @file_path,
-          loc,
+          Location.from_prism_location(loc, @code_units_cache),
           comments,
-          @index.configuration.encoding,
           current_visibility,
           @owner_stack.last,
         ))

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

@@ -19,8 +19,12 @@ module RubyIndexer
         owner: T.nilable(Entry::Namespace),
         node: Prism::CallNode,
         file_path: String,
+        code_units_cache: T.any(
+          T.proc.params(arg0: Integer).returns(Integer),
+          Prism::CodeUnitsCache,
+        ),
       ).void
     end
-    def on_call_node(index, owner, node, file_path); end
+    def on_call_node(index, owner, node, file_path, code_units_cache); end
   end
 end