pink_spoon 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7bf9b870581c1eb0fc630bb13d4ef6137767dd64d7546dcb74d92859a20e0f6
-  data.tar.gz: 7fce3bba4461680ad220526783e3179dd238fe536b83402fd945938fabf18453
+  metadata.gz: 7a1dfe02635dfec7fd176f0727ddbf7feff1a23e17ef63fdcee94c283a4e008c
+  data.tar.gz: 355c66c3af0e1cb8169d2b3b2887f161558376578a9b009bca577943d536e460
 SHA512:
-  metadata.gz: 4f4cff255afdd927f04e5c4d17116a83374b8f97490713b16d158b5bd025915c7c4ac190e9f59ba1f01f8ca1fb2264adc0cd513f464c822b27e02186b46975ca
-  data.tar.gz: 7d4ffa93a4cd9d458b53897bc5878499dc1356d045c3a3d18ba72dd44bc9a719118f7d9bd3ebce95e23a8c0f48a227883b9d5167829cb5623f7bf4abff89a97f
+  metadata.gz: f9682658394a75acd7987bbe67df72a15041a81fe47cb8d560df327410d05b62dc421808341c8f7337d84b084b331d197dab0588d86ffdc6d4b5184cf44fe869
+  data.tar.gz: a5738766fbfe3171f40148117075fa5379a5aa25893387ad43db668558f0e6b2e1786164d4b7fd6077f6352df4242da1abb447191b7672ee926bd51327afe8dd

data/lib/pink_spoon/constant_resolver.rb

@@ -28,6 +28,7 @@ module PinkSpoon
       include_context include_examples include_shared_examples_for
       shared_examples shared_context shared_examples_for
       aggregate_failures
+      described_class
     ].freeze
 
     RSPEC_MODULE_METHODS = %w[describe shared_examples shared_context shared_examples_for].freeze
@@ -69,6 +70,22 @@ module PinkSpoon
       @_nesting   = nil
     end
 
+    # Returns the inferred type of a local variable (including block params), or nil.
+    # Used by hover to show type info alongside the "block parameter" label.
+    def infer_variable_type(var_name, program_node, nesting = nil)
+      @_nesting = nesting
+      find_local_var_type(var_name, program_node, nil)
+    rescue
+      nil
+    ensure
+      @_nesting = nil
+    end
+
+    # Returns the class name passed to the outermost describe(MyClass) block, or nil.
+    def described_class_in(program_node)
+      find_described_class(program_node)
+    end
+
     # Public entry point for completion: returns the type string of a receiver node.
     def resolve_receiver_type(receiver_node, program_node, nesting = nil)
       @_nesting = nesting
@@ -162,6 +179,22 @@ module PinkSpoon
         return nil if _seen.include?(guard)
         find_ivar_type(ivar, ast, source, _seen + [guard])
       when Prism::CallNode
+        # described_class → the class passed to the outermost describe(MyClass)
+        if receiver.name == :described_class && receiver.receiver.nil?
+          return find_described_class(ast)
+        end
+        # Bare call used as a receiver (e.g. have_been_made.once).
+        # Try ExampleGroup mixin chain, then a global RBI search so that
+        # WebMock/custom methods work even without an explicit mixin link.
+        if receiver.receiver.nil?
+          rspec_return = follow_chain("RSpec::Core::ExampleGroup", receiver.name.to_s)
+          return rspec_return if rspec_return
+          found_type = @rbi_index.find_type_for_method(receiver.name.to_s)
+          if found_type
+            ret = @rbi_index.return_type_for(found_type, receiver.name.to_s)
+            return ret if ret
+          end
+        end
         # T.must(x) → resolve x
         if receiver.name == :must && t_module?(receiver.receiver)
           arg = receiver.arguments&.arguments&.first
@@ -253,6 +286,12 @@ module PinkSpoon
       nil
     end
 
+    def find_described_class(ast)
+      finder = DescribedClassFinder.new
+      finder.visit(ast)
+      finder.result
+    end
+
     # ------------------------------------------------------------------
     # Local variable type resolution
     # ------------------------------------------------------------------
@@ -271,16 +310,35 @@ module PinkSpoon
       param_type = find_method_param_type(var_name)
       return param_type if param_type
 
-      # Block parameter: method { |var| } — infer element type from receiver.
+      # Block parameter: method { |var| } — infer type from the enclosing call.
       finder = BlockParamFinder.new(var_name)
       finder.visit(ast)
-      return nil unless finder.enclosing_call&.receiver
+      return nil unless finder.enclosing_call
+
+      call        = finder.enclosing_call
+      method_name = call.name.to_s
 
-      call          = finder.enclosing_call
-      receiver_type = resolve_receiver(call.receiver, ast, source, _seen)
+      receiver_type = if call.receiver
+        resolve_receiver(call.receiver, ast, source, _seen)
+      else
+        # Bare call (e.g. stub_request { |req| }): try ExampleGroup then global.
+        @rbi_index.return_type_for("RSpec::Core::ExampleGroup", method_name) ||
+          begin
+            ft = @rbi_index.find_type_for_method(method_name)
+            ft ? "#{ft}" : nil
+          end
+      end
       return nil unless receiver_type
 
-      method_name = call.name.to_s
+      # Prefer the explicit yield type declared in the sig (yields(SomeType)).
+      yt = @rbi_index.yield_type_for(receiver_type, method_name)
+      # For bare calls that resolved via find_type_for_method, also try that type.
+      if yt.nil? && call.receiver.nil?
+        ft = @rbi_index.find_type_for_method(method_name)
+        yt = @rbi_index.yield_type_for(ft, method_name) if ft
+      end
+      return yt if yt
+
       if ENUMERATION_METHODS.include?(method_name)
         extract_element_type(receiver_type)
       else
@@ -304,10 +362,7 @@ module PinkSpoon
     def find_method_param_type(param_name)
       return nil unless @_call_line && @_nesting
 
-      class_node = @_nesting.reverse.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-      return nil unless class_node
-
-      current_type = class_node.constant_path.slice.delete_prefix("::")
+      current_type = qualified_type_from_nesting(@_nesting)
       method_name  = EnclosingDefFinder.new(@_call_line).find(
         @_nesting.find { |n| n.is_a?(Prism::ProgramNode) }
       )
@@ -318,6 +373,14 @@ module PinkSpoon
       raw ? unwrap_sorbet_wrapper(raw) : nil
     end
 
+    def qualified_type_from_nesting(nesting)
+      return nil unless nesting
+      parts = nesting
+        .select { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+        .map { |n| n.constant_path.slice.delete_prefix("::") }
+      parts.empty? ? nil : parts.join("::")
+    end
+
     def extract_element_type(type_str)
       return nil unless type_str
       m = type_str.match(/\[(\w+(?:::\w+)*)\]$/)
@@ -427,6 +490,23 @@ module PinkSpoon
       end
     end
 
+    # Finds the class constant passed as the first argument to the outermost
+    # describe(MyClass) or RSpec.describe(MyClass) call in the file.
+    class DescribedClassFinder < Prism::Visitor
+      attr_reader :result
+
+      def visit_call_node(node)
+        if node.name == :describe && @result.nil?
+          first = node.arguments&.arguments&.first
+          @result = case first
+                    when Prism::ConstantReadNode then first.name.to_s
+                    when Prism::ConstantPathNode then first.slice.delete_prefix("::")
+                    end
+        end
+        super
+      end
+    end
+
     # Finds the CallNode whose block introduces `var_name` as a parameter.
     # e.g.  entries.each { |entry| }  →  enclosing_call = entries.each(...)
     class BlockParamFinder < Prism::Visitor

data/lib/pink_spoon/doc_extractor.rb

@@ -32,7 +32,7 @@ module PinkSpoon
           end
         end
 
-        %w[lib app].each do |subdir|
+        %w[lib app spec test].each do |subdir|
           dir = File.join(@root_path, subdir)
           next unless File.directory?(dir)
           Dir.glob("#{dir}/**/*.rb").sort.each do |file|
@@ -126,19 +126,47 @@ module PinkSpoon
         end
       end
 
-      # Fall back to project source (lib/, app/).
-      %w[lib app].each do |subdir|
+      # For project files: try the conventional Zeitwerk path first so that a
+      # fully-qualified type like Acme::Billing::Worker resolves directly to
+      # lib/acme/billing/worker.rb rather than returning the first alphabetical
+      # match from a glob (which may be an unrelated class with the same name).
+      %w[lib app spec test].each do |subdir|
         dir = File.join(@root_path, subdir)
         next unless File.directory?(dir)
-        Dir.glob("#{dir}/**/*.rb").sort.each do |file|
-          line = first_line_matching(file, pattern)
-          return { file: file, line: line } if line
+
+        if parts.size > 1
+          candidate = File.join(dir, *parts.map { |p| underscore(p) }) + ".rb"
+          if File.exist?(candidate)
+            line = first_line_matching(candidate, pattern)
+            return { file: candidate, line: line || 1 } if line
+          end
+          # Glob fallback: require the file path to contain the full
+          # intermediate namespace so that lib/nexus/au/.../download.rb is
+          # not returned when looking for Nexus::Gb::Bacs::Form3::Retrievals::Download.
+          # Also accepts a single-file namespace (lib/my_gem.rb for MyGem::Foo).
+          intermediate = parts[0..-2].map { |p| underscore(p) }.join("/")
+          Dir.glob("#{dir}/**/*.rb").sort.each do |file|
+            next unless file.include?("/#{intermediate}/") || file.end_with?("/#{intermediate}.rb")
+            line = first_line_matching(file, pattern)
+            return { file: file, line: line } if line
+          end
+        else
+          Dir.glob("#{dir}/**/*.rb").sort.each do |file|
+            line = first_line_matching(file, pattern)
+            return { file: file, line: line } if line
+          end
         end
       end
 
       nil
     end
 
+    def underscore(str)
+      str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .downcase
+    end
+
     def first_line_matching(file, pattern)
       File.foreach(file).with_index(1) { |l, i| return i if l.match?(pattern) }
       nil
@@ -165,7 +193,7 @@ module PinkSpoon
       end
 
       # Fall back to project source (lib/, app/) for project-defined methods.
-      %w[lib app].each do |subdir|
+      %w[lib app spec test].each do |subdir|
         dir = File.join(@root_path, subdir)
         next unless File.directory?(dir)
         Dir.glob("#{dir}/**/*.rb").sort.each do |file|

data/lib/pink_spoon/rbi_index.rb

@@ -22,8 +22,10 @@ module PinkSpoon
       @locations       = Hash.new { |h, k| h[k] = {} }
       @mixins          = Hash.new { |h, k| h[k] = [] }
       @params          = Hash.new { |h, k| h[k] = {} }
+      @yields              = Hash.new { |h, k| h[k] = {} }
       @const_locations     = {}
       @const_resolve_cache = {}
+      @method_type_cache   = {}
       build
     end
 
@@ -160,6 +162,42 @@ module PinkSpoon
       result
     end
 
+    # Returns the yield type declared in the sig (yields(Type)), or nil.
+    # e.g. for `sig { yields(WebMock::RequestSignature).returns(...) }`
+    # returns "WebMock::RequestSignature".
+    def yield_type_for(type, method_name, _seen = [])
+      t = normalise(type)
+      return nil if _seen.include?(t)
+
+      direct = @yields[t][method_name.to_s]
+      return direct if direct
+
+      @mixins[t].each do |mixin|
+        result = yield_type_for(mixin, method_name, _seen + [t])
+        return result if result
+      end
+
+      nil
+    end
+
+    # Returns the first RBI type that defines +method_name+, scanning all
+    # indexed types. Used as a last resort when mixin-chain lookups fail
+    # (e.g. WebMock methods not wired into RSpec::Core::ExampleGroup).
+    def find_type_for_method(method_name)
+      name = method_name.to_s
+      return @method_type_cache[name] if @method_type_cache.key?(name)
+
+      result = nil
+      @sigs.each { |type, methods| result = type and break if methods.key?(name) }
+      result ||= begin
+        found = nil
+        @defs.each { |type, methods| found = type and break if methods.key?(name) }
+        found
+      end
+      @method_type_cache[name] = result
+      result
+    end
+
     # All known types (for debugging / testing).
     def types = @sigs.keys
 
@@ -196,6 +234,7 @@ module PinkSpoon
         @defs[type][entry[:method]]      = entry[:def_line]
         @params[type][entry[:method]]    = entry[:params] if entry[:params]
         @sources[type][entry[:method]]   = entry[:source] if entry[:source]
+        @yields[type][entry[:method]]    = entry[:yield_type] if entry[:yield_type]
         @locations[type][entry[:method]] = { file: path, line: entry[:line] }
       end
 
@@ -313,6 +352,7 @@ module PinkSpoon
           sig:         sig,
           def_line:    def_line,
           return_type: sig ? extract_return_type(sig) : nil,
+          yield_type:  sig ? extract_yield_type(sig) : nil,
           params:      sig ? extract_params(sig) : {},
           source:      source,
           line:        node.location.start_line,
@@ -361,6 +401,11 @@ module PinkSpoon
         match&.[](1)
       end
 
+      def extract_yield_type(sig)
+        match = sig.match(/yields\(\s*([\w:]+)\s*\)/)
+        match&.[](1)&.delete_prefix("::")
+      end
+
       def extract_params(sig)
         m = sig.match(/params\((.+?)\)\s*\./m)
         return {} unless m

data/lib/pink_spoon/version.rb

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

data/lib/ruby_lsp/pink_spoon/definition_listener.rb

@@ -41,6 +41,22 @@ module RubyLsp
           source_location(resolved) || rbi_location(resolved)
         end
 
+        # Bare call with no location yet: try RSpec::Core::ExampleGroup.
+        # Handles expect, have_been_made, a_request, stub_request, etc.
+        if location.nil? && node.receiver.nil? && resolved.nil?
+          eg_resolved = { type: "RSpec::Core::ExampleGroup", method: node.name.to_s }
+          location = source_location(eg_resolved) || rbi_location(eg_resolved)
+        end
+
+        # described_class → go to the class passed to describe(MyClass)
+        if location.nil? && node.receiver.nil? && node.name == :described_class
+          described = @resolver.described_class_in(program_node)
+          if described
+            goto_constant(described)
+            return
+          end
+        end
+
         # 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
@@ -48,7 +64,8 @@ module RubyLsp
         if location.nil? && node.receiver.nil?
           method_name = node.name.to_s
           location    = current_file_location(method_name) ||
-                        nesting_location(method_name, nesting)
+                        nesting_location(method_name, nesting) ||
+                        included_module_location(method_name, program_node)
         end
 
         # Fallback: ruby-lsp resolves LocalVariableReadNode receivers up to the
@@ -97,12 +114,11 @@ module RubyLsp
       def on_def_node_enter(node)
         return unless node.equal?(@node_context.node)
 
-        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
-        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-        return unless class_node
+        nesting = @node_context.instance_variable_get(:@nesting_nodes)
+        type    = qualified_type_from_nesting(nesting)
+        return unless type
 
-        type = class_node.constant_path.slice.delete_prefix("::")
-        loc  = source_location({ type: type, method: node.name.to_s })
+        loc = source_location({ type: type, method: node.name.to_s })
         push_location(loc[:file], loc[:line]) if loc
       rescue
         nil
@@ -137,11 +153,10 @@ module RubyLsp
         end
 
         # Not found in current file — walk the parent class chain.
-        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
-        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-        return unless class_node
+        nesting      = @node_context.instance_variable_get(:@nesting_nodes)
+        current_type = qualified_type_from_nesting(nesting)
+        return unless current_type
 
-        current_type = class_node.constant_path.slice.delete_prefix("::")
         @rbi_index.mixins_for(current_type).each do |parent_type|
           loc = @doc_extractor&.find_ivar_in_type(parent_type, ivar_name)
           if loc
@@ -181,11 +196,10 @@ module RubyLsp
         program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
         return unless program_node
 
-        class_node = nesting.reverse.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-        return unless class_node
+        current_type = qualified_type_from_nesting(nesting)
+        return unless current_type
 
-        current_type = class_node.constant_path.slice.delete_prefix("::")
-        method_name  = EnclosingMethodFinder.new(node.location.start_line).find(program_node)
+        method_name = EnclosingMethodFinder.new(node.location.start_line).find(program_node)
         return unless method_name
 
         @rbi_index.mixins_for(current_type).each do |parent_type|
@@ -227,16 +241,80 @@ module RubyLsp
         nil
       end
 
+      # Scans the file AST for include/extend/prepend calls and tries each
+      # module as a source for the method. Covers the case where a method comes
+      # from an included module that isn't in the RBI mixin chain.
+      def included_module_location(method_name, program_node)
+        included_module_names(program_node).each do |mod_name|
+          resolved = { type: mod_name, method: method_name }
+          loc = rbi_location(resolved) || source_location(resolved)
+          return loc if loc
+        end
+        nil
+      rescue
+        nil
+      end
+
+      def included_module_names(program_node)
+        names = []
+        collect_includes(program_node, names)
+        names
+      end
+
+      def collect_includes(node, names)
+        return unless node.is_a?(Prism::Node)
+        if node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+           %i[include extend prepend].include?(node.name)
+          node.arguments&.arguments&.each do |arg|
+            name = case arg
+                   when Prism::ConstantReadNode then arg.name.to_s
+                   when Prism::ConstantPathNode then arg.slice.delete_prefix("::")
+                   end
+            names << name if name
+          end
+        end
+        node.child_nodes.compact.each { |child| collect_includes(child, names) }
+      end
+
       def guess_type_from_nesting(nesting)
-        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-        class_node&.constant_path&.slice&.delete_prefix("::")
+        qualified_type_from_nesting(nesting)
       end
 
-      def goto_constant(type)
-        location = @rbi_index.const_source_for(type)
-        location ||= @doc_extractor&.find_constant_source(type)
-        return unless location
-        push_location(location[:file], location[:line])
+      def qualified_type_from_nesting(nesting)
+        return nil unless nesting
+        parts = nesting
+          .select { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+          .map { |n| n.constant_path.slice.delete_prefix("::") }
+        parts.empty? ? nil : parts.join("::")
+      end
+
+      def goto_constant(bare_name)
+        nesting = @node_context.instance_variable_get(:@nesting_nodes)
+
+        lexical_candidates(bare_name, nesting).each do |candidate|
+          location = @rbi_index.const_source_for(candidate)
+          location ||= @doc_extractor&.find_constant_source(candidate)
+          next unless location
+
+          push_location(location[:file], location[:line])
+          return
+        end
+      end
+
+      def lexical_candidates(bare_name, nesting)
+        parts = nesting
+          &.select { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+          &.map { |n| n.constant_path.slice.delete_prefix("::") }
+
+        return [bare_name] if parts.nil? || parts.empty?
+
+        candidates = []
+        while parts.any?
+          candidates << "#{parts.join("::")}::#{bare_name}"
+          parts.pop
+        end
+        candidates << bare_name
+        candidates
       end
 
       def rbi_location(resolved)
@@ -250,16 +328,10 @@ module RubyLsp
       # Infer the type from the innermost enclosing class/module in the nesting
       # and look the method up in the RBI index or gem source.
       def nesting_location(method_name, nesting)
-        return nil unless nesting
-
-        class_node = nesting.reverse.find do |n|
-          n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode)
-        end
-        return nil unless class_node
+        type = qualified_type_from_nesting(nesting)
+        return nil unless type
 
-        type     = class_node.constant_path.slice.delete_prefix("::")
         resolved = { type: type, method: method_name }
-
         rbi_location(resolved) || source_location(resolved)
       end
 

data/lib/ruby_lsp/pink_spoon/hover_listener.rb

@@ -40,11 +40,10 @@ module RubyLsp
       def on_instance_variable_read_node_enter(node)
         return unless node.equal?(@node_context.node)
 
-        nesting    = @node_context.instance_variable_get(:@nesting_nodes)
-        class_node = nesting&.reverse&.find { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
-        return unless class_node
+        nesting  = @node_context.instance_variable_get(:@nesting_nodes)
+        type     = qualified_type_from_nesting(nesting)
+        return unless type
 
-        type     = class_node.constant_path.slice.delete_prefix("::")
         accessor = node.name.to_s.delete_prefix("@")
 
         content = @rbi_index.hover_content_for(type, accessor)
@@ -60,12 +59,50 @@ module RubyLsp
         program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
         return unless program_node
 
+        if node.name == :described_class && node.receiver.nil?
+          described = @resolver.described_class_in(program_node)
+          if described
+            @response_builder.push("**`described_class`** → `#{described}`", category: :documentation)
+            return
+          end
+        end
+
         resolved = @resolver.resolve_from_call(node, program_node)
+
+        if resolved.nil? && node.receiver.nil?
+          type     = qualified_type_from_nesting(nesting)
+          resolved = { type: type, method: node.name.to_s } if type
+        end
+
+        # Bare call with still-unresolved type: try ExampleGroup.
+        # Catches RSpec/WebMock methods (expect, have_been_made, a_request, etc.)
+        # that arrive via globally-included modules not visible in the file AST.
+        if resolved.nil? && node.receiver.nil?
+          resolved = { type: "RSpec::Core::ExampleGroup", method: node.name.to_s }
+        end
+
         return unless resolved
 
         rbi_content = @rbi_index.hover_content_for(resolved[:type], resolved[:method])
         doc_content = @doc_extractor&.extract(resolved[:type], resolved[:method])
 
+        # If the main type chain yielded nothing and this is a bare call, scan the
+        # file AST for include/extend declarations and try each module directly.
+        # This covers methods that come from included modules not in the RBI chain.
+        if rbi_content.nil? && doc_content.nil? && node.receiver.nil?
+          rbi_content, doc_content = hover_from_included_modules(resolved[:method], program_node)
+        end
+
+        # Global fallback: find any RBI type that defines this method.
+        # Handles WebMock/custom methods not wired into the ExampleGroup chain.
+        if rbi_content.nil? && doc_content.nil? && node.receiver.nil?
+          found_type = @rbi_index.find_type_for_method(resolved[:method])
+          if found_type
+            rbi_content = @rbi_index.hover_content_for(found_type, resolved[:method])
+            doc_content = @doc_extractor&.extract(found_type, resolved[:method])
+          end
+        end
+
         content = combine(rbi_content, doc_content)
         return unless content
 
@@ -88,13 +125,57 @@ module RubyLsp
                 when :block_param  then "block parameter"
                 else                    "local variable"
                 end
-        @response_builder.push("**`#{node.name}`** — *#{label}*", category: :documentation)
+
+        type = @resolver.infer_variable_type(node.name.to_s, program, nesting)
+        text = type ? "**`#{node.name}`** — *#{label}* `#{type}`" \
+                    : "**`#{node.name}`** — *#{label}*"
+        @response_builder.push(text, category: :documentation)
       rescue
         nil
       end
 
       private
 
+      def hover_from_included_modules(method_name, program_node)
+        included_module_names(program_node).each do |mod_name|
+          rbi = @rbi_index.hover_content_for(mod_name, method_name)
+          doc = @doc_extractor&.extract(mod_name, method_name)
+          return [rbi, doc] if rbi || doc
+        end
+        [nil, nil]
+      rescue
+        [nil, nil]
+      end
+
+      def included_module_names(program_node)
+        names = []
+        collect_includes(program_node, names)
+        names
+      end
+
+      def collect_includes(node, names)
+        return unless node.is_a?(Prism::Node)
+        if node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+           %i[include extend prepend].include?(node.name)
+          node.arguments&.arguments&.each do |arg|
+            name = case arg
+                   when Prism::ConstantReadNode then arg.name.to_s
+                   when Prism::ConstantPathNode then arg.slice.delete_prefix("::")
+                   end
+            names << name if name
+          end
+        end
+        node.child_nodes.compact.each { |child| collect_includes(child, names) }
+      end
+
+      def qualified_type_from_nesting(nesting)
+        return nil unless nesting
+        parts = nesting
+          .select { |n| n.is_a?(Prism::ClassNode) || n.is_a?(Prism::ModuleNode) }
+          .map { |n| n.constant_path.slice.delete_prefix("::") }
+        parts.empty? ? nil : parts.join("::")
+      end
+
       def serve_constant_hover(type)
         return unless @doc_extractor
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pink_spoon
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jānis Harbs
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -39,6 +40,7 @@ dependencies:
         version: '0.22'
 description: Augments ruby-lsp hover and go-to-definition with type information from
   sorbet/rbi/**/*.rbi. Drop it in your Gemfile and it just works.
+email:
 executables:
 - pink-spoon
 extensions: []
@@ -58,8 +60,10 @@ files:
 - lib/ruby_lsp/pink_spoon/completion_listener.rb
 - lib/ruby_lsp/pink_spoon/definition_listener.rb
 - lib/ruby_lsp/pink_spoon/hover_listener.rb
+homepage:
 licenses: []
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -74,7 +78,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: 'ruby-lsp addon: resolves types from Sorbet RBI files'
 test_files: []