pink_spoon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce69a26c0202add732139120d580e082afe4e783e33053e29652f0ab113778bd
+  data.tar.gz: 468b2feec436762cb468751b58cda34264088ece69e246a0422e067cad213b2f
+SHA512:
+  metadata.gz: 2b716b7f37adb643ccaaca86c4058f32bc3903d7097f9a82ca3cdfddd2c397b1628792fb40141dc111d92d97f764c7a383018c2b0c24b37c8af1e06791203b49
+  data.tar.gz: '078a9df02c0ed4160180b8a9a9efd7ad4ca0161af3723edffd443a019f410cdb55c10b86a0320e19a32e001f5c355c1cac17cd43eaf8e4a9cd362c772f495267'

data/bin/install-addon

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Usage: ruby bin/install-addon /path/to/target/project
+#
+# Drops a ruby_lsp/pink_spoon/addon.rb stub into the target project that
+# loads pink-spoon from this gem's source tree.
+# ruby_lsp/pink_spoon/ is covered by ~/.gitignore_global so the stub
+# never shows up in git status.
+
+require "fileutils"
+
+target = ARGV[0]&.then { File.expand_path(_1) }
+
+if target.nil? || !File.directory?(target)
+  abort "Usage: #{$0} /path/to/project"
+end
+
+gem_root  = File.expand_path("..", __dir__)
+stub_dir  = File.join(target, "ruby_lsp", "pink_spoon")
+stub_file = File.join(stub_dir, "addon.rb")
+
+FileUtils.mkdir_p(stub_dir)
+File.write(stub_file, <<~RUBY)
+  # frozen_string_literal: true
+  # Auto-generated by pink-spoon/bin/install-addon — not committed.
+  # Re-run install-addon to update after changes to pink-spoon.
+  $LOAD_PATH.unshift "#{gem_root}/lib" unless $LOAD_PATH.include?("#{gem_root}/lib")
+  require "ruby_lsp/pink_spoon/addon"
+RUBY
+
+puts "wrote #{stub_file}"
+puts "covered by ~/.gitignore_global — won't appear in git status"
+puts "\nDone. Restart ruby-lsp in Zed (cmd+shift+p → Restart Language Server)."

data/bin/pink-spoon

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "pink_spoon/server"
+
+PinkSpoon::Server.new.run

data/lib/pink_spoon/constant_resolver.rb

@@ -0,0 +1,469 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module PinkSpoon
+  # Given a file + cursor position, figures out:
+  #   1. What constant the receiver resolves to (e.g. EnabledFeatureGauge → Prometheus::Client::Gauge)
+  #   2. What method name is under the cursor
+  #
+  # Returns { type: "Prometheus::Client::Gauge", method: "init_label_set" } or nil.
+  #
+  # Resolution strategy (in order):
+  #   a. Walk up the AST to find the call node under the cursor.
+  #   b. If the receiver is a constant, look it up as an assignment in the same file.
+  #   c. If the receiver is a local variable, resolve its type from assignments or block params.
+  #   d. Follow the RHS chain through the RBI index (register_gauge → Gauge, .freeze → passthrough).
+  #   e. For Foo.new(...), the type is Foo directly (Sorbet rarely types .new explicitly).
+  class ConstantResolver
+    PASSTHROUGH_METHODS = %w[freeze dup clone tap then yield_self].freeze
+
+    RSPEC_EXAMPLE_GROUP_METHODS = %w[
+      it example specify
+      context describe
+      let let!
+      subject subject!
+      before after around
+      pending skip
+      include_context include_examples include_shared_examples_for
+      shared_examples shared_context shared_examples_for
+      aggregate_failures
+    ].freeze
+
+    RSPEC_MODULE_METHODS = %w[describe shared_examples shared_context shared_examples_for].freeze
+
+    # Methods that yield each element of their receiver collection.
+    ENUMERATION_METHODS = %w[
+      each map select reject flat_map filter_map find detect
+      each_with_index each_with_object collect sum min_by max_by
+      sort_by group_by
+    ].freeze
+
+    def initialize(root_path, rbi_index)
+      @root_path = root_path
+      @rbi_index = rbi_index
+    end
+
+    # Entry point for the ruby-lsp addon.
+    # Returns { type:, method: } or nil.
+    def resolve_from_call(call_node, program_node, nesting = nil)
+      return nil unless call_node
+
+      method_name = call_node.name.to_s
+      receiver    = call_node.receiver
+
+      unless receiver
+        type = infer_rspec_receiver(method_name)
+        return type ? { type: type, method: method_name } : nil
+      end
+
+      @_call_line = call_node.location.start_line
+      @_nesting   = nesting
+
+      type = resolve_receiver(receiver, program_node, nil)
+      return nil unless type
+
+      { type: type, method: method_name }
+    ensure
+      @_call_line = nil
+      @_nesting   = nil
+    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
+      resolve_receiver(receiver_node, program_node, nil)
+    ensure
+      @_nesting = nil
+    end
+
+    # Standalone server entry point. Returns { type:, method: } or nil.
+    def resolve_at(file, line, col)
+      return nil unless file && File.exist?(file)
+
+      source = File.read(file)
+      result = Prism.parse(source)
+
+      call = innermost_call_at(result.value, line, col)
+      return nil unless call
+
+      method_name = call.name.to_s
+      receiver    = call.receiver
+
+      unless receiver
+        type = infer_rspec_receiver(method_name)
+        return type ? { type: type, method: method_name } : nil
+      end
+
+      type = resolve_receiver(receiver, result.value, source)
+      return nil unless type
+
+      { type: type, method: method_name }
+    end
+
+    private
+
+    # ------------------------------------------------------------------
+    # AST walking helpers
+    # ------------------------------------------------------------------
+
+    def innermost_call_at(root, lsp_line, lsp_col)
+      target_line = lsp_line + 1
+
+      best = nil
+      walk(root) do |node|
+        next unless node.is_a?(Prism::CallNode)
+        loc = node.location
+        next unless covers?(loc, target_line, lsp_col)
+        best = node if best.nil? || span(node) < span(best)
+      end
+      best
+    end
+
+    def covers?(loc, line, col)
+      return false if line < loc.start_line || line > loc.end_line
+      return false if line == loc.start_line && col < loc.start_column
+      return false if line == loc.end_line   && col > loc.end_column
+      true
+    end
+
+    def span(node)
+      loc = node.location
+      (loc.end_line - loc.start_line) * 100_000 + (loc.end_column - loc.start_column)
+    end
+
+    def walk(node, &block)
+      return unless node.is_a?(Prism::Node)
+      block.call(node)
+      node.child_nodes.compact.each { |child| walk(child, &block) }
+    end
+
+    # ------------------------------------------------------------------
+    # Receiver resolution
+    # _seen guards against infinite recursion when local variables
+    # reference themselves (e.g. `entries = entries.first`).
+    # ------------------------------------------------------------------
+
+    def resolve_receiver(receiver, ast, source, _seen = [])
+      case receiver
+      when Prism::ConstantReadNode
+        const_name = receiver.name.to_s
+        resolve_constant(const_name, ast, source, _seen) || const_name
+      when Prism::ConstantPathNode
+        receiver.slice.delete_prefix("::")
+      when Prism::LocalVariableReadNode
+        name = receiver.name.to_s
+        guard = "lv:#{name}"
+        return nil if _seen.include?(guard)
+        find_local_var_type(name, ast, source, _seen + [guard])
+      when Prism::InstanceVariableReadNode
+        ivar  = receiver.name.to_s
+        guard = "iv:#{ivar}"
+        return nil if _seen.include?(guard)
+        find_ivar_type(ivar, ast, source, _seen + [guard])
+      when Prism::CallNode
+        # T.must(x) → resolve x
+        if receiver.name == :must && t_module?(receiver.receiver)
+          arg = receiver.arguments&.arguments&.first
+          return arg ? resolve_receiver(arg, ast, source, _seen) : nil
+        end
+        # T.cast(x, Type) / T.let(x, Type) → return Type
+        if (receiver.name == :cast || receiver.name == :let) && t_module?(receiver.receiver)
+          type_arg = receiver.arguments&.arguments&.[](1)
+          return type_arg ? type_from_node(type_arg) : nil
+        end
+        # Constructor: Foo.new(...) → instance type is Foo.
+        if receiver.name == :new && receiver.receiver
+          case receiver.receiver
+          when Prism::ConstantReadNode  then return receiver.receiver.name.to_s
+          when Prism::ConstantPathNode  then return receiver.receiver.slice.delete_prefix("::")
+          end
+        end
+        inner_type  = resolve_receiver(receiver.receiver, ast, source, _seen)
+        method_name = receiver.name.to_s
+        follow_chain(inner_type, method_name)
+      else
+        nil
+      end
+    end
+
+    def resolve_constant(const_name, ast, source, _seen = [])
+      AssignmentFinder.new(const_name).find(ast)&.then do |rhs|
+        resolve_rhs(rhs, ast, source, _seen)
+      end
+    end
+
+    def resolve_rhs(rhs, ast, source, _seen = [])
+      case rhs
+      when Prism::ConstantReadNode
+        rhs.name.to_s
+      when Prism::ConstantPathNode
+        rhs.slice.delete_prefix("::")
+      when Prism::CallNode
+        # Constructor shortcut — same reasoning as resolve_receiver.
+        if rhs.name == :new && rhs.receiver
+          case rhs.receiver
+          when Prism::ConstantReadNode  then return rhs.receiver.name.to_s
+          when Prism::ConstantPathNode  then return rhs.receiver.slice.delete_prefix("::")
+          end
+        end
+        inner_type  = resolve_receiver(rhs.receiver, ast, source, _seen)
+        method_name = rhs.name.to_s
+        follow_chain(inner_type, method_name)
+      else
+        nil
+      end
+    end
+
+    def follow_chain(type, method_name)
+      return type if PASSTHROUGH_METHODS.include?(method_name)
+      return nil unless type
+
+      clean = unwrap_sorbet_wrapper(type)
+      ret   = @rbi_index.return_type_for(clean, method_name)&.delete_prefix("::")
+      ret ? unwrap_sorbet_wrapper(ret) : nil
+    end
+
+    def unwrap_sorbet_wrapper(type)
+      return nil unless type
+      if (m = type.match(/\AT\.nilable\((.+)\)\z/))
+        return m[1].strip.delete_prefix("::")
+      end
+      if (m = type.match(/\AT\.any\((.+)\)\z/))
+        non_nil = m[1].split(",").map(&:strip).reject { |t| t =~ /\ANilClass\z/i }
+        return non_nil.first&.delete_prefix("::") unless non_nil.empty?
+      end
+      type
+    end
+
+    def t_module?(node)
+      node.is_a?(Prism::ConstantReadNode) && node.name == :T
+    end
+
+    def type_from_node(node)
+      case node
+      when Prism::ConstantReadNode then node.name.to_s
+      when Prism::ConstantPathNode then node.slice.delete_prefix("::")
+      end
+    end
+
+    def infer_rspec_receiver(method_name)
+      return "RSpec::Core::ExampleGroup" if RSPEC_EXAMPLE_GROUP_METHODS.include?(method_name)
+      return "RSpec" if RSPEC_MODULE_METHODS.include?(method_name)
+      nil
+    end
+
+    # ------------------------------------------------------------------
+    # Local variable type resolution
+    # ------------------------------------------------------------------
+
+    # Resolves the type of a local variable by:
+    #   1. Finding its most recent assignment and resolving the RHS.
+    #   2. Falling back to block parameter inference (entries.each { |e| }).
+    def find_local_var_type(var_name, ast, source, _seen = [])
+      # Direct assignments: var = <rhs>
+      LocalAssignmentFinder.new(var_name).find_all(ast).each do |rhs|
+        type = resolve_rhs(rhs, ast, source, _seen)
+        return type if type
+      end
+
+      # Strategy 2b: method parameter type from RBI sig
+      param_type = find_method_param_type(var_name)
+      return param_type if param_type
+
+      # Block parameter: method { |var| } — infer element type from receiver.
+      finder = BlockParamFinder.new(var_name)
+      finder.visit(ast)
+      return nil unless finder.enclosing_call&.receiver
+
+      call          = finder.enclosing_call
+      receiver_type = resolve_receiver(call.receiver, ast, source, _seen)
+      return nil unless receiver_type
+
+      method_name = call.name.to_s
+      if ENUMERATION_METHODS.include?(method_name)
+        extract_element_type(receiver_type)
+      else
+        ret = @rbi_index.return_type_for(receiver_type, method_name)
+        ret ? extract_element_type(ret) : nil
+      end
+    end
+
+    # Extracts X from generic types like T::Array[X], T::Enumerator[X].
+    # Resolves the type of an instance variable by scanning its assignments.
+    def find_ivar_type(ivar_name, ast, source, _seen = [])
+      IvarTypeFinder.new(ivar_name).find_all(ast).each do |rhs|
+        type = resolve_rhs(rhs, ast, source, _seen)
+        return type if type
+      end
+      nil
+    end
+
+    # Looks up the Sorbet-declared type of a method parameter from the RBI index.
+    # Requires @_call_line and @_nesting to be set (done in resolve_from_call).
+    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("::")
+      method_name  = EnclosingDefFinder.new(@_call_line).find(
+        @_nesting.find { |n| n.is_a?(Prism::ProgramNode) }
+      )
+      return nil unless method_name
+
+      params = @rbi_index.params_for(current_type, method_name)
+      raw    = params&.[](param_name)
+      raw ? unwrap_sorbet_wrapper(raw) : nil
+    end
+
+    def extract_element_type(type_str)
+      return nil unless type_str
+      m = type_str.match(/\[(\w+(?:::\w+)*)\]$/)
+      m&.[](1)
+    end
+
+    # ------------------------------------------------------------------
+    # Inner classes
+    # ------------------------------------------------------------------
+
+    # Collects all RHS nodes for `@ivar = rhs` and `@ivar ||= rhs` writes.
+    class IvarTypeFinder < Prism::Visitor
+      def initialize(ivar_name)
+        @ivar_name = ivar_name
+        @results   = []
+      end
+
+      def find_all(ast)
+        visit(ast)
+        @results
+      end
+
+      def visit_instance_variable_write_node(node)
+        @results << node.value if node.name.to_s == @ivar_name
+        super
+      end
+
+      def visit_instance_variable_or_write_node(node)
+        @results << node.value if node.name.to_s == @ivar_name
+        super
+      end
+    end
+
+    # Finds the name of the innermost def containing a target line.
+    class EnclosingDefFinder < Prism::Visitor
+      def initialize(target_line)
+        @target_line = target_line
+        @best_name   = nil
+        @best_span   = nil
+      end
+
+      def find(ast)
+        visit(ast)
+        @best_name
+      end
+
+      def visit_def_node(node)
+        loc = node.location
+        return super unless @target_line >= loc.start_line && @target_line <= loc.end_line
+
+        span = loc.end_line - loc.start_line
+        if @best_span.nil? || span < @best_span
+          @best_span = span
+          @best_name = node.name.to_s
+        end
+        super
+      end
+    end
+
+    class AssignmentFinder < Prism::Visitor
+      def initialize(const_name)
+        @const_name = const_name
+        @result     = nil
+      end
+
+      def find(ast)
+        visit(ast)
+        @result
+      end
+
+      def visit_constant_write_node(node)
+        @result = node.value if node.name.to_s == @const_name
+        super
+      end
+
+      def visit_constant_path_write_node(node)
+        @result = node.value if node.target.slice == @const_name
+        super
+      end
+    end
+
+    # Collects all RHS nodes for `var_name = <rhs>` local variable writes.
+    class LocalAssignmentFinder < Prism::Visitor
+      def initialize(var_name)
+        @var_name = var_name
+        @results  = []
+      end
+
+      def find_all(ast)
+        visit(ast)
+        @results
+      end
+
+      def visit_local_variable_write_node(node)
+        @results << node.value if node.name.to_s == @var_name
+        super
+      end
+
+      def visit_local_variable_operator_write_node(node)
+        @results << node.value if node.name.to_s == @var_name
+        super
+      end
+
+      def visit_local_variable_or_write_node(node)
+        @results << node.value if node.name.to_s == @var_name
+        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
+      attr_reader :enclosing_call
+
+      def initialize(var_name)
+        @var_name       = var_name
+        @enclosing_call = nil
+        @call_stack     = []
+      end
+
+      def visit_call_node(node)
+        @call_stack.push(node)
+        super
+        @call_stack.pop
+      end
+
+      def visit_block_node(node)
+        return super if @enclosing_call
+
+        # BlockParametersNode wraps a ParametersNode which holds .requireds
+        block_params = node.parameters
+        return super unless block_params
+
+        inner = block_params.is_a?(Prism::BlockParametersNode) ? block_params.parameters : block_params
+        return super unless inner
+
+        found = inner.requireds&.any? do |p|
+          p.is_a?(Prism::RequiredParameterNode) && p.name.to_s == @var_name
+        end
+
+        if found
+          @enclosing_call = @call_stack.last
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/pink_spoon/definition_finder.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module PinkSpoon
+  # Maps a fully-qualified type + method name to a source file and line number
+  # inside the installed gem.
+  #
+  # Strategy:
+  #   1. Convert the type name to a likely gem name (heuristic + Bundler lookup).
+  #   2. Find the gem's source directory via Gem::Specification.
+  #   3. Convert the type to a file path (Prometheus::Client::Gauge → prometheus/client/gauge.rb).
+  #   4. Parse that file with Prism and find the def line.
+  #   5. If not found in the direct file, walk parent classes via Prism.
+  class DefinitionFinder
+    def initialize(root_path)
+      @root_path = root_path
+      setup_bundler
+    end
+
+    # Returns { file: absolute_path, line: integer } or nil.
+    def find(type, method_name)
+      return nil unless type && method_name
+
+      candidates = candidate_files(type)
+      candidates.each do |file|
+        next unless File.exist?(file)
+        line = method_line(file, method_name.to_s)
+        return { file: file, line: line } if line
+      end
+
+      nil
+    end
+
+    private
+
+    def setup_bundler
+      gemfile = File.join(@root_path, "Gemfile")
+      return unless File.exist?(gemfile)
+
+      # Load Bundler's gem paths without clobbering the current environment.
+      require "bundler"
+      Bundler.load.specs  # warm the spec cache
+    rescue => e
+      $stderr.puts "[pink-spoon] Bundler setup skipped: #{e.message}"
+    end
+
+    # ------------------------------------------------------------------
+    # Build a list of candidate source files for the given type.
+    # ------------------------------------------------------------------
+    def candidate_files(type)
+      parts = type.delete_prefix("::").split("::")
+
+      files = []
+
+      parts.length.downto(1) do |depth|
+        tail = parts.last(depth)
+
+        # Generate two suffix variants: standard underscore and a form where the
+        # first component is simply lowercased (handles acronyms like RSpec → rspec
+        # vs the incorrect underscore form r_spec).
+        suffixes = [
+          tail.map { |p| underscore(p) }.join("/") + ".rb",
+          ([tail.first.downcase] + tail.drop(1).map { |p| underscore(p) }).join("/") + ".rb",
+        ].uniq
+
+        # Use both underscore and plain-downcase as gem hints for the same reason.
+        gem_hints = [underscore(parts.first), parts.first.downcase].uniq
+
+        gem_hints.each do |hint|
+          gem_dirs_for(hint).each do |gem_dir|
+            suffixes.each do |suffix|
+              files << File.join(gem_dir, "lib", suffix)
+              files << File.join(gem_dir, suffix)
+            end
+          end
+        end
+
+        # Broader fallback: try all gem dirs.
+        all_gem_dirs.each do |gem_dir|
+          suffixes.each do |suffix|
+            files << File.join(gem_dir, "lib", suffix)
+          end
+        end
+      end
+
+      files.uniq
+    end
+
+    # Gem dirs whose name starts with the hint (e.g. "prometheus" → prometheus-client-*).
+    def gem_dirs_for(hint)
+      Gem::Specification.each.filter_map do |spec|
+        spec.gem_dir if spec.name.start_with?(hint) || spec.name.include?(hint)
+      end
+    rescue
+      []
+    end
+
+    def all_gem_dirs
+      @all_gem_dirs ||= Gem::Specification.map(&:gem_dir)
+    rescue
+      []
+    end
+
+    # ------------------------------------------------------------------
+    # Find the line number of `def method_name` inside a Ruby file.
+    # ------------------------------------------------------------------
+    def method_line(file, method_name)
+      result = Prism.parse_file(file)
+      finder = DefFinder.new(method_name)
+      finder.visit(result.value)
+      finder.line
+    rescue
+      nil
+    end
+
+    def underscore(str)
+      str
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase
+        .tr("-", "_")
+    end
+
+    # ------------------------------------------------------------------
+    # Finds the line of `def <name>` in a parsed AST.
+    # ------------------------------------------------------------------
+    class DefFinder < Prism::Visitor
+      attr_reader :line
+
+      def initialize(method_name)
+        @method_name = method_name
+        @line        = nil
+      end
+
+      def visit_def_node(node)
+        if node.name.to_s == @method_name
+          @line ||= node.location.start_line
+        end
+        super
+      end
+    end
+  end
+end