ruby-lsp 0.11.2 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 836f512695d45c2b360a2a6533185bd489a7d1c45eda21c0e67a2602cff23712
-  data.tar.gz: bdf8fdeefffbb7620ba60cdd91e7e73d7ee9121c5bd810f3456fd46835f5bf5e
+  metadata.gz: 2774623b2161a416bfb07769e8eb5ccf3d40177f98edf9e4d4ed4c7e3f7fd47b
+  data.tar.gz: 23626aa84fdaf85571c7d039d670f9131409ccb7a8cd2c61d4889ffd08ecb8de
 SHA512:
-  metadata.gz: 4be56dc36e58719d4ccdaea4b720507f21178b0fcfbbc9f634374dd808c33f46872c1cb25dc427f25f007d9b9b1333404c5724e8bbf8bab71ff1a3700c9a766d
-  data.tar.gz: 6afc266ad6ae954492d9603e456ba1f65ed00ec6fdc31984b1c42c6597867224d2a230ad165ee2c18afc39d7e5e6eb0f88fc2f4f53e09a724ef67cd4e87e53b2
+  metadata.gz: ffd099ba6d95ce10cd3fd2c3fb1e431d5481e0e8bad77c062fdd9b2f9fce534f9c58319672e508d17ca089e10ba9fdf398479dd9dfac3adbc347912815800cdd
+  data.tar.gz: fb0f4c3111718c5f792266459e2694787ea7939b63c819707bba764395dc6cc3bf1d925517a1fa412b362fbd0b3222e8460723df4f2c3a4272ac73dc62eb872a

data/VERSION

@@ -1 +1 @@
-0.11.2
+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 = 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)
@@ -57,6 +64,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
 
   env = { "BUNDLE_GEMFILE" => bundle_gemfile }
   env["BUNDLE_PATH"] = bundle_path if bundle_path
+  env["BUNDLE_APP_CONFIG"] = bundle_app_config if bundle_app_config
   exit exec(env, "bundle exec ruby-lsp #{original_args.join(" ")}")
 end
 
@@ -77,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

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "ruby_lsp/internal"
+
+index = RubyIndexer::Index.new
+
+RubyIndexer.configuration.indexables.each do |indexable|
+  puts "indexing: #{indexable.full_path}"
+  content = File.read(indexable.full_path)
+  result = Prism.parse(content)
+  visitor = RubyIndexer::IndexVisitor.new(index, result, indexable.full_path)
+  result.value.accept(visitor)
+end

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
@@ -98,6 +102,10 @@ module RubyIndexer
         next if locked_gems&.any? do |locked_spec|
           locked_spec.name == short_name &&
             !Gem::Specification.find_by_name(short_name).full_gem_path.start_with?(RbConfig::CONFIG["rubylibprefix"])
+        rescue Gem::MissingSpecError
+          # If a default gem is scoped to a specific platform, then `find_by_name` will raise. We want to skip those
+          # cases
+          true
         end
 
         if pathname.directory?
@@ -142,7 +150,7 @@ module RubyIndexer
 
     sig { returns(Regexp) }
     def magic_comment_regex
-      @magic_comment_regex ||= T.let(/^\s*#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
+      @magic_comment_regex ||= T.let(/^#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
     end
 
     private

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -0,0 +1,205 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Entry
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { returns(String) }
+    attr_reader :file_path
+
+    sig { returns(Prism::Location) }
+    attr_reader :location
+
+    sig { returns(T::Array[String]) }
+    attr_reader :comments
+
+    sig { returns(Symbol) }
+    attr_accessor :visibility
+
+    sig { params(name: String, file_path: String, location: Prism::Location, comments: T::Array[String]).void }
+    def initialize(name, file_path, location, comments)
+      @name = name
+      @file_path = file_path
+      @location = location
+      @comments = comments
+      @visibility = T.let(:public, Symbol)
+    end
+
+    sig { returns(String) }
+    def file_name
+      File.basename(@file_path)
+    end
+
+    class Namespace < Entry
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      def short_name
+        T.must(@name.split("::").last)
+      end
+    end
+
+    class Module < Namespace
+    end
+
+    class Class < Namespace
+      extend T::Sig
+
+      # The unresolved name of the parent class. This may return `nil`, which indicates the lack of an explicit parent
+      # and therefore ::Object is the correct parent class
+      sig { returns(T.nilable(String)) }
+      attr_reader :parent_class
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+          parent_class: T.nilable(String),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, parent_class)
+        super(name, file_path, location, comments)
+        @parent_class = T.let(parent_class, T.nilable(String))
+      end
+    end
+
+    class Constant < Entry
+    end
+
+    class Parameter
+      extend T::Helpers
+      extend T::Sig
+
+      abstract!
+
+      sig { returns(Symbol) }
+      attr_reader :name
+
+      sig { params(name: Symbol).void }
+      def initialize(name:)
+        @name = name
+      end
+    end
+
+    class RequiredParameter < Parameter
+    end
+
+    class Method < Entry
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig { returns(T::Array[Parameter]) }
+      attr_reader :parameters
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+          parameters_node: T.nilable(Prism::ParametersNode),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, parameters_node)
+        super(name, file_path, location, comments)
+        @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
+      end
+
+      private
+
+      sig { params(parameters_node: T.nilable(Prism::ParametersNode)).returns(T::Array[Parameter]) }
+      def list_params(parameters_node)
+        return [] unless parameters_node
+
+        parameters_node.requireds.filter_map do |required|
+          name = parameter_name(required)
+          next unless name
+
+          RequiredParameter.new(name: name)
+        end
+      end
+
+      sig do
+        params(node: Prism::Node).returns(T.nilable(Symbol))
+      end
+      def parameter_name(node)
+        case node
+        when Prism::RequiredParameterNode
+          node.name
+        when Prism::RequiredDestructuredParameterNode
+          names = node.parameters.map { |parameter_node| parameter_name(parameter_node) }
+          names_with_commas = names.join(", ")
+          :"(#{names_with_commas})"
+        end
+      end
+    end
+
+    class SingletonMethod < Method
+    end
+
+    class InstanceMethod < Method
+    end
+
+    # An UnresolvedAlias points to a constant alias with a right hand side that has not yet been resolved. For
+    # example, if we find
+    #
+    # ```ruby
+    #   CONST = Foo
+    # ```
+    # Before we have discovered `Foo`, there's no way to eagerly resolve this alias to the correct target constant.
+    # All aliases are inserted as UnresolvedAlias in the index first and then we lazily resolve them to the correct
+    # target in [rdoc-ref:Index#resolve]. If the right hand side contains a constant that doesn't exist, then it's not
+    # possible to resolve the alias and it will remain an UnresolvedAlias until the right hand side constant exists
+    class UnresolvedAlias < Entry
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :target
+
+      sig { returns(T::Array[String]) }
+      attr_reader :nesting
+
+      sig do
+        params(
+          target: String,
+          nesting: T::Array[String],
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+        ).void
+      end
+      def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments)
+
+        @target = target
+        @nesting = nesting
+      end
+    end
+
+    # Alias represents a resolved alias, which points to an existing constant target
+    class Alias < Entry
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :target
+
+      sig { params(target: String, unresolved_alias: UnresolvedAlias).void }
+      def initialize(target, unresolved_alias)
+        super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
+
+        @target = target
+      end
+    end
+  end
+end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -95,7 +95,7 @@ module RubyIndexer
     # ```
     sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
     def prefix_search(query, nesting)
-      results = (nesting.length + 1).downto(0).flat_map do |i|
+      results = nesting.length.downto(0).flat_map do |i|
         prefix = T.must(nesting[0...i]).join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
         @entries_tree.search(namespaced_query)
@@ -153,15 +153,33 @@ module RubyIndexer
       nil
     end
 
-    sig { params(indexable_paths: T::Array[IndexablePath]).void }
-    def index_all(indexable_paths: RubyIndexer.configuration.indexables)
-      indexable_paths.each { |path| index_single(path) }
+    # Index all files for the given indexable paths, which defaults to what is configured. A block can be used to track
+    # and control indexing progress. That block is invoked with the current progress percentage and should return `true`
+    # to continue indexing or `false` to stop indexing.
+    sig do
+      params(
+        indexable_paths: T::Array[IndexablePath],
+        block: T.nilable(T.proc.params(progress: Integer).returns(T::Boolean)),
+      ).void
+    end
+    def index_all(indexable_paths: RubyIndexer.configuration.indexables, &block)
+      # Calculate how many paths are worth 1% of progress
+      progress_step = (indexable_paths.length / 100.0).ceil
+
+      indexable_paths.each_with_index do |path, index|
+        if block && index % progress_step == 0
+          progress = (index / progress_step) + 1
+          break unless block.call(progress)
+        end
+
+        index_single(path)
+      end
     end
 
     sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
-      result = YARP.parse(content)
+      result = Prism.parse(content)
       visitor = IndexVisitor.new(self, result, indexable_path.full_path)
       result.value.accept(visitor)
 
@@ -234,106 +252,5 @@ module RubyIndexer
 
       resolved_alias
     end
-
-    class Entry
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { returns(String) }
-      attr_reader :file_path
-
-      sig { returns(YARP::Location) }
-      attr_reader :location
-
-      sig { returns(T::Array[String]) }
-      attr_reader :comments
-
-      sig { returns(Symbol) }
-      attr_accessor :visibility
-
-      sig { params(name: String, file_path: String, location: YARP::Location, comments: T::Array[String]).void }
-      def initialize(name, file_path, location, comments)
-        @name = name
-        @file_path = file_path
-        @location = location
-        @comments = comments
-        @visibility = T.let(:public, Symbol)
-      end
-
-      sig { returns(String) }
-      def file_name
-        File.basename(@file_path)
-      end
-
-      class Namespace < Entry
-        sig { returns(String) }
-        def short_name
-          T.must(@name.split("::").last)
-        end
-      end
-
-      class Module < Namespace
-      end
-
-      class Class < Namespace
-      end
-
-      class Constant < Entry
-      end
-
-      # An UnresolvedAlias points to a constant alias with a right hand side that has not yet been resolved. For
-      # example, if we find
-      #
-      # ```ruby
-      #   CONST = Foo
-      # ```
-      # Before we have discovered `Foo`, there's no way to eagerly resolve this alias to the correct target constant.
-      # All aliases are inserted as UnresolvedAlias in the index first and then we lazily resolve them to the correct
-      # target in [rdoc-ref:Index#resolve]. If the right hand side contains a constant that doesn't exist, then it's not
-      # possible to resolve the alias and it will remain an UnresolvedAlias until the right hand side constant exists
-      class UnresolvedAlias < Entry
-        extend T::Sig
-
-        sig { returns(String) }
-        attr_reader :target
-
-        sig { returns(T::Array[String]) }
-        attr_reader :nesting
-
-        sig do
-          params(
-            target: String,
-            nesting: T::Array[String],
-            name: String,
-            file_path: String,
-            location: YARP::Location,
-            comments: T::Array[String],
-          ).void
-        end
-        def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
-          super(name, file_path, location, comments)
-
-          @target = target
-          @nesting = nesting
-        end
-      end
-
-      # Alias represents a resolved alias, which points to an existing constant target
-      class Alias < Entry
-        extend T::Sig
-
-        sig { returns(String) }
-        attr_reader :target
-
-        sig { params(target: String, unresolved_alias: UnresolvedAlias).void }
-        def initialize(target, unresolved_alias)
-          super(unresolved_alias.name, unresolved_alias.file_path, unresolved_alias.location, unresolved_alias.comments)
-
-          @target = target
-        end
-      end
-    end
   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/lib/ruby_indexer/prefix_tree.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 module RubyIndexer
@@ -133,16 +133,16 @@ module RubyIndexer
         @key = key
         @value = value
         @parent = parent
-        @children = T.let({}, T::Hash[String, Node[Value]])
-        @leaf = T.let(false, T::Boolean)
+        @children = {}
+        @leaf = false
       end
 
       sig { returns(T::Array[Value]) }
       def collect
-        result = T.let([], T::Array[Value])
-        result << value if leaf
+        result = []
+        result << @value if @leaf
 
-        children.each_value do |node|
+        @children.each_value do |node|
           result.concat(node.collect)
         end