ruby-lsp 0.22.1 → 0.23.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efd5671eae595026a17c3114a00de1053865ac828726dd7ac5a66548f6b1ad56
-  data.tar.gz: ccf5b7af12a6e1e327cc2d458be11f39a9ac7319ab9049863ed5a74e333e8a6f
+  metadata.gz: 3a0d78055f2f6bf861e581a5b5a2d1321d3a8452b23d638becb6e64da925d842
+  data.tar.gz: '0397aa5a123ed08757606db1be3690b50cba847a372f52da25fb64a6fb5816ce'
 SHA512:
-  metadata.gz: 8fbcdfaac508788a17fb3b7e939ce290e33049a0080ff6260abfaeb609ee76a033234ccc2efa5724587e9c4cbf4552e2cd5d2cb0af1186971b8ed06fec290cb3
-  data.tar.gz: 3e37acf250618e60df2addbce7f9acf86df4bf3e771b7b49c4cd8f4ad326ea82e3d41ad80c5ce71e3b0429dab98385df51f4645824cd419e32dac5ea13778760
+  metadata.gz: a14d101646bd32467724aeedb60892c5c06e775a57d749623cc1e76dbc42ee6d82eca10e2fa1149900365eff59ee57c20300bb043a3fdcf1330961b6bbd94918
+  data.tar.gz: 23b339c5854620771e7b505381dad64cf3e8d89ed2850a19c7a299e72d2363202e1e74327c05d27d8fb7fae508abb7141e5a858319b2841c8c914233e28e076e

data/README.md

@@ -4,7 +4,7 @@
 
 [![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
 [![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
-[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA)
 
 # Ruby LSP
 
@@ -13,7 +13,7 @@ for Ruby, used to improve rich features in editors. It is a part of a wider goal
 experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
 Want to discuss Ruby developer experience? Consider joining the public
-[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q).
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA).
 
 ## Getting Started
 

data/VERSION

@@ -1 +1 @@
-0.22.1
+0.23.10

data/exe/ruby-lsp

@@ -64,9 +64,9 @@ if ENV["BUNDLE_GEMFILE"].nil?
   # which gives us the opportunity to control which specs are activated and enter degraded mode if any gems failed to
   # install rather than failing to boot the server completely
   if options[:launcher]
-    command = +File.expand_path("ruby-lsp-launcher", __dir__)
-    command << " --debug" if options[:debug]
-    exit exec(command)
+    flags = []
+    flags << "--debug" if options[:debug]
+    exit exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *flags)
   end
 
   require_relative "../lib/ruby_lsp/setup_bundler"
@@ -78,13 +78,14 @@ if ENV["BUNDLE_GEMFILE"].nil?
     exit(78)
   end
 
-  base_bundle = if env["BUNDLER_VERSION"]
-    "bundle _#{env["BUNDLER_VERSION"]}_"
-  else
-    "bundle"
+  bundler_path = File.join(Gem.default_bindir, "bundle")
+  base_command = (!Gem.win_platform? && File.exist?(bundler_path) ? "#{Gem.ruby} #{bundler_path}" : "bundle").dup
+
+  if env["BUNDLER_VERSION"]
+    base_command << " _#{env["BUNDLER_VERSION"]}_"
   end
 
-  exit exec(env, "#{base_bundle} exec ruby-lsp #{original_args.join(" ")}".strip)
+  exit exec(env, "#{base_command} exec ruby-lsp #{original_args.join(" ")}".strip)
 end
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
@@ -139,9 +140,9 @@ if options[:doctor]
 
   puts "Globbing for indexable files"
 
-  index.configuration.indexables.each do |indexable|
-    puts "indexing: #{indexable.full_path}"
-    index.index_single(indexable)
+  index.configuration.indexable_uris.each do |uri|
+    puts "indexing: #{uri}"
+    index.index_file(uri)
   end
   return
 end

data/exe/ruby-lsp-check

@@ -44,14 +44,14 @@ puts "\n"
 puts "Verifying that indexing executes successfully. This may take a while..."
 
 index = RubyIndexer::Index.new
-indexables = index.configuration.indexables
+uris = index.configuration.indexable_uris
 
-indexables.each_with_index do |indexable, i|
-  index.index_single(indexable)
+uris.each_with_index do |uri, i|
+  index.index_file(uri)
 rescue => e
-  errors[indexable.full_path] = e
+  errors[uri.full_path] = e
 ensure
-  print("\033[M\033[0KIndexed #{i + 1}/#{indexables.length}") unless ENV["CI"]
+  print("\033[M\033[0KIndexed #{i + 1}/#{uris.length}") unless ENV["CI"]
 end
 puts "\n"
 

data/exe/ruby-lsp-launcher

@@ -7,14 +7,25 @@
 # !!!!!!!
 
 setup_error = nil
+install_error = nil
+reboot = false
 
-# Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
-# Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
-# to ensure that we're setting up the bundle in the right place
-$stdin.binmode
-headers = $stdin.gets("\r\n\r\n")
-content_length = headers[/Content-Length: (\d+)/i, 1].to_i
-raw_initialize = $stdin.read(content_length)
+workspace_uri = ARGV.first
+
+raw_initialize = if workspace_uri && !workspace_uri.start_with?("--")
+  # If there's an argument without `--`, then it's the server asking to compose the bundle and passing to this
+  # executable the workspace URI. We can't require gems at this point, so we built a fake initialize request manually
+  reboot = true
+  "{\"params\":{\"workspaceFolders\":[{\"uri\":\"#{workspace_uri}\"}]}}"
+else
+  # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
+  # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
+  # to ensure that we're setting up the bundle in the right place
+  $stdin.binmode
+  headers = $stdin.gets("\r\n\r\n")
+  content_length = headers[/Content-Length: (\d+)/i, 1].to_i
+  $stdin.read(content_length)
+end
 
 # Compose the Ruby LSP bundle in a forked process so that we can require gems without polluting the main process
 # `$LOAD_PATH` and `Gem.loaded_specs`. Windows doesn't support forking, so we need a separate path to support it
@@ -40,7 +51,7 @@ end
 
 begin
   # Wait until the composed Bundle is finished
-  Process.wait(pid)
+  _, status = Process.wait2(pid)
 rescue Errno::ECHILD
   # In theory, the child process can finish before we even get to the wait call, but that is not an error
 end
@@ -61,25 +72,40 @@ begin
 
     require "bundler"
     Bundler.ui.level = :silent
+
+    # This Marshal load can only happen after requiring Bundler because it will load a custom error class from Bundler
+    # itself. If we try to load before requiring, the class will not be defined and loading will fail
+    error_path = File.join(".ruby-lsp", "install_error")
+    install_error = if File.exist?(error_path)
+      Marshal.load(File.read(error_path))
+    end
+
     Bundler.setup
     $stderr.puts("Composed Bundle set up successfully")
   end
 rescue StandardError => e
   # If installing gems failed for any reason, we don't want to exit the process prematurely. We can still provide most
   # features in a degraded mode. We simply save the error so that we can report to the user that certain gems might be
-  # missing, but we respect the LSP life cycle
-  setup_error = e
-  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  # missing, but we respect the LSP life cycle.
+  #
+  # If an install error occurred and one of the gems is not installed, Bundler.setup is guaranteed to fail with
+  # `Bundler::GemNotFound`. We don't set `setup_error` here because that would essentially report the same problem twice
+  # to telemetry, which is not useful
+  unless install_error && e.is_a?(Bundler::GemNotFound)
+    setup_error = e
+    $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+  end
 
   # If Bundler.setup fails, we need to restore the original $LOAD_PATH so that we can still require the Ruby LSP server
   # in degraded mode
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 end
 
-error_path = File.join(".ruby-lsp", "install_error")
-
-install_error = if File.exist?(error_path)
-  Marshal.load(File.read(error_path))
+# When performing a lockfile re-boot, this executable is invoked to set up the composed bundle ahead of time. In this
+# flow, we are not booting the LSP yet, just checking if the bundle is valid before rebooting
+if reboot
+  # Use the exit status to signal to the server if composing the bundle succeeded
+  exit(install_error || setup_error ? 1 : status&.exitstatus || 0)
 end
 
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already

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

@@ -81,8 +81,8 @@ module RubyIndexer
         .then { |dirs| File.join(@workspace_path, "{#{dirs.join(",")}}/**/*") }
     end
 
-    sig { returns(T::Array[IndexablePath]) }
-    def indexables
+    sig { returns(T::Array[URI::Generic]) }
+    def indexable_uris
       excluded_gems = @excluded_gems - @included_gems
       locked_gems = Bundler.locked_gems&.specs
 
@@ -107,12 +107,12 @@ module RubyIndexer
           [included_path, relative_path]
         end
 
-      indexables = T.let([], T::Array[IndexablePath])
+      uris = T.let([], T::Array[URI::Generic])
 
       # Handle top level files separately. The path below is an optimization to prevent descending down directories that
       # are going to be excluded anyway, so we need to handle top level scripts separately
       Dir.glob(File.join(@workspace_path, "*.rb"), flags).each do |path|
-        indexables << IndexablePath.new(nil, path)
+        uris << URI::Generic.from_path(path: path)
       end
 
       # Add user specified patterns
@@ -134,7 +134,7 @@ module RubyIndexer
               load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
             end
 
-            indexables << IndexablePath.new(load_path_entry, path)
+            uris << URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
           end
         end
       end
@@ -150,9 +150,9 @@ module RubyIndexer
       end
 
       # Remove user specified patterns
-      indexables.reject! do |indexable|
+      uris.reject! do |indexable|
         excluded_patterns.any? do |pattern|
-          File.fnmatch?(pattern, indexable.full_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          File.fnmatch?(pattern, T.must(indexable.full_path), File::FNM_PATHNAME | File::FNM_EXTGLOB)
         end
       end
 
@@ -182,14 +182,14 @@ module RubyIndexer
 
         if pathname.directory?
           # If the default_path is a directory, we index all the Ruby files in it
-          indexables.concat(
+          uris.concat(
             Dir.glob(File.join(default_path, "**", "*.rb"), File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
-              IndexablePath.new(RbConfig::CONFIG["rubylibdir"], path)
+              URI::Generic.from_path(path: path, load_path_entry: RbConfig::CONFIG["rubylibdir"])
             end,
           )
         elsif pathname.extname == ".rb"
           # If the default_path is a Ruby file, we index it
-          indexables << IndexablePath.new(RbConfig::CONFIG["rubylibdir"], default_path)
+          uris << URI::Generic.from_path(path: default_path, load_path_entry: RbConfig::CONFIG["rubylibdir"])
         end
       end
 
@@ -204,10 +204,12 @@ module RubyIndexer
         # duplicates or accidentally ignoring exclude patterns
         next if spec.full_gem_path == @workspace_path
 
-        indexables.concat(
+        uris.concat(
           spec.require_paths.flat_map do |require_path|
             load_path_entry = File.join(spec.full_gem_path, require_path)
-            Dir.glob(File.join(load_path_entry, "**", "*.rb")).map! { |path| IndexablePath.new(load_path_entry, path) }
+            Dir.glob(File.join(load_path_entry, "**", "*.rb")).map! do |path|
+              URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
+            end
           end,
         )
       rescue Gem::MissingSpecError
@@ -216,8 +218,8 @@ module RubyIndexer
         # just ignore if they're missing
       end
 
-      indexables.uniq!(&:full_path)
-      indexables
+      uris.uniq!(&:to_s)
+      uris
     end
 
     sig { returns(Regexp) }
@@ -271,6 +273,15 @@ module RubyIndexer
       end
 
       others.concat(this_gem.to_spec.dependencies) if this_gem
+      others.concat(
+        others.filter_map do |d|
+          d.to_spec&.dependencies
+        rescue Gem::MissingSpecError
+          nil
+        end.flatten,
+      )
+      others.uniq!
+      others.map!(&:name)
 
       excluded.each do |dependency|
         next unless dependency.runtime?
@@ -279,12 +290,7 @@ module RubyIndexer
         next unless spec
 
         spec.dependencies.each do |transitive_dependency|
-          # If the transitive dependency is included in other groups, skip it
-          next if others.any? { |d| d.name == transitive_dependency.name }
-
-          # If the transitive dependency is included as a transitive dependency of a gem outside of the development
-          # group, skip it
-          next if others.any? { |d| d.to_spec&.dependencies&.include?(transitive_dependency) }
+          next if others.include?(transitive_dependency.name)
 
           excluded << transitive_dependency
         end