rigortype 0.1.4 → 0.1.6

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+require_relative "uri"
+require_relative "../analysis/runner"
+require_relative "../analysis/buffer_binding"
+
+module Rigor
+  module LanguageServer
+    # Converts buffer state into `textDocument/publishDiagnostics`
+    # notifications. Owns the Rigor `Analysis::Runner` orchestration
+    # for the per-buffer single-file scope path that editor mode v1
+    # already supports — every `publish_for(uri)` call materialises
+    # a `BufferBinding` from the BufferTable entry, runs the Runner,
+    # and pushes the resulting LSP `Diagnostic[]` through the writer.
+    #
+    # Slice 4 is synchronous: each call blocks until analysis
+    # completes (typically 100-300ms warm). Debouncing (200ms
+    # quiet-time before publish) and Ractor-pool dispatch are
+    # queued for slice 4b / slice 8 respectively.
+    class DiagnosticPublisher
+      # Maps Rigor severity symbols to LSP DiagnosticSeverity
+      # integers per spec § "Diagnostic":
+      #   1 = Error, 2 = Warning, 3 = Information, 4 = Hint.
+      SEVERITY_MAP = {
+        error: 1,
+        warning: 2,
+        info: 3,
+        hint: 4
+      }.freeze
+
+      # @param debouncer [Rigor::LanguageServer::Debouncer, nil]
+      #   when present, `publish_for` schedules its work through
+      #   the debouncer (cancels prior pending task for the same
+      #   URI, fires after `debounce_seconds` quiet-time). Nil
+      #   keeps the slice 4-7 synchronous behaviour — primarily
+      #   useful for specs.
+      # @param debounce_seconds [Numeric] quiet-time before the
+      #   debounced publish fires. 0 with a debouncer means
+      #   "schedule on next-tick" (still async); without a
+      #   debouncer the value is unused.
+      def initialize(writer:, buffer_table:, project_context:,
+                     debouncer: nil, debounce_seconds: 0.2)
+        @writer = writer
+        @buffer_table = buffer_table
+        @project_context = project_context
+        @debouncer = debouncer
+        @debounce_seconds = debounce_seconds
+      end
+
+      # Run analysis for the buffer at `uri` (looked up in the
+      # BufferTable) and push a `textDocument/publishDiagnostics`
+      # notification. No-op when the URI isn't a `file://` form or
+      # the buffer isn't currently open. When a Debouncer is wired,
+      # the analysis is scheduled async per the configured
+      # `debounce_seconds`; otherwise it runs inline.
+      def publish_for(uri)
+        path = Uri.to_path(uri)
+        return if path.nil?
+
+        if @debouncer
+          @debouncer.schedule(uri, delay: @debounce_seconds) { run_and_notify(uri, path) }
+        else
+          run_and_notify(uri, path)
+        end
+      end
+
+      # Publishes an EMPTY diagnostic array for `uri`. The LSP-spec
+      # idiom for "clear inline markers" — called from `didClose`
+      # so clients drop stale highlights when the user closes a
+      # buffer.
+      def publish_empty(uri)
+        notify(uri, [])
+      end
+
+      # Cancels every in-flight debounced task. Called from
+      # `Server#handle_shutdown` so pending publishes don't fire
+      # against a closed STDOUT.
+      def cancel_pending
+        @debouncer&.cancel_all
+      end
+
+      private
+
+      def run_and_notify(uri, path)
+        entry = @buffer_table[uri]
+        # The buffer may have been closed during the debounce
+        # window — drop the publish; the empty notification from
+        # didClose already cleared the markers.
+        return if entry.nil?
+
+        diagnostics = run_analysis(path: path, bytes: entry.bytes)
+        notify(uri, diagnostics)
+      end
+
+      # Runs `Analysis::Runner` with a `BufferBinding` so the buffer
+      # bytes (instead of the on-disk file) drive the parse. The
+      # `Rigor::Analysis::ProjectScan` cached on the ProjectContext
+      # is passed through `prebuilt:` so plugin `#prepare`, the
+      # dependency-source walker, and the synthetic-method /
+      # project-patched scanners do not re-run per publish. The
+      # snapshot rebuilds only when `ProjectContext#invalidate!`
+      # fires (watched-file or configuration change). Returns
+      # the LSP-shaped Diagnostic Array, ready to serialize into
+      # the notification's `params.diagnostics` field.
+      def run_analysis(path:, bytes:)
+        with_tempfile(bytes) do |tmp|
+          binding = Analysis::BufferBinding.new(logical_path: path, physical_path: tmp.path)
+          runner = Analysis::Runner.new(
+            configuration: @project_context.configuration,
+            cache_store: @project_context.cache_store,
+            collect_stats: false,
+            buffer: binding,
+            prebuilt: @project_context.project_scan,
+            environment: @project_context.environment
+          )
+          result = runner.run([path])
+          result.diagnostics.filter_map { |diagnostic| to_lsp_diagnostic(diagnostic, path) }
+        end
+      end
+
+      def with_tempfile(bytes)
+        tmp = Tempfile.new(["rigor-lsp-buffer-", ".rb"])
+        tmp.write(bytes)
+        tmp.flush
+        yield tmp
+      ensure
+        tmp&.close
+        tmp&.unlink
+      end
+
+      # @return [Hash, nil] the LSP `Diagnostic` Hash, or nil to
+      #   skip diagnostics outside the buffer's own path (e.g.
+      #   `.rigor.yml`-anchored info diagnostics get filtered —
+      #   they belong to the project, not the buffer).
+      def to_lsp_diagnostic(diagnostic, buffer_path)
+        return nil if diagnostic.path != buffer_path
+
+        # Rigor uses 1-based line + 1-based byte column; LSP uses
+        # 0-based line + 0-based UTF-16 code unit. UTF-16 conversion
+        # is queued (design doc § "Open questions"); v1 emits byte
+        # columns which are correct for ASCII source.
+        line = (diagnostic.line - 1).clamp(0, Float::INFINITY).to_i
+        character = (diagnostic.column - 1).clamp(0, Float::INFINITY).to_i
+
+        {
+          range: {
+            start: { line: line, character: character },
+            end: { line: line, character: character }
+          },
+          severity: SEVERITY_MAP.fetch(diagnostic.severity, 3),
+          code: diagnostic.rule,
+          source: "rigor",
+          message: diagnostic.message
+        }.compact
+      end
+
+      def notify(uri, diagnostics)
+        @writer.write(
+          method: "textDocument/publishDiagnostics",
+          params: { uri: uri, diagnostics: diagnostics }
+        )
+      end
+    end
+  end
+end

data/lib/rigor/language_server/document_symbol_provider.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "uri"
+
+module Rigor
+  module LanguageServer
+    # Answers `textDocument/documentSymbol` requests by walking the
+    # Prism AST and emitting one LSP `DocumentSymbol` per
+    # `ClassNode` / `ModuleNode` / `DefNode`. Nested classes /
+    # modules / methods nest in the `children` array so the editor's
+    # outline tree mirrors the source structure.
+    #
+    # SymbolKind mapping (LSP § "SymbolKind"):
+    # - Class       (5)  — `class Foo`
+    # - Module      (2)  — `module Foo`
+    # - Method      (6)  — `def m` inside a class / module
+    # - Function    (12) — `def m` at top-level (no enclosing class)
+    class DocumentSymbolProvider
+      KIND_MODULE   = 2
+      KIND_CLASS    = 5
+      KIND_METHOD   = 6
+      KIND_FUNCTION = 12
+
+      def initialize(buffer_table:, project_context:)
+        @buffer_table = buffer_table
+        @project_context = project_context
+      end
+
+      # @return [Array<Hash>, nil] LSP `DocumentSymbol[]` for the
+      #   buffer at `uri`. Returns nil when the URI isn't open or
+      #   doesn't parse cleanly enough to surface symbols — LSP
+      #   clients fall back to no-outline in that case.
+      def provide(uri)
+        path = Uri.to_path(uri)
+        return nil if path.nil?
+
+        entry = @buffer_table[uri]
+        return nil if entry.nil?
+
+        parse_result = Prism.parse(entry.bytes, filepath: path,
+                                                version: @project_context.configuration.target_ruby)
+        # Tolerate partial parse errors: walk what Prism gave us
+        # anyway. Editors prefer a stale outline over no outline.
+        walk_top_level(parse_result.value)
+      end
+
+      private
+
+      def walk_top_level(root)
+        symbols = []
+        each_decl(root, in_namespace: false) { |s| symbols << s }
+        symbols
+      end
+
+      def each_decl(node, in_namespace:, &block)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode
+          children = []
+          each_decl(node.body, in_namespace: true) { |child| children << child } if node.body
+          block.call(class_symbol(node, children))
+        when Prism::ModuleNode
+          children = []
+          each_decl(node.body, in_namespace: true) { |child| children << child } if node.body
+          block.call(module_symbol(node, children))
+        when Prism::DefNode
+          block.call(def_symbol(node, in_namespace: in_namespace))
+        else
+          node.compact_child_nodes.each do |child|
+            each_decl(child, in_namespace: in_namespace, &block)
+          end
+        end
+      end
+
+      def class_symbol(node, children)
+        {
+          name: qualified_name_of(node.constant_path),
+          kind: KIND_CLASS,
+          range: range_from(node.location),
+          selectionRange: range_from(node.constant_path.location),
+          children: children
+        }
+      end
+
+      def module_symbol(node, children)
+        {
+          name: qualified_name_of(node.constant_path),
+          kind: KIND_MODULE,
+          range: range_from(node.location),
+          selectionRange: range_from(node.constant_path.location),
+          children: children
+        }
+      end
+
+      def def_symbol(node, in_namespace:)
+        name = node.name.to_s
+        # `def self.foo` (singleton-class) → singleton-method shape.
+        # We surface the same as instance methods in v1 (LSP kind
+        # has no distinct "ClassMethod" code); the textual `self.`
+        # prefix preserves the distinction visually.
+        display_name = node.receiver.is_a?(Prism::SelfNode) ? "self.#{name}" : name
+        {
+          name: display_name,
+          kind: in_namespace ? KIND_METHOD : KIND_FUNCTION,
+          range: range_from(node.location),
+          selectionRange: range_from(node.name_loc),
+          children: []
+        }
+      end
+
+      # Renders a `ConstantReadNode` / `ConstantPathNode` as its
+      # fully-qualified name string (e.g. `Foo::Bar::Baz`). Returns
+      # the slot-name source when the node shape is unrecognised so
+      # the outline still has something to display.
+      def qualified_name_of(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent.nil? ? nil : qualified_name_of(node.parent)
+          parent.nil? ? node.name.to_s : "#{parent}::#{node.name}"
+        else
+          node.respond_to?(:slice) ? node.slice : "<unknown>"
+        end
+      end
+
+      # LSP `Range` is 0-based start + end with `character` in
+      # UTF-16 code units. Slice 6 emits byte columns (correct for
+      # ASCII source); UTF-16 conversion stays queued per design
+      # doc § "Open questions".
+      def range_from(location)
+        {
+          start: { line: location.start_line - 1, character: location.start_column },
+          end: { line: location.end_line - 1, character: location.end_column }
+        }
+      end
+    end
+  end
+end

data/lib/rigor/language_server/folding_range_provider.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "uri"
+
+module Rigor
+  module LanguageServer
+    # Answers `textDocument/foldingRange` requests. Walks the Prism
+    # AST and emits one `FoldingRange` per foldable construct:
+    # `class` / `module` / `def` / `singleton class << self` /
+    # block (`do…end` or `{…}`). Skips single-line constructs
+    # (start_line == end_line) since there's nothing to fold.
+    #
+    # Ranges are LSP 0-based. `startLine` is the line containing
+    # the opening keyword (`class`, `def`); `endLine` is the last
+    # line OF the body — one line before the `end` keyword — so
+    # collapsed view shows the opener intact and hides the body
+    # only.
+    class FoldingRangeProvider
+      def initialize(buffer_table:, project_context:)
+        @buffer_table = buffer_table
+        @project_context = project_context
+      end
+
+      # @return [Array<Hash>, nil] LSP `FoldingRange[]` for the
+      #   buffer, or nil when the URI isn't open / parseable.
+      def provide(uri)
+        path = Uri.to_path(uri)
+        return nil if path.nil?
+
+        entry = @buffer_table[uri]
+        return nil if entry.nil?
+
+        parse_result = Prism.parse(entry.bytes, filepath: path,
+                                                version: @project_context.configuration.target_ruby)
+        # Tolerate partial parse errors — fold whatever AST Prism
+        # produced. Editors prefer a stale outline / fold map
+        # over none.
+        ranges = []
+        walk(parse_result.value, ranges)
+        ranges
+      end
+
+      private
+
+      def walk(node, ranges)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode,
+             Prism::SingletonClassNode, Prism::DefNode,
+             Prism::BlockNode
+          add_range(node, ranges)
+        end
+        node.compact_child_nodes.each { |child| walk(child, ranges) }
+      end
+
+      def add_range(node, ranges)
+        loc = node.location
+        start_line = loc.start_line - 1
+        # `end_line` includes the line of the `end` keyword.
+        # Folding should hide the body and leave both the opener
+        # AND the `end` keyword visible — so endLine is one line
+        # before `end`. When the body is a single line, that
+        # makes start == end (one-line fold), which most editors
+        # skip; we filter those out.
+        end_line = loc.end_line - 2
+        return if end_line <= start_line
+
+        ranges << { startLine: start_line, endLine: end_line }
+      end
+    end
+  end
+end

data/lib/rigor/language_server/hover_provider.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "uri"
+require_relative "hover_renderer"
+require_relative "../environment"
+require_relative "../scope"
+require_relative "../source/node_locator"
+require_relative "../inference/scope_indexer"
+
+module Rigor
+  module LanguageServer
+    # Answers `textDocument/hover` requests by running the same
+    # NodeLocator + ScopeIndexer + `Scope#type_of` chain that
+    # `rigor type-of` already drives. The LSP wraps the result in a
+    # `Hover` payload with markdown contents.
+    #
+    # Per LSP spec § "Position":
+    # - `line` and `character` are 0-based.
+    # - `character` counts UTF-16 code units; v1 emits byte counts
+    #   for ASCII source (UTF-16 conversion is queued, see design
+    #   doc § "Open questions").
+    class HoverProvider
+      def initialize(buffer_table:, project_context:, renderer: HoverRenderer.new)
+        @buffer_table = buffer_table
+        @project_context = project_context
+        @renderer = renderer
+      end
+
+      # @return [Hash, nil] an LSP `Hover` payload or nil when no
+      #   expression sits at the queried position. Returning nil
+      #   maps to `result: null` per the LSP spec — clients
+      #   suppress the hover popup in that case.
+      def provide(uri:, line:, character:)
+        path = Uri.to_path(uri)
+        return nil if path.nil?
+
+        entry = @buffer_table[uri]
+        return nil if entry.nil?
+
+        parse_result = Prism.parse(entry.bytes, filepath: path, version: @project_context.configuration.target_ruby)
+        return nil unless parse_result.errors.empty?
+
+        # Rigor's NodeLocator uses 1-based line / column; LSP uses
+        # 0-based. Translate at the boundary.
+        node = locate_node(source: entry.bytes, root: parse_result.value, line: line + 1, character: character + 1)
+        return nil if node.nil?
+
+        scope = base_scope(path)
+        index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
+        node_scope = index[node]
+        type = node_scope.type_of(node)
+
+        @renderer.render(node: node, type: type, node_scope_lookup: index)
+      end
+
+      private
+
+      def locate_node(source:, root:, line:, character:)
+        Source::NodeLocator.at_position(source: source, root: root, line: line, column: character)
+      rescue Source::NodeLocator::OutOfRangeError
+        nil
+      end
+
+      def base_scope(_path)
+        # Slice 7: pull the Environment from the cached
+        # ProjectContext so hovers don't pay the RBS-load tax on
+        # every cursor stop.
+        Scope.empty(environment: @project_context.environment)
+      end
+    end
+  end
+end