ruby-lsp 0.23.11 → 0.23.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b93894c0d2c2687def87d9e173c7a9e45e810088613cb902c2a4b1a9d93a8404
-  data.tar.gz: 9e92f360c8367cde864ac1a5dd2305170a975fa3164e6fc2c1d6f492396fbbc5
+  metadata.gz: e224f23084eccd6f7b441b6cf6ae2793fb9c73a0045bf36f8c1bbdf2b1f00445
+  data.tar.gz: 581749c8bd2ab362075e49940d364af6a237068e6107d340a2535043d7fdec37
 SHA512:
-  metadata.gz: fc2172fba1c50192cb86d2dfc619c633cf756f3ebb574caaaeabb81fe23d283b7b896f48fe23981d29c472fce98248137171d119b33c75d1a7f6fafc73c7a775
-  data.tar.gz: 03b0b5987fc8dcc6c989ce6c5df55e16fff906836ef74aa993ddc445b50c5d3458775fee1a31b9e228710df44f80b8338390ef1fdf75d464deac4e38fe822644
+  metadata.gz: a5d7cb45c56ad5e9e92cba7a0012be7a1626044da4fbc936c413b7a8e5cb3cdd4463bf56dd35ef65feed10f0de363edd04702a4496572248e6e74ea9f720a373
+  data.tar.gz: 53639a355c1641e8b11d4e756a417ea9ee96421cb5a87090ffc94cd8f905d41ca3fa5111e4171a81fa62b452c23088895deca0e7eb52fd2e8fed82e1232d2d06

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.23.13

data/exe/ruby-lsp-launcher

@@ -83,19 +83,20 @@ begin
     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...")
+    exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *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__))

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

@@ -29,7 +29,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

@@ -63,8 +63,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 +91,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 +105,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|
+      uris = @included_patterns.flat_map do |pattern|
         load_path_entry = T.let(nil, T.nilable(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 = T.must(indexable.full_path)
+        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