rigortype 0.1.16 → 0.1.18

data/lib/rigor/cli/triage_command.rb

@@ -7,6 +7,7 @@ require_relative "../analysis/runner"
 require_relative "../cache/store"
 require_relative "../triage"
 require_relative "triage_renderer"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -18,16 +19,10 @@ module Rigor
     # Read-only and advisory (WD4): never edits config, never
     # writes a baseline. Always exits 0 — it is an inspection
     # command, not a gate (`rigor check` remains the gate).
-    class TriageCommand
+    class TriageCommand < Command
       USAGE = "Usage: rigor triage [options] [paths]"
       DEFAULT_SECTIONS = %i[distribution hotspots hints].freeze
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status (always 0).
       def run
         options = parse_options

data/lib/rigor/cli/type_of_command.rb

@@ -11,6 +11,8 @@ require_relative "../source/node_locator"
 require_relative "../inference/fallback_tracer"
 require_relative "../inference/scope_indexer"
 require_relative "type_of_renderer"
+require_relative "command"
+require_relative "options"
 
 module Rigor
   class CLI
@@ -25,21 +27,15 @@ module Rigor
     # dispatching and lets us evolve the type-of UX (extra flags, watch mode,
     # streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
-    class TypeOfCommand
+    class TypeOfCommand < Command
       USAGE = "Usage: rigor type-of [options] FILE:LINE:COL"
 
       Result = Data.define(:file, :line, :column, :node, :type, :tracer)
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
-        buffer = resolve_buffer_binding(options)
+        buffer = Options.resolve_buffer_binding(options, err: @err)
         return CLI::EXIT_USAGE if buffer == :usage_error
 
         target = parse_position_argument(@argv)
@@ -58,42 +54,13 @@ module Rigor
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
-          opts.on("--tmp-file=PATH",
-                  "Editor mode: read source bytes from PATH instead of --instead-of (paired)") do |value|
-            options[:tmp_file] = value
-          end
-          opts.on("--instead-of=PATH",
-                  "Editor mode: the logical project path the buffer represents (paired with --tmp-file)") do |value|
-            options[:instead_of] = value
-          end
+          Options.add_editor_mode(opts, options)
         end
         parser.parse!(@argv)
 
         options
       end
 
-      # Mirrors `Rigor::CLI#resolve_buffer_binding` (the `check`
-      # path). Returns nil / BufferBinding / :usage_error. The
-      # symbol return path lets the caller translate to
-      # `CLI::EXIT_USAGE` without raising.
-      def resolve_buffer_binding(options)
-        tmp = options[:tmp_file]
-        instead = options[:instead_of]
-        return nil if tmp.nil? && instead.nil?
-
-        if tmp.nil? || instead.nil?
-          @err.puts("--tmp-file and --instead-of must appear together")
-          return :usage_error
-        end
-
-        unless File.file?(tmp)
-          @err.puts("--tmp-file #{tmp.inspect}: no such file or not readable")
-          return :usage_error
-        end
-
-        Rigor::Analysis::BufferBinding.new(logical_path: instead, physical_path: tmp)
-      end
-
       def execute(target:, options:, buffer: nil)
         file, line, column = target
         # Under editor mode the logical `file` may not exist on disk

data/lib/rigor/cli/type_of_renderer.rb

@@ -3,6 +3,8 @@
 require "json"
 require "optionparser"
 
+require_relative "renderable"
+
 module Rigor
   class CLI
     # Renders a `TypeOfCommand::Result` as either human-readable text or a
@@ -12,19 +14,12 @@ module Rigor
     # output formats (sexp, lsp-style hover payloads, color decoration) can
     # plug in without disturbing argument parsing or the inference call site.
     class TypeOfRenderer
+      include Renderable
+
       def initialize(out:)
         @out = out
       end
 
-      def render(result, format:)
-        case format
-        when "text" then render_text(result)
-        when "json" then render_json(result)
-        else
-          raise OptionParser::InvalidArgument, "unsupported format: #{format}"
-        end
-      end
-
       private
 
       def render_text(result)

data/lib/rigor/cli/type_scan_command.rb

@@ -9,6 +9,7 @@ require_relative "../inference/coverage_scanner"
 require_relative "../scope"
 require_relative "type_scan_renderer"
 require_relative "type_scan_report"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -19,21 +20,15 @@ module Rigor
     # the inference engine's directly recognized classes. It is the project's
     # primary CI gate for tracking how much of an input source the engine can
     # name without falling back to `Dynamic[Top]`.
-    class TypeScanCommand
+    class TypeScanCommand < Command
       USAGE = "Usage: rigor type-scan [options] PATH..."
 
       LocatedEvent = Data.define(:file, :event)
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
-        paths = collect_paths(@argv)
+        paths = collect_paths(@argv, command_name: "type-scan")
         return CLI::EXIT_USAGE if paths.nil?
         return usage_error if paths.empty?
 
@@ -67,21 +62,6 @@ module Rigor
         options
       end
 
-      def collect_paths(args)
-        paths = []
-        args.each do |arg|
-          if File.directory?(arg)
-            paths.concat(Dir.glob(File.join(arg, "**/*.rb")))
-          elsif File.file?(arg)
-            paths << arg
-          else
-            @err.puts("type-scan: not a file or directory: #{arg}")
-            return nil
-          end
-        end
-        paths.uniq
-      end
-
       def usage_error
         @err.puts("type-scan: at least one path is required")
         @err.puts(USAGE)

data/lib/rigor/cli/type_scan_renderer.rb

@@ -3,6 +3,8 @@
 require "json"
 require "optionparser"
 
+require_relative "renderable"
+
 module Rigor
   class CLI
     # Renders a `TypeScanCommand::Report` as either a terminal-friendly text
@@ -11,19 +13,12 @@ module Rigor
     # the two formats stay in lockstep; that pairing is why this class is a
     # bit longer than the default class-length budget.
     class TypeScanRenderer
+      include Renderable
+
       def initialize(out:)
         @out = out
       end
 
-      def render(report, format:)
-        case format
-        when "text" then render_text(report)
-        when "json" then render_json(report)
-        else
-          raise OptionParser::InvalidArgument, "unsupported format: #{format}"
-        end
-      end
-
       private
 
       def render_text(report)