ruby-lsp 0.13.1 → 0.13.3

data/lib/ruby_lsp/listener.rb

@@ -16,6 +16,7 @@ module RubyLsp
 
     sig { params(dispatcher: Prism::Dispatcher).void }
     def initialize(dispatcher)
+      super()
       @dispatcher = dispatcher
     end
 
@@ -29,54 +30,4 @@ module RubyLsp
     sig { abstract.returns(ResponseType) }
     def _response; end
   end
-
-  # ExtensibleListener is an abstract class to be used by requests that accept addons.
-  class ExtensibleListener < Listener
-    extend T::Sig
-    extend T::Generic
-
-    ResponseType = type_member
-
-    abstract!
-
-    # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
-    # ivars have been initialized. This is because the constructor of ExtensibleListener calls
-    # `initialize_external_listener` which may depend on the subclass's ivars.
-    sig { params(dispatcher: Prism::Dispatcher).void }
-    def initialize(dispatcher)
-      super
-      @response_merged = T.let(false, T::Boolean)
-      @external_listeners = T.let(
-        Addon.addons.filter_map do |ext|
-          initialize_external_listener(ext)
-        end,
-        T::Array[RubyLsp::Listener[ResponseType]],
-      )
-    end
-
-    # Merge responses from all external listeners into the base listener's response. We do this to return a single
-    # response to the editor including the results of all addons
-    sig { void }
-    def merge_external_listeners_responses!
-      @external_listeners.each { |l| merge_response!(l) }
-    end
-
-    sig { returns(ResponseType) }
-    def response
-      merge_external_listeners_responses! unless @response_merged
-      super
-    end
-
-    sig do
-      abstract.params(addon: RubyLsp::Addon).returns(T.nilable(RubyLsp::Listener[ResponseType]))
-    end
-    def initialize_external_listener(addon); end
-
-    # Does nothing by default. Requests that accept addons should override this method to define how to merge responses
-    # coming from external listeners
-    sig { abstract.params(other: Listener[T.untyped]).returns(T.self_type) }
-    def merge_response!(other)
-    end
-  end
-  private_constant(:ExtensibleListener)
 end

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -0,0 +1,233 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../listener"
+
+module RubyLsp
+  module Listeners
+    class CodeLens < Listener
+      extend T::Sig
+      extend T::Generic
+
+      BASE_COMMAND = T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_lockfile }
+          "bundle exec ruby"
+        rescue Bundler::GemfileNotFound
+          "ruby"
+        end + " -Itest ",
+        String,
+      )
+      ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
+      SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          uri: URI::Generic,
+          lenses_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(uri, lenses_configuration, dispatcher)
+        @uri = T.let(uri, URI::Generic)
+        @_response = T.let([], ResponseType)
+        @path = T.let(uri.to_standardized_path, T.nilable(String))
+        # visibility_stack is a stack of [current_visibility, previous_visibility]
+        @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
+        @class_stack = T.let([], T::Array[String])
+        @group_id = T.let(1, Integer)
+        @group_id_stack = T.let([], T::Array[Integer])
+        @lenses_configuration = lenses_configuration
+
+        super(dispatcher)
+
+        dispatcher.register(
+          self,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_def_node_enter,
+          :on_call_node_enter,
+          :on_call_node_leave,
+        )
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        @visibility_stack.push([:public, :public])
+        class_name = node.constant_path.slice
+        @class_stack.push(class_name)
+
+        if @path && class_name.end_with?("Test")
+          add_test_code_lens(
+            node,
+            name: class_name,
+            command: generate_test_command(class_name: class_name),
+            kind: :group,
+          )
+        end
+
+        @group_id_stack.push(@group_id)
+        @group_id += 1
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @class_stack.pop
+        @group_id_stack.pop
+      end
+
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
+        class_name = @class_stack.last
+        return unless class_name&.end_with?("Test")
+
+        visibility, _ = @visibility_stack.last
+        if visibility == :public
+          method_name = node.name.to_s
+          if @path && method_name.start_with?("test_")
+            add_test_code_lens(
+              node,
+              name: method_name,
+              command: generate_test_command(method_name: method_name, class_name: class_name),
+              kind: :example,
+            )
+          end
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        name = node.name
+        arguments = node.arguments
+
+        # If we found `private` by itself or `private def foo`
+        if ACCESS_MODIFIERS.include?(name)
+          if arguments.nil?
+            @visibility_stack.pop
+            @visibility_stack.push([name, name])
+          elsif arguments.arguments.first.is_a?(Prism::DefNode)
+            visibility, _ = @visibility_stack.pop
+            @visibility_stack.push([name, visibility])
+          end
+
+          return
+        end
+
+        if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
+          return unless @lenses_configuration.enabled?(:gemfileLinks)
+
+          first_argument = arguments.arguments.first
+          return unless first_argument.is_a?(Prism::StringNode)
+
+          remote = resolve_gem_remote(first_argument)
+          return unless remote
+
+          add_open_gem_remote_code_lens(node, remote)
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_leave(node)
+        _, prev_visibility = @visibility_stack.pop
+        @visibility_stack.push([prev_visibility, prev_visibility])
+      end
+
+      private
+
+      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
+      def add_test_code_lens(node, name:, command:, kind:)
+        # don't add code lenses if the test library is not supported or unknown
+        return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
+
+        arguments = [
+          @path,
+          name,
+          command,
+          {
+            start_line: node.location.start_line - 1,
+            start_column: node.location.start_column,
+            end_line: node.location.end_line - 1,
+            end_column: node.location.end_column,
+          },
+        ]
+
+        grouping_data = { group_id: @group_id_stack.last, kind: kind }
+        grouping_data[:id] = @group_id if kind == :group
+
+        @_response << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
+          arguments: arguments,
+          data: { type: "test", **grouping_data },
+        )
+
+        @_response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          arguments: arguments,
+          data: { type: "test_in_terminal", **grouping_data },
+        )
+
+        @_response << create_code_lens(
+          node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
+          arguments: arguments,
+          data: { type: "debug", **grouping_data },
+        )
+      end
+
+      sig { params(gem_name: Prism::StringNode).returns(T.nilable(String)) }
+      def resolve_gem_remote(gem_name)
+        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.content }&.to_spec
+        return if spec.nil?
+
+        [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|
+          page.start_with?("https://github.com", "https://gitlab.com")
+        end
+      end
+
+      sig { params(class_name: String, method_name: T.nilable(String)).returns(String) }
+      def generate_test_command(class_name:, method_name: nil)
+        command = BASE_COMMAND + T.must(@path)
+
+        case DependencyDetector.instance.detected_test_library
+        when "minitest"
+          command += if method_name
+            " --name " + "/#{Shellwords.escape(class_name + "#" + method_name)}/"
+          else
+            " --name " + "/#{Shellwords.escape(class_name)}/"
+          end
+        when "test-unit"
+          command += " --testcase " + "/#{Shellwords.escape(class_name)}/"
+
+          if method_name
+            command += " --name " + Shellwords.escape(method_name)
+          end
+        end
+
+        command
+      end
+
+      sig { params(node: Prism::CallNode, remote: String).void }
+      def add_open_gem_remote_code_lens(node, remote)
+        @_response << create_code_lens(
+          node,
+          title: "Open remote",
+          command_name: "rubyLsp.openLink",
+          arguments: [remote],
+          data: { type: "link" },
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/completion.rb

@@ -0,0 +1,275 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class Completion < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          index: RubyIndexer::Index,
+          nesting: T::Array[String],
+          typechecker_enabled: T::Boolean,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(index, nesting, typechecker_enabled, dispatcher)
+        super(dispatcher)
+        @_response = T.let([], ResponseType)
+        @index = index
+        @nesting = nesting
+        @typechecker_enabled = typechecker_enabled
+
+        dispatcher.register(
+          self,
+          :on_string_node_enter,
+          :on_constant_path_node_enter,
+          :on_constant_read_node_enter,
+          :on_call_node_enter,
+        )
+      end
+
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
+        @index.search_require_paths(node.content).map!(&:require_path).sort!.each do |path|
+          @_response << build_completion(T.must(path), node)
+        end
+      end
+
+      # Handle completion on regular constant references (e.g. `Bar`)
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+
+        name = node.slice
+        candidates = @index.prefix_search(name, @nesting)
+        candidates.each do |entries|
+          complete_name = T.must(entries.first).name
+          @_response << build_entry_completion(
+            complete_name,
+            name,
+            node,
+            entries,
+            top_level?(complete_name),
+          )
+        end
+      end
+
+      # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+
+        name = node.slice
+
+        top_level_reference = if name.start_with?("::")
+          name = name.delete_prefix("::")
+          true
+        else
+          false
+        end
+
+        # If we're trying to provide completion for an aliased namespace, we need to first discover it's real name in
+        # order to find which possible constants match the desired search
+        *namespace, incomplete_name = name.split("::")
+        aliased_namespace = T.must(namespace).join("::")
+        namespace_entries = @index.resolve(aliased_namespace, @nesting)
+        return unless namespace_entries
+
+        real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
+
+        candidates = @index.prefix_search("#{real_namespace}::#{incomplete_name}", top_level_reference ? [] : @nesting)
+        candidates.each do |entries|
+          # The only time we may have a private constant reference from outside of the namespace is if we're dealing
+          # with ConstantPath and the entry name doesn't start with the current nesting
+          first_entry = T.must(entries.first)
+          next if first_entry.visibility == :private && !first_entry.name.start_with?("#{@nesting}::")
+
+          constant_name = T.must(first_entry.name.split("::").last)
+
+          full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+
+          @_response << build_entry_completion(
+            full_name,
+            name,
+            node,
+            entries,
+            top_level_reference || top_level?(T.must(entries.first).name),
+          )
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if @typechecker_enabled
+        return unless self_receiver?(node)
+
+        name = node.message
+        return unless name
+
+        receiver_entries = @index[@nesting.join("::")]
+        return unless receiver_entries
+
+        receiver = T.must(receiver_entries.first)
+
+        @index.prefix_search(name).each do |entries|
+          entry = entries.find { |e| e.is_a?(RubyIndexer::Entry::Member) && e.owner&.name == receiver.name }
+          next unless entry
+
+          @_response << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          entry: RubyIndexer::Entry::Member,
+          node: Prism::CallNode,
+        ).returns(Interface::CompletionItem)
+      end
+      def build_method_completion(entry, node)
+        name = entry.name
+
+        Interface::CompletionItem.new(
+          label: name,
+          filter_text: name,
+          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: name),
+          kind: Constant::CompletionItemKind::METHOD,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            detail: "(#{entry.parameters.map(&:decorated_name).join(", ")})",
+            description: entry.file_name,
+          ),
+          documentation: markdown_from_index_entries(name, entry),
+        )
+      end
+
+      sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
+      def build_completion(label, node)
+        # We should use the content location as we only replace the content and not the delimiters of the string
+        loc = node.content_loc
+
+        Interface::CompletionItem.new(
+          label: label,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_location(loc),
+            new_text: label,
+          ),
+          kind: Constant::CompletionItemKind::FILE,
+        )
+      end
+
+      sig do
+        params(
+          real_name: String,
+          incomplete_name: String,
+          node: Prism::Node,
+          entries: T::Array[RubyIndexer::Entry],
+          top_level: T::Boolean,
+        ).returns(Interface::CompletionItem)
+      end
+      def build_entry_completion(real_name, incomplete_name, node, entries, top_level)
+        first_entry = T.must(entries.first)
+        kind = case first_entry
+        when RubyIndexer::Entry::Class
+          Constant::CompletionItemKind::CLASS
+        when RubyIndexer::Entry::Module
+          Constant::CompletionItemKind::MODULE
+        when RubyIndexer::Entry::Constant
+          Constant::CompletionItemKind::CONSTANT
+        else
+          Constant::CompletionItemKind::REFERENCE
+        end
+
+        insertion_text = real_name.dup
+        filter_text = real_name.dup
+
+        # If we have two entries with the same name inside the current namespace and the user selects the top level
+        # option, we have to ensure it's prefixed with `::` or else we're completing the wrong constant. For example:
+        # If we have the index with ["Foo::Bar", "Bar"], and we're providing suggestions for `B` inside a `Foo` module,
+        # then selecting the `Foo::Bar` option needs to complete to `Bar` and selecting the top level `Bar` option needs
+        # to complete to `::Bar`.
+        if top_level
+          insertion_text.prepend("::")
+          filter_text.prepend("::")
+        end
+
+        # If the user is searching for a constant inside the current namespace, then we prefer completing the short name
+        # of that constant. E.g.:
+        #
+        # module Foo
+        #  class Bar
+        #  end
+        #
+        #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
+        # end
+        @nesting.each do |namespace|
+          prefix = "#{namespace}::"
+          shortened_name = insertion_text.delete_prefix(prefix)
+
+          # If a different entry exists for the shortened name, then there's a conflict and we should not shorten it
+          conflict_name = "#{@nesting.join("::")}::#{shortened_name}"
+          break if real_name != conflict_name && @index[conflict_name]
+
+          insertion_text = shortened_name
+
+          # If the user is typing a fully qualified name `Foo::Bar::Baz`, then we should not use the short name (e.g.:
+          # `Baz`) as filtering. So we only shorten the filter text if the user is not including the namespaces in their
+          # typing
+          filter_text.delete_prefix!(prefix) unless incomplete_name.start_with?(prefix)
+        end
+
+        # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
+        # For these top level references, we need to include the `::` as part of the filter text or else it won't match
+        # the right entries in the index
+        Interface::CompletionItem.new(
+          label: real_name,
+          filter_text: filter_text,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_node(node),
+            new_text: insertion_text,
+          ),
+          kind: kind,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            description: entries.map(&:file_name).join(","),
+          ),
+          documentation: markdown_from_index_entries(real_name, entries),
+        )
+      end
+
+      # Check if there are any conflicting names for `entry_name`, which would require us to use a top level reference.
+      # For example:
+      #
+      # ```ruby
+      # class Bar; end
+      #
+      # module Foo
+      #   class Bar; end
+      #
+      #   # in this case, the completion for `Bar` conflicts with `Foo::Bar`, so we can't suggest `Bar` as the
+      #   # completion, but instead need to suggest `::Bar`
+      #   B
+      # end
+      # ```
+      sig { params(entry_name: String).returns(T::Boolean) }
+      def top_level?(entry_name)
+        @nesting.length.downto(0).each do |i|
+          prefix = T.must(@nesting[0...i]).join("::")
+          full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
+          next if full_name == entry_name
+
+          return true if @index[full_name]
+        end
+
+        false
+      end
+    end
+  end
+end