ruby-lsp 0.12.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd4c9d22a582587f5b28e38863009ac0375ebb66a743da42e823ba3a0ff28987
-  data.tar.gz: 90ff34eac484bc0af67529ce798d9b6a94def13a3989f1c94bb6bae67c190023
+  metadata.gz: 3f60569fbb67f1c78fcffed58dbf540cb4e68fe10200841e54cd8a68859cf0de
+  data.tar.gz: 07c4419c763e590e1fbed7fe14a2660c1bf6ddbd92ca791948a8c2235208f6e9
 SHA512:
-  metadata.gz: a67a91649a58fef931970abd81a1def32f2a8c58b1cbce454aa22f44d7ca944e2b787ec55025e8051922fd6a9a94edcc38ed332f9c1d0086ad840fc99003536b
-  data.tar.gz: 93b3584713f16f4655c2a075c008e66f263e0de449bebb6e1c440f4de8b3474366f69a69f511934883e38d5437c3b0c4d9817cc164bb943aabfced4134861aba
+  metadata.gz: 5284be197a27351a845cbcfc1735a0e9546472d60f9600ffd4ee55ba3ab0998438110c1ec59f684e0cf2fbaa7ff99f89878919ae3954022372e50116182c59dd
+  data.tar.gz: f706c17b0cd47c1001bffb42f6c9a1c43efbd390e548ffe7b51fb3c58bdb433c868a7f907a3aa32175d7742ccbb3c1c29606a0c7c979246bfe887500e6531676

data/VERSION

@@ -1 +1 @@
-0.12.0
+0.12.2

data/exe/ruby-lsp

@@ -25,6 +25,13 @@ parser = OptionParser.new do |opts|
     options[:branch] = branch
   end
 
+  opts.on(
+    "--experimental",
+    "Run pre-release versions of the Ruby LSP",
+  ) do
+    options[:experimental] = true
+  end
+
   opts.on("-h", "--help", "Print this help") do
     puts opts.help
     puts
@@ -49,7 +56,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
   require_relative "../lib/ruby_lsp/setup_bundler"
 
   begin
-    bundle_gemfile, bundle_path, bundle_app_config = RubyLsp::SetupBundler.new(Dir.pwd, branch: options[:branch]).setup!
+    bundle_gemfile, bundle_path, bundle_app_config = RubyLsp::SetupBundler.new(Dir.pwd, **options).setup!
   rescue RubyLsp::SetupBundler::BundleNotLocked
     warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
     exit(78)
@@ -78,7 +85,8 @@ rescue
   nil
 end
 
-require_relative "../lib/ruby_lsp/internal"
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "ruby_lsp/internal"
 
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)

data/exe/ruby-lsp-check

@@ -14,7 +14,8 @@ rescue
   nil
 end
 
-require_relative "../lib/ruby_lsp/internal"
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "ruby_lsp/internal"
 
 RubyLsp::Addon.load_addons
 

data/exe/ruby-lsp-doctor

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "bundler/setup"
-
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
 index = RubyIndexer::Index.new

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

@@ -0,0 +1,125 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop"
+require "sorbet-runtime"
+
+module RuboCop
+  module Cop
+    module RubyLsp
+      # Avoid using register without handler method, or handler without register.
+      #
+      # @example
+      # # Register without handler method.
+      #
+      # # bad
+      # class MyListener < Listener
+      #   def initialize(dispatcher)
+      #     super()
+      #     dispatcher.register(
+      #       self,
+      #       :on_string_node_enter,
+      #     )
+      #   end
+      # end
+      #
+      # # good
+      # class MyListener < Listener
+      #   def initialize(dispatcher)
+      #     super()
+      #     dispatcher.register(
+      #       self,
+      #       :on_string_node_enter,
+      #     )
+      #   end
+      #
+      #   def on_string_node_enter(node)
+      #   end
+      # end
+      #
+      # @example
+      # # Handler method without register.
+      #
+      # # bad
+      # class MyListener < Listener
+      #   def initialize(dispatcher)
+      #     super()
+      #     dispatcher.register(
+      #       self,
+      #     )
+      #   end
+      #
+      #   def on_string_node_enter(node)
+      #   end
+      # end
+      #
+      # # good
+      # class MyListener < Listener
+      #   def initialize(dispatcher)
+      #     super()
+      #     dispatcher.register(
+      #       self,
+      #       :on_string_node_enter,
+      #     )
+      #   end
+      #
+      #   def on_string_node_enter(node)
+      #   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."
+
+        def_node_search(
+          :find_all_listeners,
+          "(send
+            (_ :dispatcher) :register
+            (self)
+            $(sym _)+)",
+        )
+
+        def_node_search(
+          :find_all_handlers,
+          "$(def [_ #valid_event_name?] (args (arg _)) ...)",
+        )
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          listeners = find_all_listeners(processed_source.ast).flat_map { |listener| listener }
+          handlers = find_all_handlers(processed_source.ast).flat_map { |handler| handler }
+
+          add_offense_to_listeners_without_handler(listeners, handlers)
+          add_offense_handlers_without_listener(listeners, handlers)
+        end
+
+        private
+
+        sig { params(event_name: Symbol).returns(T::Boolean) }
+        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 }
+        def add_offense_to_listeners_without_handler(listeners, handlers)
+          return if listeners.none?
+
+          listeners
+            .filter { |node| handlers.map(&:method_name).none?(node.value) }
+            .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 }
+        def add_offense_handlers_without_listener(listeners, handlers)
+          return if handlers.none?
+
+          handlers
+            .filter { |node| listeners.map(&:value).none?(node.method_name) }
+            .each { |node| add_offense(node, message: format(MSG_MISSING_LISTENER, listener: node.method_name)) }
+        end
+      end
+    end
+  end
+end

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

@@ -67,8 +67,12 @@ module RubyIndexer
 
       # Add user specified patterns
       indexables = @included_patterns.flat_map do |pattern|
+        load_path_entry = T.let(nil, T.nilable(String))
+
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
-          load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_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 for the entire pattern
+          load_path_entry ||= $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
           IndexablePath.new(load_path_entry, path)
         end
       end
@@ -194,7 +198,11 @@ module RubyIndexer
       excluded.each do |dependency|
         next unless dependency.runtime?
 
-        dependency.to_spec.dependencies.each do |transitive_dependency|
+        # If the dependency is prerelease, to_spec may return `nil`
+        spec = dependency.to_spec
+        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 }
 

data/lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb

@@ -21,7 +21,7 @@ module RubyIndexer
     def initialize(load_path_entry, full_path)
       @full_path = full_path
       @require_path = T.let(
-        load_path_entry ? Pathname.new(full_path).relative_path_from(load_path_entry).to_s.delete_suffix(".rb") : nil,
+        load_path_entry ? full_path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb") : nil,
         T.nilable(String),
       )
     end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -12,12 +12,12 @@ require "ruby_indexer/lib/ruby_indexer/configuration"
 require "ruby_indexer/lib/ruby_indexer/prefix_tree"
 
 module RubyIndexer
+  @configuration = T.let(Configuration.new, Configuration)
+
   class << self
     extend T::Sig
 
     sig { returns(Configuration) }
-    def configuration
-      @configuration ||= T.let(Configuration.new, T.nilable(Configuration))
-    end
+    attr_reader :configuration
   end
 end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -24,7 +24,23 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
 
-      BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
+      BASE_COMMAND = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_lockfile }
+          "bundle exec ruby"
+        rescue Bundler::GemfileNotFound
+          "ruby"
+        end + " -Itest ",
+        String,
+      )
+      GEMFILE_NAME = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
+        rescue Bundler::GemfileNotFound
+          "Gemfile"
+        end,
+        String,
+      )
       ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
@@ -111,7 +127,7 @@ module RubyLsp
           return
         end
 
-        if @path&.include?("Gemfile") && name == :gem && arguments
+        if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
           first_argument = arguments.arguments.first
           return unless first_argument.is_a?(Prism::StringNode)
 

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -73,6 +73,8 @@ module RubyLsp
           :on_module_node_leave,
           :on_instance_variable_write_node_enter,
           :on_class_variable_write_node_enter,
+          :on_singleton_class_node_enter,
+          :on_singleton_class_node_leave,
         )
       end
 
@@ -103,6 +105,23 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
+        expression = node.expression
+
+        @stack << create_document_symbol(
+          name: "<< #{expression.slice}",
+          kind: Constant::SymbolKind::NAMESPACE,
+          range_location: node.location,
+          selection_range_location: expression.location,
+        )
+      end
+
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_leave(node)
+        @stack.pop
+      end
+
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         return unless ATTR_ACCESSORS.include?(node.name) && node.receiver.nil?
@@ -163,10 +182,14 @@ module RubyLsp
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         receiver = node.receiver
+        previous_symbol = @stack.last
 
         if receiver.is_a?(Prism::SelfNode)
           name = "self.#{node.name}"
-          kind = Constant::SymbolKind::METHOD
+          kind = Constant::SymbolKind::FUNCTION
+        elsif previous_symbol.is_a?(Interface::DocumentSymbol) && previous_symbol.name.start_with?("<<")
+          name = node.name.to_s
+          kind = Constant::SymbolKind::FUNCTION
         else
           name = node.name.to_s
           kind = name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -9,9 +9,9 @@ module RubyLsp
 
         RUBOCOP_TO_LSP_SEVERITY = T.let(
           {
-            convention: Constant::DiagnosticSeverity::INFORMATION,
-            info: Constant::DiagnosticSeverity::INFORMATION,
+            info: Constant::DiagnosticSeverity::HINT,
             refactor: Constant::DiagnosticSeverity::INFORMATION,
+            convention: Constant::DiagnosticSeverity::INFORMATION,
             warning: Constant::DiagnosticSeverity::WARNING,
             error: Constant::DiagnosticSeverity::ERROR,
             fatal: Constant::DiagnosticSeverity::ERROR,
@@ -19,12 +19,6 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
-        # Cache cops to attach URLs to diagnostics. Only built-in cops for now.
-        COP_TO_DOC_URL = T.let(
-          RuboCop::Cop::Registry.global.to_h,
-          T::Hash[String, [T.class_of(RuboCop::Cop::Base)]],
-        )
-
         sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(offense, uri)
           @offense = offense
@@ -53,16 +47,6 @@ module RubyLsp
 
         sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
-          severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
-          message  = @offense.message
-
-          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
-
-          cop = COP_TO_DOC_URL[@offense.cop_name]&.first
-          if cop&.documentation_url
-            code_description = { href: cop.documentation_url }
-          end
-
           Interface::Diagnostic.new(
             message: message,
             source: "RuboCop",
@@ -88,6 +72,24 @@ module RubyLsp
 
         private
 
+        sig { returns(String) }
+        def message
+          message  = @offense.message
+          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
+          message
+        end
+
+        sig { returns(T.nilable(Integer)) }
+        def severity
+          RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+        end
+
+        sig { returns(T.nilable(Interface::CodeDescription)) }
+        def code_description
+          doc_url = RuboCopRunner.find_cop_by_name(@offense.cop_name)&.documentation_url
+          Interface::CodeDescription.new(href: doc_url) if doc_url
+        end
+
         sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -101,6 +101,25 @@ module RubyLsp
           @options[:stdin]
         end
 
+        class << self
+          extend T::Sig
+
+          sig { params(cop_name: String).returns(T.nilable(T.class_of(RuboCop::Cop::Base))) }
+          def find_cop_by_name(cop_name)
+            cop_registry[cop_name]&.first
+          end
+
+          private
+
+          sig { returns(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]) }
+          def cop_registry
+            @cop_registry ||= T.let(
+              RuboCop::Cop::Registry.global.to_h,
+              T.nilable(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]),
+            )
+          end
+        end
+
         private
 
         sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }

data/lib/ruby_lsp/server.rb

@@ -58,7 +58,7 @@ module RubyLsp
 
     sig { void }
     def start
-      warn("Starting Ruby LSP...")
+      warn("Starting Ruby LSP v#{VERSION}...")
 
       # Requests that have to be executed sequentially or in the main process are implemented here. All other requests
       # fall under the else branch which just pushes requests to the queue

data/lib/ruby_lsp/setup_bundler.rb

@@ -20,17 +20,11 @@ module RubyLsp
 
     FOUR_HOURS = T.let(4 * 60 * 60, Integer)
 
-    sig { params(project_path: String, branch: T.nilable(String)).void }
-    def initialize(project_path, branch: nil)
+    sig { params(project_path: String, options: T.untyped).void }
+    def initialize(project_path, **options)
       @project_path = project_path
-      @branch = branch
-
-      # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
-      @custom_gemfile = T.let(@custom_dir + "Gemfile", Pathname)
-      @custom_lockfile = T.let(@custom_dir + "Gemfile.lock", Pathname)
-      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
-      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
+      @branch = T.let(options[:branch], T.nilable(String))
+      @experimental = T.let(options[:experimental], T.nilable(T::Boolean))
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -43,6 +37,15 @@ module RubyLsp
       )
       @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
 
+      @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
+
+      # Custom bundle paths
+      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
+      @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
+      @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
+      @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])
     end
 
@@ -118,7 +121,7 @@ module RubyLsp
       # If there's a top level Gemfile, we want to evaluate from the custom bundle. We get the source from the top level
       # Gemfile, so if there isn't one we need to add a default source
       if @gemfile&.exist?
-        parts << "eval_gemfile(File.expand_path(\"../Gemfile\", __dir__))"
+        parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
       else
         parts.unshift('source "https://rubygems.org"')
       end
@@ -188,7 +191,9 @@ module RubyLsp
         command.prepend("(")
         command << " && bundle update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
-        command << "debug" unless @dependencies["debug"]
+        command << "debug " unless @dependencies["debug"]
+        command << "--pre" if @experimental
+        command.delete_suffix!(" ")
         command << ")"
 
         @last_updated_path.write(Time.now.iso8601)
@@ -202,6 +207,7 @@ module RubyLsp
 
       # Add bundle update
       warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
+      warn("Ruby LSP> Command: #{command}")
       system(env, command)
       [bundle_gemfile.to_s, expanded_path, env["BUNDLE_APP_CONFIG"]]
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-18 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -76,6 +76,7 @@ files:
 - exe/ruby-lsp-doctor
 - lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
+- lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb