ruby-lsp 0.23.11 → 0.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b93894c0d2c2687def87d9e173c7a9e45e810088613cb902c2a4b1a9d93a8404
-  data.tar.gz: 9e92f360c8367cde864ac1a5dd2305170a975fa3164e6fc2c1d6f492396fbbc5
+  metadata.gz: c80f549675508ffbb28d649de04506adabec01eac9aa4c6eee057ec848adf858
+  data.tar.gz: 71ea1a4d628444b98bc1173748f5aecf0d71bdc8d3dc80f33b2779c9c78d9de0
 SHA512:
-  metadata.gz: fc2172fba1c50192cb86d2dfc619c633cf756f3ebb574caaaeabb81fe23d283b7b896f48fe23981d29c472fce98248137171d119b33c75d1a7f6fafc73c7a775
-  data.tar.gz: 03b0b5987fc8dcc6c989ce6c5df55e16fff906836ef74aa993ddc445b50c5d3458775fee1a31b9e228710df44f80b8338390ef1fdf75d464deac4e38fe822644
+  metadata.gz: 7261bf15c095154ff36152492aa252cbd84b84f6e83eb458623c7bb9790a57957885a855c2ee10683b7035267177e323c013988befc02e96f3fdf0274d2312ca
+  data.tar.gz: 74bcea4844e876230713400776bf7def1db44492bcf913526195b5d01919efd24ac69b517594ce2499e332184bf7ef4881e17e7694574bf4d35afabeda25b8c4

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-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://shopify.github.io/ruby-lsp/invite)
 
 # 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-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA).
+[Ruby DX Slack workspace](https://shopify.github.io/ruby-lsp/invite).
 
 ## Getting Started
 

data/VERSION

@@ -1 +1 @@
-0.23.11
+0.26.1

data/exe/ruby-lsp

@@ -88,13 +88,17 @@ if ENV["BUNDLE_GEMFILE"].nil?
   exit exec(env, "#{base_command} exec ruby-lsp #{original_args.join(" ")}".strip)
 end
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -147,8 +151,10 @@ if options[:doctor]
   return
 end
 
+server = RubyLsp::Server.new
+
 # Ensure all output goes out stderr by default to allow puts/p/pp to work
 # without specifying output device.
 $> = $stderr
 
-RubyLsp::Server.new.start
+server.start

data/exe/ruby-lsp-check

@@ -3,13 +3,9 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "ruby_lsp/load_sorbet"
-
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
 
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."

data/exe/ruby-lsp-launcher

@@ -6,22 +6,35 @@
 # composed bundle
 # !!!!!!!
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 setup_error = nil
 install_error = nil
 reboot = false
 
 workspace_uri = ARGV.first
+raw_initialize_path = File.join(".ruby-lsp", "raw_initialize")
 
 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}\"}]}}"
+elsif ARGV.include?("--retry")
+  # If we're trying to re-boot automatically, we can't try to read the same initialize request again from the pipe. We
+  # need to ensure that the retry mechanism always writes the request to a file, so that we can reuse it
+  content = File.read(raw_initialize_path)
+  File.delete(raw_initialize_path)
+  content
 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)
@@ -76,26 +89,33 @@ begin
     # 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))
+    install_error = begin
+      Marshal.load(File.read(error_path)) if File.exist?(error_path)
+    rescue ArgumentError
+      # The class we tried to load is not defined. This might happen when the user upgrades Bundler and new error
+      # classes are introduced or removed
+      File.delete(error_path)
+      nil
     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.
-  #
-  # 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}")
+rescue Bundler::GemNotFound, Bundler::GitError
+  # Sometimes, we successfully set up the bundle, but users either change their Gemfile or uninstall gems from an
+  # external process. If there's no install error, but the gem is still not found, then we need to attempt to start from
+  # scratch
+  unless install_error || ARGV.include?("--retry")
+    $stderr.puts("Initial bundle compose succeeded, but Bundler.setup failed. Trying to restart from scratch...")
+    File.write(raw_initialize_path, raw_initialize)
+    exec(Gem.ruby, __FILE__, *ARGV, "--retry")
   end
 
+  $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+rescue StandardError => e
+  setup_error = e
+  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
+
   # 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__))
@@ -111,11 +131,8 @@ end
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if ARGV.include?("--debug")
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -129,22 +146,28 @@ if ARGV.include?("--debug")
   end
 end
 
-# Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
-$> = $stderr
-
 initialize_request = JSON.parse(raw_initialize, symbolize_names: true) if raw_initialize
 
 begin
-  RubyLsp::Server.new(
+  server = RubyLsp::Server.new(
     install_error: install_error,
     setup_error: setup_error,
     initialize_request: initialize_request,
-  ).start
+  )
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
+  server.start
 rescue ArgumentError
   # If the launcher is booting an outdated version of the server, then the initializer doesn't accept a keyword splat
   # and we already read the initialize request from the stdin pipe. In this case, we need to process the initialize
   # request manually and then start the main loop
   server = RubyLsp::Server.new
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
   server.process_message(initialize_request)
   server.start
 end

data/exe/ruby-lsp-test-exec

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This executable will be removed thanks to the changes in https://github.com/Shopify/ruby-lsp/pull/3661.
+# Remove this a few months after extension updates have rolled out
+exec(*ARGV)

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop
@@ -29,7 +28,7 @@ module RuboCop
       class UseLanguageServerAliases < RuboCop::Cop::Base
         extend RuboCop::Cop::AutoCorrector
 
-        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+        ALIASED_CONSTANTS = [:Interface, :Transport, :Constant].freeze #: Array[Symbol]
 
         MSG = "Use constant alias `%{constant}`."
 

data/lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop
@@ -63,8 +62,6 @@ module RuboCop
       #   end
       # end
       class UseRegisterWithHandlerMethod < RuboCop::Cop::Base
-        extend T::Sig
-
         MSG_MISSING_HANDLER = "Registered to `%{listener}` without a handler defined."
         MSG_MISSING_LISTENER = "Created a handler without registering the associated `%{listener}` event."
 
@@ -93,12 +90,12 @@ module RuboCop
 
         private
 
-        sig { params(event_name: Symbol).returns(T::Boolean) }
+        #: (Symbol event_name) -> bool
         def valid_event_name?(event_name)
           /^on_.*(node_enter|node_leave)$/.match?(event_name)
         end
 
-        sig { params(listeners: T::Array[RuboCop::AST::SymbolNode], handlers: T::Array[RuboCop::AST::DefNode]).void }
+        #: (Array[RuboCop::AST::SymbolNode] listeners, Array[RuboCop::AST::DefNode] handlers) -> void
         def add_offense_to_listeners_without_handler(listeners, handlers)
           return if listeners.none?
 
@@ -107,7 +104,7 @@ module RuboCop
             .each { |node| add_offense(node, message: format(MSG_MISSING_HANDLER, listener: node.value)) }
         end
 
-        sig { params(listeners: T::Array[RuboCop::AST::SymbolNode], handlers: T::Array[RuboCop::AST::DefNode]).void }
+        #: (Array[RuboCop::AST::SymbolNode] listeners, Array[RuboCop::AST::DefNode] handlers) -> void
         def add_offense_handlers_without_listener(listeners, handlers)
           return if handlers.none?
 

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

@@ -3,85 +3,59 @@
 
 module RubyIndexer
   class Configuration
-    extend T::Sig
-
-    CONFIGURATION_SCHEMA = T.let(
-      {
-        "excluded_gems" => Array,
-        "included_gems" => Array,
-        "excluded_patterns" => Array,
-        "included_patterns" => Array,
-        "excluded_magic_comments" => Array,
-      }.freeze,
-      T::Hash[String, T.untyped],
-    )
-
-    sig { params(workspace_path: String).void }
+    CONFIGURATION_SCHEMA = {
+      "excluded_gems" => Array,
+      "included_gems" => Array,
+      "excluded_patterns" => Array,
+      "included_patterns" => Array,
+      "excluded_magic_comments" => Array,
+    }.freeze #: Hash[String, untyped]
+
+    #: String
     attr_writer :workspace_path
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_accessor :encoding
 
-    sig { void }
+    #: -> void
     def initialize
-      @workspace_path = T.let(Dir.pwd, String)
-      @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("node_modules", "**", "*"),
-          File.join("spec", "**", "*"),
-          File.join("test", "**", "*"),
-          File.join("tmp", "**", "*"),
-        ],
-        T::Array[String],
-      )
+      @workspace_path = Dir.pwd #: String
+      @encoding = Encoding::UTF_8 #: Encoding
+      @excluded_gems = initial_excluded_gems #: Array[String]
+      @included_gems = [] #: Array[String]
+
+      @excluded_patterns = [
+        "**/{test,spec}/**/{*_test.rb,test_*.rb,*_spec.rb}",
+        "**/fixtures/**/*",
+      ] #: Array[String]
 
       path = Bundler.settings["path"]
       if path
         # Substitute Windows backslashes into forward slashes, which are used in glob patterns
         glob = path.gsub(/[\\]+/, "/")
-        @excluded_patterns << File.join(glob, "**", "*.rb")
+        glob.delete_suffix!("/")
+        @excluded_patterns << "#{glob}/**/*.rb"
       end
 
-      @included_patterns = T.let([File.join("**", "*.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 { 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(",")}}/**/*") }
+      # We start the included patterns with only the non excluded directories so that we can avoid paying the price of
+      # traversing large directories that don't include Ruby files like `node_modules`
+      @included_patterns = ["{#{top_level_directories.join(",")}}/**/*.rb", "*.rb"] #: Array[String]
+      @excluded_magic_comments = [
+        "frozen_string_literal:",
+        "typed:",
+        "compiled:",
+        "encoding:",
+        "shareable_constant_value:",
+        "warn_indent:",
+        "rubocop:",
+        "nodoc:",
+        "doc:",
+        "coding:",
+        "warn_past_scope:",
+      ] #: Array[String]
     end
 
-    sig { returns(T::Array[URI::Generic]) }
+    #: -> Array[URI::Generic]
     def indexable_uris
       excluded_gems = @excluded_gems - @included_gems
       locked_gems = Bundler.locked_gems&.specs
@@ -91,51 +65,19 @@ module RubyIndexer
 
       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
-
-      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|
-        uris << URI::Generic.from_path(path: path)
-      end
-
-      # Add user specified patterns
-      @included_patterns.each do |pattern|
-        load_path_entry = T.let(nil, T.nilable(String))
+      uris = @included_patterns.flat_map do |pattern|
+        load_path_entry = nil #: String?
 
-        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)
-
-          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
-
-            uris << URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
+        Dir.glob(File.join(@workspace_path, pattern), flags).map! do |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
+
+          URI::Generic.from_path(path: path, load_path_entry: load_path_entry)
         end
       end
 
@@ -150,10 +92,12 @@ module RubyIndexer
       end
 
       # Remove user specified patterns
+      bundle_path = Bundler.settings["path"]&.gsub(/[\\]+/, "/")
       uris.reject! do |indexable|
-        excluded_patterns.any? do |pattern|
-          File.fnmatch?(pattern, T.must(indexable.full_path), File::FNM_PATHNAME | File::FNM_EXTGLOB)
-        end
+        path = indexable.full_path #: as !nil
+        next false if test_files_ignored_from_exclusion?(path, bundle_path)
+
+        excluded_patterns.any? { |pattern| File.fnmatch?(pattern, path, flags) }
       end
 
       # Add default gems to the list of files to be indexed
@@ -222,12 +166,12 @@ module RubyIndexer
       uris
     end
 
-    sig { returns(Regexp) }
+    #: -> Regexp
     def magic_comment_regex
-      @magic_comment_regex ||= T.let(/^#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
+      @magic_comment_regex ||= /^#\s*#{@excluded_magic_comments.join("|")}/ #: Regexp?
     end
 
-    sig { params(config: T::Hash[String, T.untyped]).void }
+    #: (Hash[String, untyped] config) -> void
     def apply_config(config)
       validate_config!(config)
 
@@ -240,7 +184,7 @@ module RubyIndexer
 
     private
 
-    sig { params(config: T::Hash[String, T.untyped]).void }
+    #: (Hash[String, untyped] config) -> void
     def validate_config!(config)
       errors = config.filter_map do |key, value|
         type = CONFIGURATION_SCHEMA[key]
@@ -255,7 +199,7 @@ module RubyIndexer
       raise ArgumentError, errors.join("\n") if errors.any?
     end
 
-    sig { returns(T::Array[String]) }
+    #: -> Array[String]
     def initial_excluded_gems
       excluded, others = Bundler.definition.dependencies.partition do |dependency|
         dependency.groups == [:development]
@@ -305,5 +249,27 @@ module RubyIndexer
     rescue Bundler::GemfileNotFound
       []
     end
+
+    # Checks if the test file is never supposed to be ignored from indexing despite matching exclusion patterns, like
+    # `test_helper.rb` or `test_case.rb`. Also takes into consideration the possibility of finding these files under
+    # fixtures or inside gem source code if the bundle path points to a directory inside the workspace
+    #: (String path, String? bundle_path) -> bool
+    def test_files_ignored_from_exclusion?(path, bundle_path)
+      ["test_case.rb", "test_helper.rb"].include?(File.basename(path)) &&
+        !File.fnmatch?("**/fixtures/**/*", path, File::FNM_PATHNAME | File::FNM_EXTGLOB) &&
+        (!bundle_path || !path.start_with?(bundle_path))
+    end
+
+    #: -> Array[String]
+    def top_level_directories
+      excluded_directories = ["tmp", "node_modules", "sorbet"]
+
+      Dir.glob("#{Dir.pwd}/*").filter_map do |path|
+        dir_name = File.basename(path)
+        next unless File.directory?(path) && !excluded_directories.include?(dir_name)
+
+        dir_name
+      end
+    end
   end
 end