pink_spoon 0.1.0

data/lib/pink_spoon/server.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "rbi_index"
+require_relative "constant_resolver"
+require_relative "definition_finder"
+
+module PinkSpoon
+  # JSON-RPC 2.0 server over stdin/stdout.
+  # Implements only initialize, textDocument/definition, and textDocument/hover.
+  # Every other request gets a null result so clients don't hang.
+  class Server
+    def initialize
+      @rbi_index        = nil  # built lazily after initialize gives us the project root
+      @constant_resolver = nil
+      @definition_finder = nil
+    end
+
+    def run
+      $stdout.sync = true
+      $stderr.sync = true
+
+      loop do
+        header = read_header
+        break unless header
+
+        length = header[/Content-Length:\s*(\d+)/i, 1]&.to_i
+        next unless length&.positive?
+
+        body = $stdin.read(length)
+        next unless body
+
+        request = JSON.parse(body, symbolize_names: true)
+        handle(request)
+      end
+    end
+
+    private
+
+    # ------------------------------------------------------------------
+    # Request routing
+    # ------------------------------------------------------------------
+
+    def handle(req)
+      id     = req[:id]
+      method = req[:method]
+
+      case method
+      when "initialize"
+        on_initialize(id, req[:params])
+      when "initialized"
+        # notification, no response needed
+      when "shutdown"
+        write_response(id, nil)
+      when "exit"
+        exit(0)
+      when "textDocument/definition"
+        write_response(id, on_definition(req[:params]))
+      when "textDocument/hover"
+        write_response(id, on_hover(req[:params]))
+      else
+        # Return null for anything we don't handle so the client moves on.
+        write_response(id, nil) if id
+      end
+    rescue => e
+      $stderr.puts "[pink-spoon] error handling #{req[:method]}: #{e.class}: #{e.message}"
+      $stderr.puts e.backtrace.first(10).join("\n")
+      write_error(id, -32_603, e.message) if id
+    end
+
+    # ------------------------------------------------------------------
+    # Handlers
+    # ------------------------------------------------------------------
+
+    def on_initialize(id, params)
+      root_uri = params&.dig(:rootUri) || params&.dig(:rootPath)
+      root_path = root_uri&.delete_prefix("file://") || Dir.pwd
+
+      @rbi_index         = RbiIndex.new(root_path)
+      @constant_resolver = ConstantResolver.new(root_path, @rbi_index)
+      @definition_finder = DefinitionFinder.new(root_path)
+
+      write_response(id, {
+        capabilities: {
+          definitionProvider: true,
+          hoverProvider:      true,
+        },
+        serverInfo: { name: "pink-spoon", version: "0.1.0" },
+      })
+    end
+
+    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)
+
+      resolved = @constant_resolver.resolve_at(file, line, col)
+      return nil unless resolved
+
+      location = @definition_finder.find(resolved[:type], resolved[:method])
+      return nil unless location
+
+      {
+        uri:   path_to_uri(location[:file]),
+        range: {
+          start: { line: location[:line] - 1, character: 0 },
+          end:   { line: location[:line] - 1, character: 0 },
+        },
+      }
+    end
+
+    def on_hover(params)
+      return nil unless @rbi_index
+
+      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
+
+      sig = @rbi_index.signature_for(resolved[:type], resolved[:method])
+      return nil unless sig
+
+      {
+        contents: {
+          kind:  "markdown",
+          value: "```ruby\n#{sig}\n```",
+        },
+      }
+    end
+
+    # ------------------------------------------------------------------
+    # Protocol helpers
+    # ------------------------------------------------------------------
+
+    def read_header
+      lines = []
+      loop do
+        line = $stdin.gets
+        return nil if line.nil?
+        break if line.strip.empty?
+        lines << line.strip
+      end
+      lines.empty? ? nil : lines.join("\n")
+    end
+
+    def write_response(id, result)
+      return unless id
+      body = JSON.generate({ jsonrpc: "2.0", id: id, result: result })
+      $stdout.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+    end
+
+    def write_error(id, code, message)
+      body = JSON.generate({
+        jsonrpc: "2.0",
+        id:      id,
+        error:   { code: code, message: message },
+      })
+      $stdout.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+    end
+
+    def uri_to_path(uri)
+      uri&.delete_prefix("file://")
+    end
+
+    def path_to_uri(path)
+      "file://#{path}"
+    end
+  end
+end

data/lib/pink_spoon/version.rb

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

data/lib/pink_spoon.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "pink_spoon/rbi_index"
+require_relative "pink_spoon/constant_resolver"
+require_relative "pink_spoon/definition_finder"
+require_relative "pink_spoon/doc_extractor"
+require_relative "pink_spoon/server"

data/lib/ruby_lsp/pink_spoon/addon.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+
+require_relative "../../pink_spoon/version"
+require_relative "../../pink_spoon/rbi_index"
+require_relative "../../pink_spoon/constant_resolver"
+require_relative "../../pink_spoon/doc_extractor"
+require_relative "hover_listener"
+require_relative "definition_listener"
+require_relative "completion_listener"
+require_relative "code_lens_listener"
+
+module RubyLsp
+  module PinkSpoon
+    class Addon < ::RubyLsp::Addon
+      def activate(global_state, outgoing_queue)
+        root = global_state.workspace_path
+
+        @rbi_index         = ::PinkSpoon::RbiIndex.new(root)
+        @constant_resolver = ::PinkSpoon::ConstantResolver.new(root, @rbi_index)
+        @doc_extractor     = ::PinkSpoon::DocExtractor.new(root)
+      end
+
+      def deactivate; end
+
+      def name    = "Pink Spoon"
+      def version = ::PinkSpoon::VERSION
+
+      # @override
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        HoverListener.new(response_builder, node_context, dispatcher, @constant_resolver, @rbi_index, @doc_extractor)
+      end
+
+      # @override
+      def create_definition_listener(response_builder, uri, node_context, dispatcher)
+        DefinitionListener.new(response_builder, uri, node_context, dispatcher, @constant_resolver, @rbi_index, @doc_extractor)
+      end
+
+      # @override
+      def create_completion_listener(response_builder, node_context, dispatcher, uri)
+        CompletionListener.new(response_builder, node_context, dispatcher, uri, @constant_resolver, @rbi_index)
+      end
+
+      # @override
+      def create_code_lens_listener(response_builder, uri, dispatcher)
+        CodeLensListener.new(response_builder, uri, dispatcher)
+      end
+
+    end
+  end
+end

data/lib/ruby_lsp/pink_spoon/code_lens_listener.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module PinkSpoon
+    # Fired on every textDocument/codeLens request.
+    # Adds "Run" / "Run in watch mode" code lenses next to RSpec
+    # describe/context/it blocks.
+    class CodeLensListener
+      RSPEC_GROUP_METHODS   = %w[describe context feature scenario].freeze
+      RSPEC_EXAMPLE_METHODS = %w[it example specify scenario].freeze
+
+      def initialize(response_builder, uri, dispatcher)
+        @response_builder = response_builder
+        @uri              = uri
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        method_name = node.name.to_s
+        return unless RSPEC_GROUP_METHODS.include?(method_name) ||
+                      RSPEC_EXAMPLE_METHODS.include?(method_name)
+        return if node.receiver  # only bare calls (RSpec DSL)
+
+        description = extract_description(node)
+        line        = node.location.start_line - 1  # 0-based
+
+        range = Interface::Range.new(
+          start: Interface::Position.new(line: line, character: 0),
+          end:   Interface::Position.new(line: line, character: 0),
+        )
+
+        @response_builder << Interface::CodeLens.new(
+          range:   range,
+          command: Interface::Command.new(
+            title:     "▶ Run",
+            command:   "rubyLsp.runTest",
+            arguments: [{ uri: @uri.to_s, name: description, line: line }],
+          ),
+        )
+      end
+
+      private
+
+      def extract_description(node)
+        first_arg = node.arguments&.arguments&.first
+        case first_arg
+        when Prism::StringNode        then first_arg.unescaped
+        when Prism::ConstantReadNode  then first_arg.name.to_s
+        when Prism::ConstantPathNode  then first_arg.slice
+        else
+          node.name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/pink_spoon/completion_listener.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module PinkSpoon
+    # Fired on every textDocument/completion request.
+    #
+    # Handles three completion modes:
+    #   1. Receiver-qualified call (GAUGE.)  → RBI methods for that type.
+    #   2. Bare call / partial identifier    → locals in scope + class methods
+    #                                          from RBI + defs in file + RSpec DSL.
+    class CompletionListener
+      RSPEC_COMPLETIONS = [
+        { name: "describe",           snippet: "describe $1 do\n  $0\nend",                      detail: "RSpec · example group" },
+        { name: "context",            snippet: "context \"$1\" do\n  $0\nend",                   detail: "RSpec · example group" },
+        { name: "it",                 snippet: "it \"$1\" do\n  $0\nend",                        detail: "RSpec · example" },
+        { name: "example",            snippet: "example \"$1\" do\n  $0\nend",                   detail: "RSpec · example (alias)" },
+        { name: "specify",            snippet: "specify \"$1\" do\n  $0\nend",                   detail: "RSpec · example (alias)" },
+        { name: "let",                snippet: "let(:$1) { $0 }",                                detail: "RSpec · memoized helper" },
+        { name: "let!",               snippet: "let!(:$1) { $0 }",                               detail: "RSpec · eager helper" },
+        { name: "subject",            snippet: "subject { $0 }",                                 detail: "RSpec · subject" },
+        { name: "subject!",           snippet: "subject!(:$1) { $0 }",                          detail: "RSpec · named subject" },
+        { name: "before",             snippet: "before do\n  $0\nend",                           detail: "RSpec · before hook" },
+        { name: "after",              snippet: "after do\n  $0\nend",                            detail: "RSpec · after hook" },
+        { name: "around",             snippet: "around do |example|\n  $0\n  example.run\nend", detail: "RSpec · around hook" },
+        { name: "shared_examples",    snippet: "shared_examples \"$1\" do\n  $0\nend",           detail: "RSpec · shared examples" },
+        { name: "shared_context",     snippet: "shared_context \"$1\" do\n  $0\nend",            detail: "RSpec · shared context" },
+        { name: "include_context",    snippet: "include_context \"$1\"",                         detail: "RSpec · include shared context" },
+        { name: "include_examples",   snippet: "include_examples \"$1\"",                       detail: "RSpec · include shared examples" },
+        { name: "pending",            snippet: "pending \"$1\"",                                 detail: "RSpec · mark pending" },
+        { name: "skip",               snippet: "skip \"$1\"",                                   detail: "RSpec · skip example" },
+        { name: "aggregate_failures", snippet: "aggregate_failures do\n  $0\nend",              detail: "RSpec · collect failures" },
+      ].freeze
+
+      COMPLETION_KIND_METHOD   = 2
+      COMPLETION_KIND_VARIABLE = 6
+      INSERT_FORMAT_SNIPPET    = 2
+      INSERT_FORMAT_PLAINTEXT  = 1
+
+      def initialize(response_builder, node_context, dispatcher, uri, resolver, rbi_index)
+        @response_builder = response_builder
+        @node_context     = node_context
+        @resolver         = resolver
+        @rbi_index        = rbi_index
+        @uri              = uri
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_local_variable_read_node_enter,
+        )
+      end
+
+      def on_call_node_enter(node)
+        return unless node.equal?(@node_context.node)
+
+        if node.receiver
+          offer_method_completions(node)
+        else
+          offer_bare_completions(node.name.to_s, node)
+        end
+      end
+
+      # Partial identifier with no parens (e.g. `con` → `context`, `cre` → `creditor_city`).
+      def on_local_variable_read_node_enter(node)
+        return unless node.equal?(@node_context.node)
+        offer_bare_completions(node.name.to_s, node)
+      end
+
+      private
+
+      # ----------------------------------------------------------------
+      # Receiver-qualified completions: GAUGE.inc → enumerate RBI methods.
+      # ----------------------------------------------------------------
+      def offer_method_completions(node)
+        nesting      = @node_context.instance_variable_get(:@nesting_nodes)
+        program_node = nesting&.find { |n| n.is_a?(Prism::ProgramNode) }
+        return unless program_node
+
+        type = @resolver.resolve_receiver_type(node.receiver, program_node, nesting)
+        return unless type
+
+        range = loc_to_range(node.message_loc || node.location)
+
+        @rbi_index.methods_for(type).each do |method_name, sig_or_def|
+          @response_builder << Interface::CompletionItem.new(
+            label:              method_name,
+            filter_text:        method_name,
+            kind:               COMPLETION_KIND_METHOD,
+            detail:             sig_or_def&.then { |s| s.start_with?("sig") ? s : nil },
+            text_edit:          Interface::TextEdit.new(range: range, new_text: method_name),
+            insert_text_format: INSERT_FORMAT_PLAINTEXT,
+          )
+        end
+      end
+
+      # ----------------------------------------------------------------
+      # Bare completions: locals + class methods + file defs + RSpec DSL.
+      # ----------------------------------------------------------------
+      def offer_bare_completions(partial, node)
+        range = loc_to_range(
+          node.is_a?(Prism::CallNode) ? (node.message_loc || node.location) : node.location,
+        )
+
+        offer_local_var_completions(partial, range)
+        offer_class_method_completions(partial, range)
+        offer_file_def_completions(partial, range)
+        offer_rspec_completions(partial, range)
+      end
+
+      # Local variables in the current scope from NodeContext.
+      def offer_local_var_completions(partial, range)
+        @node_context.locals_for_scope.each do |sym|
+          name = sym.to_s
+          next unless partial.empty? || name.start_with?(partial)
+
+          @response_builder << Interface::CompletionItem.new(
+            label:              name,
+            filter_text:        name,
+            kind:               COMPLETION_KIND_VARIABLE,
+            detail:             "local variable",
+            text_edit:          Interface::TextEdit.new(range: range, new_text: name),
+            insert_text_format: INSERT_FORMAT_PLAINTEXT,
+          )
+        end
+      end
+
+      # Methods of the current class from the RBI index (handles typed mixins/parents).
+      def offer_class_method_completions(partial, range)
+        type = @node_context.fully_qualified_name
+        return unless type && !type.empty?
+
+        @rbi_index.methods_for(type).each do |method_name, sig_or_def|
+          next unless partial.empty? || method_name.start_with?(partial)
+
+          @response_builder << Interface::CompletionItem.new(
+            label:              method_name,
+            filter_text:        method_name,
+            kind:               COMPLETION_KIND_METHOD,
+            detail:             sig_or_def&.then { |s| s.start_with?("sig") ? s : nil },
+            text_edit:          Interface::TextEdit.new(range: range, new_text: method_name),
+            insert_text_format: INSERT_FORMAT_PLAINTEXT,
+          )
+        end
+      end
+
+      # Scans the current file for `def method_name` lines — catches project-defined
+      # methods that aren't in any RBI (e.g. `creditor_city_enabled?`).
+      def offer_file_def_completions(partial, range)
+        file = @uri.to_s.delete_prefix("file://")
+        return unless file && File.exist?(file)
+
+        seen = {}
+        File.foreach(file) do |line|
+          m = line.match(/\bdef\s+(?:self\.)?(\w[\w!?]*)/)
+          next unless m
+
+          name = m[1]
+          next if seen[name]
+          next unless partial.empty? || name.start_with?(partial)
+
+          seen[name] = true
+          @response_builder << Interface::CompletionItem.new(
+            label:              name,
+            filter_text:        name,
+            kind:               COMPLETION_KIND_METHOD,
+            detail:             "def",
+            text_edit:          Interface::TextEdit.new(range: range, new_text: name),
+            insert_text_format: INSERT_FORMAT_PLAINTEXT,
+          )
+        end
+      rescue
+        nil
+      end
+
+      # RSpec DSL snippets with tab stops.
+      def offer_rspec_completions(partial, range)
+        RSPEC_COMPLETIONS.each do |item|
+          next unless partial.empty? || item[:name].start_with?(partial)
+
+          @response_builder << Interface::CompletionItem.new(
+            label:              item[:name],
+            filter_text:        item[:name],
+            kind:               COMPLETION_KIND_METHOD,
+            detail:             item[:detail],
+            text_edit:          Interface::TextEdit.new(range: range, new_text: item[:snippet]),
+            insert_text_format: INSERT_FORMAT_SNIPPET,
+          )
+        end
+      end
+
+      # Converts a Prism location (1-based lines) to an LSP Range (0-based).
+      def loc_to_range(loc)
+        Interface::Range.new(
+          start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
+          end:   Interface::Position.new(line: loc.end_line - 1,   character: loc.end_column),
+        )
+      end
+    end
+  end
+end