ruby-lsp 0.20.0 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d43d431cf15d817d80ebb8564f90a748b871ad3c2c278482d4b1b5c831b7bcd2
-  data.tar.gz: 28ab582396723d582f7909ad277300430b6e14e6a281408be21a71f4d768930f
+  metadata.gz: 58327a9f9a3d85375cbbf81e3e170a948d5c8dfbdcdcac0a1fdef5f685d20c95
+  data.tar.gz: 45572eb6645bce73d2079bed65f0d92c98921517926b968bba96788769a3aada
 SHA512:
-  metadata.gz: 73a87212da50592a6b201a5f21ea559de74fb12ed795428e06392a4375aa73015a103aedd56734b9b05a2f0a27fcb7366b16107ea9f1a080b3459e2eff1dcd88
-  data.tar.gz: 7ad77f3dccbabba9cb306c73ccefca4e84e9ff480bc0594d20a1c6e03727948119f7accefc522e5ed25d6de1d21fff03b18c704c7c8908b33eb92cfc5b2c665d
+  metadata.gz: c506eeff4d24060e3afdb4ad9da319c12b725050c8f25a9348ec7dea9082f8adced7671b7b1eb8f7f09412942139e47a2df5059b5672d2b6a75f0ffc5a59885d
+  data.tar.gz: d9a89ce24946e5f9cc47b5a48086f6fd977176d31332a0b634950dc00a41fc9a36e4753eae2896e2da0129e92bff4278265eaa970252a5292c783e5bc82258e9

data/VERSION

@@ -1 +1 @@
-0.20.0
+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/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/index.rb

@@ -980,29 +980,23 @@ module RubyIndexer
     # nesting
     sig { params(name: String, nesting: T::Array[String]).returns(String) }
     def build_non_redundant_full_name(name, nesting)
+      # If there's no nesting, then we can just return the name as is
       return name if nesting.empty?
 
-      namespace = nesting.join("::")
-
       # If the name is not qualified, we can just concatenate the nesting and the name
-      return "#{namespace}::#{name}" unless name.include?("::")
+      return "#{nesting.join("::")}::#{name}" unless name.include?("::")
 
       name_parts = name.split("::")
+      first_redundant_part = nesting.index(name_parts[0])
 
-      # Find the first part of the name that is not in the nesting
-      index = name_parts.index { |part| !nesting.include?(part) }
+      # If there are no redundant parts between the name and the nesting, then the full name is both combined
+      return "#{nesting.join("::")}::#{name}" unless first_redundant_part
 
-      if index.nil?
-        # All parts of the nesting are redundant because they are already present in the name. We can return the name
-        # directly
-        name
-      elsif index == 0
-        # No parts of the nesting are in the name, we can concatenate the namespace and the name
-        "#{namespace}::#{name}"
-      else
-        # The name includes some parts of the nesting. We need to remove the redundant parts
-        "#{namespace}::#{T.must(name_parts[index..-1]).join("::")}"
-      end
+      # Otherwise, push all of the leading parts of the nesting that aren't redundant into the name. For example, if we
+      # have a reference to `Foo::Bar` inside the `[Namespace, Foo]` nesting, then only the `Foo` part is redundant, but
+      # we still need to include the `Namespace` part
+      T.unsafe(name_parts).unshift(*nesting[0...first_redundant_part])
+      name_parts.join("::")
     end
 
     sig do

data/lib/ruby_indexer/test/index_test.rb

@@ -1934,5 +1934,94 @@ module RubyIndexer
       real_namespace = @index.follow_aliased_namespace("Namespace::Second")
       assert_equal("First::Second", real_namespace)
     end
+
+    def test_resolving_alias_to_non_existing_namespace
+      index(<<~RUBY)
+        module Namespace
+          class Foo
+            module InnerNamespace
+              Constants = Namespace::Foo::Constants
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_instance_of(Entry::UnresolvedConstantAlias, entry)
+
+      entry = @index.resolve("Namespace::Foo::Constants", ["Namespace", "Foo", "InnerNamespace"])&.first
+      assert_nil(entry)
+    end
+
+    def test_resolving_alias_to_existing_constant_from_inner_namespace
+      index(<<~RUBY)
+        module Parent
+          CONST = 123
+        end
+
+        module First
+          module Namespace
+            class Foo
+              include Parent
+
+              module InnerNamespace
+                Constants = Namespace::Foo::CONST
+              end
+            end
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("Namespace::Foo::CONST", ["First", "Namespace", "Foo", "InnerNamespace"])&.first
+      assert_equal("Parent::CONST", entry.name)
+      assert_instance_of(Entry::Constant, entry)
+    end
+
+    def test_build_non_redundant_name
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Foo::Constants",
+          ["Namespace", "Foo"],
+        ),
+      )
+
+      assert_equal(
+        "Bar::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["Bar"],
+        ),
+      )
+
+      assert_equal(
+        "First::Namespace::Foo::Constants",
+        @index.send(
+          :build_non_redundant_full_name,
+          "Namespace::Foo::Constants",
+          ["First", "Namespace", "Foo", "InnerNamespace"],
+        ),
+      )
+    end
   end
 end

data/lib/ruby_lsp/requests/references.rb

@@ -78,6 +78,8 @@ module RubyLsp
 
           parse_result = Prism.parse_file(path)
           collect_references(reference_target, parse_result, uri)
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |_uri, document|

data/lib/ruby_lsp/requests/rename.rb

@@ -147,6 +147,8 @@ module RubyLsp
           parse_result = Prism.parse_file(path)
           edits = collect_changes(target, parse_result, name, uri)
           changes[uri.to_s] = edits unless edits.empty?
+        rescue Errno::EISDIR, Errno::ENOENT
+          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |uri, document|

data/lib/ruby_lsp/setup_bundler.rb

@@ -48,7 +48,9 @@ module RubyLsp
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
       @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
 
-      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
+      dependencies, bundler_version = load_dependencies
+      @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
+      @bundler_version = T.let(bundler_version, T.nilable(Gem::Version))
       @rails_app = T.let(rails_app?, T::Boolean)
       @retry = T.let(false, T::Boolean)
     end
@@ -156,14 +158,15 @@ module RubyLsp
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns([T::Hash[String, T.untyped], T.nilable(Gem::Version)]) }
     def load_dependencies
-      return {} unless @lockfile&.exist?
+      return [{}, nil] unless @lockfile&.exist?
 
       # We need to parse the Gemfile.lock manually here. If we try to do `bundler/setup` to use something more
       # convenient, we may end up with issues when the globally installed `ruby-lsp` version mismatches the one included
       # in the `Gemfile`
-      dependencies = Bundler::LockfileParser.new(@lockfile.read).dependencies
+      lockfile_parser = Bundler::LockfileParser.new(@lockfile.read)
+      dependencies = lockfile_parser.dependencies
 
       # When working on a gem, the `ruby-lsp` might be listed as a dependency in the gemspec. We need to make sure we
       # check those as well or else we may get version mismatch errors. Notice that bundler allows more than one
@@ -172,7 +175,7 @@ module RubyLsp
         dependencies.merge!(Bundler.load_gemspec(path).dependencies.to_h { |dep| [dep.name, dep] })
       end
 
-      dependencies
+      [dependencies, lockfile_parser.bundler_version]
     end
 
     sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
@@ -188,6 +191,16 @@ module RubyLsp
         env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
       end
 
+      # If there's a Bundler version locked, then we need to use that one to run bundle commands, so that the composed
+      # lockfile is also locked to the same version. This avoids Bundler restarts on version mismatches
+      base_bundle = if @bundler_version
+        env["BUNDLER_VERSION"] = @bundler_version.to_s
+        install_bundler_if_needed
+        "bundle _#{@bundler_version}_"
+      else
+        "bundle"
+      end
+
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) 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 any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
@@ -196,13 +209,13 @@ module RubyLsp
 
       # When not updating, we run `(bundle check || bundle install)`
       # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
-      command = +"(bundle check"
+      command = +"(#{base_bundle} check"
 
       if should_bundle_update?
         # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
         # version
         command.prepend("(")
-        command << " && bundle update "
+        command << " && #{base_bundle} update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -212,7 +225,7 @@ module RubyLsp
         @last_updated_path.write(Time.now.iso8601)
       end
 
-      command << " || bundle install) "
+      command << " || #{base_bundle} install) "
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
@@ -259,6 +272,15 @@ module RubyLsp
       end
     end
 
+    sig { void }
+    def install_bundler_if_needed
+      # Try to find the bundler version specified in the lockfile in installed gems. If not found, install it
+      requirement = Gem::Requirement.new(@bundler_version.to_s)
+      return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
+
+      Gem.install("bundler", @bundler_version.to_s)
+    end
+
     sig { returns(T::Boolean) }
     def should_bundle_update?
       # If `ruby-lsp`, `ruby-lsp-rails` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.20.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol