ruby-lsp 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd4c9d22a582587f5b28e38863009ac0375ebb66a743da42e823ba3a0ff28987
-  data.tar.gz: 90ff34eac484bc0af67529ce798d9b6a94def13a3989f1c94bb6bae67c190023
+  metadata.gz: 2774623b2161a416bfb07769e8eb5ccf3d40177f98edf9e4d4ed4c7e3f7fd47b
+  data.tar.gz: 23626aa84fdaf85571c7d039d670f9131409ccb7a8cd2c61d4889ffd08ecb8de
 SHA512:
-  metadata.gz: a67a91649a58fef931970abd81a1def32f2a8c58b1cbce454aa22f44d7ca944e2b787ec55025e8051922fd6a9a94edcc38ed332f9c1d0086ad840fc99003536b
-  data.tar.gz: 93b3584713f16f4655c2a075c008e66f263e0de449bebb6e1c440f4de8b3474366f69a69f511934883e38d5437c3b0c4d9817cc164bb943aabfced4134861aba
+  metadata.gz: ffd099ba6d95ce10cd3fd2c3fb1e431d5481e0e8bad77c062fdd9b2f9fce534f9c58319672e508d17ca089e10ba9fdf398479dd9dfac3adbc347912815800cdd
+  data.tar.gz: fb0f4c3111718c5f792266459e2694787ea7939b63c819707bba764395dc6cc3bf1d925517a1fa412b362fbd0b3222e8460723df4f2c3a4272ac73dc62eb872a

data/VERSION

@@ -1 +1 @@
-0.12.0
+0.12.1

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

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/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/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.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-18 00:00:00.000000000 Z
+date: 2023-10-26 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