pink_spoon 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fecc3a95f0a37f4c8a764c1dc116960bfd04f7911605512f591aed76d2981f64
-  data.tar.gz: a76ef303890dd64f6028b2cee4f943462c173c684c1e4551c22560415b40cfd2
+  metadata.gz: d7bf9b870581c1eb0fc630bb13d4ef6137767dd64d7546dcb74d92859a20e0f6
+  data.tar.gz: 7fce3bba4461680ad220526783e3179dd238fe536b83402fd945938fabf18453
 SHA512:
-  metadata.gz: '06128423c7fc856fe1bda76bc2f754e8911556e0f1bb2098866c050db9c909553fe51475591c1bd3996b7af49ce383cc8fce48754f4e0f71c7484534535af6e9'
-  data.tar.gz: 4d28946be92e5ceb745533cb8e1b9f65edf4390248add98b16c96c69c4252a14ac0bfae429df27ab839c3d99649191ba13c37d6a53c696c8ee772e029fca66d8
+  metadata.gz: 4f4cff255afdd927f04e5c4d17116a83374b8f97490713b16d158b5bd025915c7c4ac190e9f59ba1f01f8ca1fb2264adc0cd513f464c822b27e02186b46975ca
+  data.tar.gz: 7d4ffa93a4cd9d458b53897bc5878499dc1356d045c3a3d18ba72dd44bc9a719118f7d9bd3ebce95e23a8c0f48a227883b9d5167829cb5623f7bf4abff89a97f

data/lib/pink_spoon/rbi_index.rb

@@ -14,14 +14,16 @@ module PinkSpoon
   # though the method is defined on Hesiod::Gauge (which Hesiod extends).
   class RbiIndex
     def initialize(root_path)
-      @root_path = root_path
-      @sigs      = Hash.new { |h, k| h[k] = {} }
-      @types     = Hash.new { |h, k| h[k] = {} }
-      @defs      = Hash.new { |h, k| h[k] = {} }
-      @sources   = Hash.new { |h, k| h[k] = {} }
-      @locations = Hash.new { |h, k| h[k] = {} }
-      @mixins    = Hash.new { |h, k| h[k] = [] }
-      @params    = Hash.new { |h, k| h[k] = {} }
+      @root_path       = root_path
+      @sigs            = Hash.new { |h, k| h[k] = {} }
+      @types           = Hash.new { |h, k| h[k] = {} }
+      @defs            = Hash.new { |h, k| h[k] = {} }
+      @sources         = Hash.new { |h, k| h[k] = {} }
+      @locations       = Hash.new { |h, k| h[k] = {} }
+      @mixins          = Hash.new { |h, k| h[k] = [] }
+      @params          = Hash.new { |h, k| h[k] = {} }
+      @const_locations     = {}
+      @const_resolve_cache = {}
       build
     end
 
@@ -109,6 +111,20 @@ module PinkSpoon
       @mixins[normalise(type)].dup
     end
 
+    # Returns { file:, line: } pointing at the real gem source for a constant,
+    # resolved from the "# source://" comment in the RBI file, or nil.
+    # Resolution is deferred to call time and nil results are not cached so
+    # transient Bundler state changes don't permanently break lookups.
+    def const_source_for(type)
+      raw = @const_locations[normalise(type)]
+      return nil unless raw
+      cached = @const_resolve_cache[raw]
+      return cached if cached
+      loc = resolve_source_uri(raw)
+      @const_resolve_cache[raw] = loc if loc
+      loc
+    end
+
     # Returns { param_name => type_string } for type#method, or nil.
     # Follows the mixin chain.
     def params_for(type, method_name, _seen = [])
@@ -186,6 +202,44 @@ module PinkSpoon
       visitor.mixins.each do |type, mixin_list|
         @mixins[normalise(type)].concat(mixin_list.map { normalise(_1) }).uniq!
       end
+
+      visitor.const_sources.each do |type, raw_uri|
+        @const_locations[normalise(type)] = raw_uri
+      end
+    end
+
+    # Parses "# source://gem-name//lib/path/to/file.rb#42" and resolves
+    # the gem name to a real file path.
+    #
+    # Primary: scan $LOAD_PATH for entries containing /gems/<gem-name>-<version>/.
+    # $LOAD_PATH is fixed at process start and unaffected by Bundler state changes
+    # that ruby-lsp triggers during its indexing phase.
+    #
+    # Fallback: scan Gem.path directories (covers cases where the gem's lib dir
+    # is not explicitly on the load path).
+    def resolve_source_uri(comment)
+      m = comment.match(%r{source://([^/]+)//(.+?)#(\d+)})
+      return nil unless m
+      gem_name, rel_path, line = m[1], m[2], m[3].to_i
+      lp_pattern = %r{/gems/(#{Regexp.escape(gem_name)}-[^/]+)/}
+
+      $LOAD_PATH.each do |lp|
+        next unless (lm = lp.match(lp_pattern))
+        gem_dir = lp[0, lp.index(lm[0]) + lm[0].length - 1]
+        file = File.join(gem_dir, rel_path)
+        return { file: file, line: line } if File.exist?(file)
+      end
+
+      Gem.path.each do |gem_base|
+        Dir.glob("#{gem_base}/gems/#{gem_name}-*/").sort.reverse.each do |gem_dir|
+          file = File.join(gem_dir, rel_path)
+          return { file: file, line: line } if File.exist?(file)
+        end
+      end
+
+      nil
+    rescue
+      nil
     end
 
     def normalise(type)
@@ -198,25 +252,31 @@ module PinkSpoon
     #   - extend/include calls (mixins)
     # ------------------------------------------------------------------
     class RbiVisitor < Prism::Visitor
-      attr_reader :entries, :mixins
+      attr_reader :entries, :mixins, :const_sources
 
       def initialize(comment_map = {})
-        @entries     = []
-        @mixins      = Hash.new { |h, k| h[k] = [] }
-        @scope       = []
-        @pending_sig = nil
-        @comment_map = comment_map
+        @entries       = []
+        @mixins        = Hash.new { |h, k| h[k] = [] }
+        @const_sources = {}
+        @scope         = []
+        @pending_sig   = nil
+        @comment_map   = comment_map
       end
 
       def visit_module_node(node)
-        push_scope(node.constant_path) { super }
+        source_comment = source_comment_at(node.location.start_line)
+        push_scope(node.constant_path) do
+          @const_sources[@scope.join("::")] = source_comment if source_comment
+          super
+        end
       end
 
       def visit_class_node(node)
+        source_comment = source_comment_at(node.location.start_line)
         push_scope(node.constant_path) do
-          # Record superclass as a parent so method lookups walk the chain.
+          type = @scope.join("::")
+          @const_sources[type] = source_comment if source_comment
           if node.superclass
-            type   = @scope.join("::")
             parent = const_path_to_string(node.superclass).delete_prefix("::")
             @mixins[type] << parent unless @mixins[type].include?(parent)
           end
@@ -263,6 +323,11 @@ module PinkSpoon
 
       private
 
+      def source_comment_at(start_line)
+        c = @comment_map[start_line - 1]
+        c if c&.include?("source://")
+      end
+
       def record_mixins(call_node)
         type = @scope.join("::")
         return if type.empty?

data/lib/pink_spoon/server.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "prism"
 require_relative "rbi_index"
 require_relative "constant_resolver"
 require_relative "definition_finder"
@@ -56,6 +57,8 @@ module PinkSpoon
         exit(0)
       when "textDocument/definition"
         write_response(id, on_definition(req[:params]))
+      when "textDocument/diagnostic"
+        write_response(id, { kind: "full", items: [] })
       when "textDocument/hover"
         write_response(id, on_hover(req[:params]))
       else
@@ -92,23 +95,19 @@ module PinkSpoon
     def on_definition(params)
       return nil unless @rbi_index
 
-      file   = uri_to_path(params.dig(:textDocument, :uri))
-      line   = params.dig(:position, :line)
-      col    = params.dig(:position, :character)
+      file = uri_to_path(params.dig(:textDocument, :uri))
+      line = params.dig(:position, :line)
+      col  = params.dig(:position, :character)
 
       resolved = @constant_resolver.resolve_at(file, line, col)
-      return nil unless resolved
-
-      location = @definition_finder.find(resolved[:type], resolved[:method])
-      return nil unless location
+      if resolved
+        location = @definition_finder.find(resolved[:type], resolved[:method])
+        return location_response(location[:file], location[:line]) if location
+      end
 
-      {
-        uri:   path_to_uri(location[:file]),
-        range: {
-          start: { line: location[:line] - 1, character: 0 },
-          end:   { line: location[:line] - 1, character: 0 },
-        },
-      }
+      local_variable_definition(file, line, col)
+    rescue
+      nil
     end
 
     def on_hover(params)
@@ -132,6 +131,34 @@ module PinkSpoon
       }
     end
 
+    def local_variable_definition(file, lsp_line, col)
+      return nil unless file && File.exist?(file)
+
+      result = Prism.parse_file(file)
+      return nil unless result.success?
+
+      prism_line = lsp_line + 1
+      var_node   = CursorLocalVarFinder.new(prism_line, col).tap { |f| f.visit(result.value) }.result
+      return nil unless var_node
+
+      decl_line = LocalVarDeclarationFinder.new(var_node.name.to_s, prism_line).tap { |f| f.visit(result.value) }.line
+      return nil unless decl_line
+
+      location_response(file, decl_line)
+    rescue
+      nil
+    end
+
+    def location_response(file, line)
+      {
+        uri:   path_to_uri(file),
+        range: {
+          start: { line: line - 1, character: 0 },
+          end:   { line: line - 1, character: 0 },
+        },
+      }
+    end
+
     # ------------------------------------------------------------------
     # Protocol helpers
     # ------------------------------------------------------------------
@@ -170,4 +197,58 @@ module PinkSpoon
       "file://#{path}"
     end
   end
+
+  # Finds the LocalVariableReadNode whose source range covers the given cursor.
+  class CursorLocalVarFinder < Prism::Visitor
+    attr_reader :result
+
+    def initialize(line, col)
+      @line = line
+      @col  = col
+    end
+
+    def visit_local_variable_read_node(node)
+      loc = node.location
+      if loc.start_line == @line &&
+         loc.start_column <= @col &&
+         loc.end_column   >  @col
+        @result = node
+      end
+      super
+    end
+  end
+
+  # Finds the line where a local variable was last declared (parameter or
+  # assignment) before a given line number.
+  class LocalVarDeclarationFinder < Prism::Visitor
+    def initialize(var_name, before_line)
+      @var_name    = var_name
+      @before_line = before_line
+      @candidates  = []
+    end
+
+    def line
+      @candidates.last
+    end
+
+    def visit_local_variable_write_node(node)          = record(node) || super
+    def visit_local_variable_operator_write_node(node) = record(node) || super
+    def visit_local_variable_or_write_node(node)       = record(node) || super
+    def visit_local_variable_and_write_node(node)      = record(node) || super
+    def visit_required_parameter_node(node)            = record(node) || super
+    def visit_optional_parameter_node(node)            = record(node) || super
+    def visit_rest_parameter_node(node)                = record(node) || super
+    def visit_keyword_rest_parameter_node(node)        = record(node) || super
+    def visit_block_parameter_node(node)               = record(node) || super
+    def visit_required_keyword_parameter_node(node)    = record(node) || super
+    def visit_optional_keyword_parameter_node(node)    = record(node) || super
+
+    private
+
+    def record(node)
+      return unless node.name.to_s == @var_name
+      line_no = node.location.start_line
+      @candidates << line_no if line_no <= @before_line
+    end
+  end
 end

data/lib/pink_spoon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PinkSpoon
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/ruby_lsp/pink_spoon/addon.rb

@@ -13,6 +13,100 @@ require_relative "code_lens_listener"
 
 module RubyLsp
   module PinkSpoon
+    # Prepended to RubyLsp::Requests::Definition to handle local variable
+    # go-to-definition. Ruby-lsp excludes LocalVariableReadNode from its
+    # node_types list, so when the cursor is on a local variable (including
+    # when it is the receiver of a method call), ruby-lsp sets target = nil
+    # and calls no listeners. This patch does a second locate pass for that
+    # exact case and dispatches to pink-spoon's DefinitionListener.
+    module LocalVariableDefinitionFallback
+      class << self
+        attr_accessor :addon_instance
+      end
+
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
+        super
+
+        return if @target
+        return unless document.is_a?(RubyLsp::RubyDocument)
+
+        char_position, _ = document.find_index_by_position(position)
+        lv_context = RubyLsp::RubyDocument.locate(
+          document.ast,
+          char_position,
+          node_types: [Prism::LocalVariableReadNode],
+          code_units_cache: document.code_units_cache,
+        )
+        return unless lv_context.node.is_a?(Prism::LocalVariableReadNode)
+
+        addon = LocalVariableDefinitionFallback.addon_instance
+        return unless addon
+
+        @_lv_dispatcher = Prism::Dispatcher.new
+        addon.create_definition_listener(@response_builder, document.uri, lv_context, @_lv_dispatcher)
+        @_lv_target = lv_context.node
+      end
+
+      def perform
+        result = super
+        if @_lv_target && @_lv_dispatcher && result.empty?
+          @_lv_dispatcher.dispatch_once(@_lv_target)
+          return @response_builder.response
+        end
+        result
+      end
+    end
+
+    # Same pattern as LocalVariableDefinitionFallback but for hover.
+    # Hover#perform returns nil when target is nil; here we intercept,
+    # do a second locate for LocalVariableReadNode, and return hover content.
+    module LocalVariableHoverFallback
+      class << self
+        attr_accessor :addon_instance
+      end
+
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
+        super
+
+        return if @target
+        return unless document.is_a?(RubyLsp::RubyDocument)
+
+        char_position, _ = document.find_index_by_position(position)
+        lv_context = RubyLsp::RubyDocument.locate(
+          document.ast,
+          char_position,
+          node_types: [Prism::LocalVariableReadNode],
+          code_units_cache: document.code_units_cache,
+        )
+        return unless lv_context.node.is_a?(Prism::LocalVariableReadNode)
+
+        addon = LocalVariableHoverFallback.addon_instance
+        return unless addon
+
+        @_lv_hover_builder = RubyLsp::ResponseBuilders::Hover.new
+        @_lv_hover_dispatcher = Prism::Dispatcher.new
+        addon.create_hover_listener(@_lv_hover_builder, lv_context, @_lv_hover_dispatcher)
+        @_lv_hover_target = lv_context.node
+      end
+
+      def perform
+        result = super
+        return result if result
+
+        return nil unless @_lv_hover_target && @_lv_hover_dispatcher
+
+        @_lv_hover_dispatcher.dispatch_once(@_lv_hover_target)
+        return nil if @_lv_hover_builder.empty?
+
+        RubyLsp::Interface::Hover.new(
+          contents: RubyLsp::Interface::MarkupContent.new(
+            kind: "markdown",
+            value: @_lv_hover_builder.response,
+          ),
+        )
+      end
+    end
+
     class Addon < ::RubyLsp::Addon
       def activate(global_state, outgoing_queue)
         root = global_state.workspace_path
@@ -20,9 +114,22 @@ module RubyLsp
         @rbi_index         = ::PinkSpoon::RbiIndex.new(root)
         @constant_resolver = ::PinkSpoon::ConstantResolver.new(root, @rbi_index)
         @doc_extractor     = ::PinkSpoon::DocExtractor.new(root)
+
+        unless RubyLsp::Requests::Definition.ancestors.include?(LocalVariableDefinitionFallback)
+          LocalVariableDefinitionFallback.addon_instance = self
+          RubyLsp::Requests::Definition.prepend(LocalVariableDefinitionFallback)
+        end
+
+        unless RubyLsp::Requests::Hover.ancestors.include?(LocalVariableHoverFallback)
+          LocalVariableHoverFallback.addon_instance = self
+          RubyLsp::Requests::Hover.prepend(LocalVariableHoverFallback)
+        end
       end
 
-      def deactivate; end
+      def deactivate
+        LocalVariableDefinitionFallback.addon_instance = nil
+        LocalVariableHoverFallback.addon_instance = nil
+      end
 
       def name    = "Pink Spoon"
       def version = ::PinkSpoon::VERSION

data/lib/ruby_lsp/pink_spoon/definition_listener.rb

@@ -41,11 +41,14 @@ module RubyLsp
           source_location(resolved) || rbi_location(resolved)
         end
 
-        # Bare call (no explicit receiver): try two more strategies.
+        # Bare call (no explicit receiver): current file first, then nesting.
+        # Checking the current file first avoids the project-wide scan in
+        # nesting_location picking up a same-named method in a different file
+        # (e.g. alphabetically earlier au/.../download.rb vs gb/.../download.rb).
         if location.nil? && node.receiver.nil?
           method_name = node.name.to_s
-          location    = nesting_location(method_name, nesting) ||
-                        current_file_location(method_name)
+          location    = current_file_location(method_name) ||
+                        nesting_location(method_name, nesting)
         end
 
         # Fallback: ruby-lsp resolves LocalVariableReadNode receivers up to the
@@ -150,6 +153,27 @@ module RubyLsp
         nil
       end
 
+      # Handles go-to-definition for real local variables (entry = ..., |entry|, etc).
+      def on_local_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        file = @uri.to_s.delete_prefix("file://")
+        return unless file && File.exist?(file)
+
+        var_name  = node.name.to_s
+        read_line = node.location.start_line
+
+        result = Prism.parse_file(file)
+        finder = LocalVariableDefinitionFinder.new(var_name, read_line)
+        finder.visit(result.value)
+        line = finder.line
+        return unless line
+
+        push_location(file, line)
+      rescue
+        nil
+      end
+
       private
 
       def navigate_super(node)
@@ -209,7 +233,8 @@ module RubyLsp
       end
 
       def goto_constant(type)
-        location = @doc_extractor&.find_constant_source(type)
+        location = @rbi_index.const_source_for(type)
+        location ||= @doc_extractor&.find_constant_source(type)
         return unless location
         push_location(location[:file], location[:line])
       end
@@ -238,27 +263,6 @@ module RubyLsp
         rbi_location(resolved) || source_location(resolved)
       end
 
-      # Handles go-to-definition for real local variables (entry = ..., |entry|, etc).
-      def on_local_variable_read_node_enter(node)
-        return unless node.equal?(@node_context.node)
-
-        file = @uri.to_s.delete_prefix("file://")
-        return unless file && File.exist?(file)
-
-        var_name  = node.name.to_s
-        read_line = node.location.start_line
-
-        result = Prism.parse_file(file)
-        finder = LocalVariableDefinitionFinder.new(var_name, read_line)
-        finder.visit(result.value)
-        line = finder.line
-        return unless line
-
-        push_location(file, line)
-      rescue
-        nil
-      end
-
       # Last resort: scan the file the user is currently editing.
       # Matches def, let(:name), let!(:name), subject(:name), subject!(:name).
       def current_file_location(method_name)
@@ -280,13 +284,26 @@ module RubyLsp
       end
 
       def push_location(file, line)
+        target_uri = "file://#{file}"
+
+        begin
+          existing = @response_builder.response
+          return if existing.any? do |item|
+            (item.respond_to?(:target_uri) ? item.target_uri : item.uri) == target_uri
+          end
+        rescue
+          # Can't inspect existing results — proceed with the push
+        end
+
         line_lsp = line - 1
-        @response_builder << Interface::Location.new(
-          uri:   "file://#{file}",
-          range: Interface::Range.new(
-            start: Interface::Position.new(line: line_lsp, character: 0),
-            end:   Interface::Position.new(line: line_lsp, character: 0),
-          ),
+        range = Interface::Range.new(
+          start: Interface::Position.new(line: line_lsp, character: 0),
+          end:   Interface::Position.new(line: line_lsp, character: 0),
+        )
+        @response_builder << Interface::LocationLink.new(
+          target_uri:             target_uri,
+          target_range:           range,
+          target_selection_range: range,
         )
       end
 
@@ -336,6 +353,16 @@ module RubyLsp
           super
         end
 
+        def visit_rest_parameter_node(node)
+          record(node)
+          super
+        end
+
+        def visit_keyword_rest_parameter_node(node)
+          record(node)
+          super
+        end
+
         # Block parameters: do |entry|
         def visit_block_parameter_node(node)
           record(node)

data/lib/ruby_lsp/pink_spoon/hover_listener.rb

@@ -23,6 +23,7 @@ module RubyLsp
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
           :on_instance_variable_read_node_enter,
+          :on_local_variable_read_node_enter,
         )
       end
 
@@ -71,6 +72,27 @@ module RubyLsp
         @response_builder.push(content, category: :documentation)
       end
 
+      def on_local_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        nesting = @node_context.instance_variable_get(:@nesting_nodes)
+        program = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
+        return unless program
+
+        finder = LocalVarKindFinder.new(node.name.to_s, node.location.start_line)
+        finder.visit(program)
+        return unless finder.kind
+
+        label = case finder.kind
+                when :method_param then "parameter"
+                when :block_param  then "block parameter"
+                else                    "local variable"
+                end
+        @response_builder.push("**`#{node.name}`** — *#{label}*", category: :documentation)
+      rescue
+        nil
+      end
+
       private
 
       def serve_constant_hover(type)
@@ -90,5 +112,64 @@ module RubyLsp
         "#{rbi}\n\n---\n\n#{doc}"
       end
     end
+
+    # Determines whether a local variable is a method parameter, block
+    # parameter, or a plain local variable assignment.
+    class LocalVarKindFinder < Prism::Visitor
+      def initialize(var_name, before_line)
+        @var_name    = var_name
+        @before_line = before_line
+        @candidates  = []
+        @context     = []
+      end
+
+      def kind
+        @candidates.last&.last
+      end
+
+      def visit_def_node(node)
+        @context.push(:method)
+        super
+        @context.pop
+      end
+
+      def visit_block_node(node)
+        @context.push(:block)
+        super
+        @context.pop
+      end
+
+      def visit_lambda_node(node)
+        @context.push(:block)
+        super
+        @context.pop
+      end
+
+      def visit_local_variable_write_node(node)          = record(node, :local_var) || super
+      def visit_local_variable_operator_write_node(node) = record(node, :local_var) || super
+      def visit_local_variable_or_write_node(node)       = record(node, :local_var) || super
+      def visit_local_variable_and_write_node(node)      = record(node, :local_var) || super
+
+      def visit_required_parameter_node(node)         = record_param(node) || super
+      def visit_optional_parameter_node(node)         = record_param(node) || super
+      def visit_rest_parameter_node(node)             = record_param(node) || super
+      def visit_keyword_rest_parameter_node(node)     = record_param(node) || super
+      def visit_block_parameter_node(node)            = record_param(node) || super
+      def visit_required_keyword_parameter_node(node) = record_param(node) || super
+      def visit_optional_keyword_parameter_node(node) = record_param(node) || super
+
+      private
+
+      def record_param(node)
+        kind = @context.last == :block ? :block_param : :method_param
+        record(node, kind)
+      end
+
+      def record(node, kind)
+        return unless node.name.to_s == @var_name
+        line_no = node.location.start_line
+        @candidates << [line_no, kind] if line_no <= @before_line
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pink_spoon
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Jānis Harbs
 bindir: bin
 cert_chain: []
-date: 2026-06-02 00:00:00.000000000 Z
+date: 2026-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism