ruby-lsp 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2708af5c4c174d0fafe710fb1f7aaeed7e1aee45cb7aad49f16a53d9f32ad03
-  data.tar.gz: eaab5153e4c99eac231bf7376ef368fec589e1d6fe05807c9a4de45394242e42
+  metadata.gz: dd4c9d22a582587f5b28e38863009ac0375ebb66a743da42e823ba3a0ff28987
+  data.tar.gz: 90ff34eac484bc0af67529ce798d9b6a94def13a3989f1c94bb6bae67c190023
 SHA512:
-  metadata.gz: ca5c0ba2801350c6557c31b90626a07a4e358245d2177b65a9670f00d2521d0d9850fc488dd65124a58cbc841a09c656d91595cf436391f80e87a434021e822b
-  data.tar.gz: c8cf7c3228b62639d5b8eb3e3b61750237e85bc43837424359bb54b5d794bea37f0b7214ea6229bfb365c189445d48069dae166e8ad91a0b774bbe34fd269473
+  metadata.gz: a67a91649a58fef931970abd81a1def32f2a8c58b1cbce454aa22f44d7ca944e2b787ec55025e8051922fd6a9a94edcc38ed332f9c1d0086ad840fc99003536b
+  data.tar.gz: 93b3584713f16f4655c2a075c008e66f263e0de449bebb6e1c440f4de8b3474366f69a69f511934883e38d5437c3b0c4d9817cc164bb943aabfced4134861aba

data/VERSION

@@ -1 +1 @@
-0.11.1
+0.12.0

data/exe/ruby-lsp

@@ -49,7 +49,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, branch: options[:branch]).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 +57,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
 

data/exe/ruby-lsp-doctor

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+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/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -98,6 +98,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 +146,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)
@@ -130,7 +130,7 @@ module RubyIndexer
       if name.start_with?("::")
         name = name.delete_prefix("::")
         results = @entries[name] || @entries[follow_aliased_namespace(name)]
-        return results.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if results
+        return results&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e }
       end
 
       nesting.length.downto(0).each do |i|
@@ -153,16 +153,35 @@ 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)
-      visitor = IndexVisitor.new(self, YARP.parse(content), indexable_path.full_path)
-      visitor.run
+      result = Prism.parse(content)
+      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
+      result.value.accept(visitor)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
@@ -182,6 +201,8 @@ module RubyIndexer
     # aliases, so we have to invoke `follow_aliased_namespace` again to check until we only return a real name
     sig { params(name: String).returns(String) }
     def follow_aliased_namespace(name)
+      return name if @entries[name]
+
       parts = name.split("::")
       real_parts = []
 
@@ -231,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/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