rich-ri 0.1.0

data/lib/rich_ri/cli.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "manual"
+
+module RichRI
+  class CLI
+    def self.run(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      if argv.first == "--complete"
+        Completion.new.write(argv.drop(1), $stdout)
+        return 0
+      end
+
+      options = Options.new.parse(argv)
+      return action(*options.action, options: options) if options.action
+
+      driver_options = options.driver_options
+      driver_options[:rich_ri_color] = color?(options.color)
+      driver_options[:rich_ri_theme] = options.theme
+      driver_options[:rich_ri_bat_theme] = options.bat_theme
+      driver_options[:rich_ri_shell_theme] = options.shell_theme
+      with_pager(options.pager_command) do
+        if driver_options[:dump_path]
+          dump(driver_options[:dump_path])
+        else
+          Driver.new(driver_options).run
+        end
+      end
+      0
+    rescue Errno::EPIPE
+      0
+    rescue OptionParser::ParseError, ArgumentError, RDoc::Error, TypeError, LoadError, SystemCallError => e
+      if (dependency = optional_dependency(e))
+        warn "rich-ri: --#{dependency == 'webrick' ? 'server' : 'profile'} requires the optional #{dependency} gem.\n" \
+             "Install it for your active Ruby: gem install #{dependency}"
+      elsif incompatible_cache?(e)
+        warn "rich-ri: incompatible RI cache format for this Ruby and RDoc.\n" \
+             "Regenerate the documentation with your current Ruby and RDoc. For gems: gem rdoc GEM_NAME --ri.\n" \
+             "For Ruby core documentation, see https://github.com/hvpaiva/rich-ri/blob/main/docs/troubleshooting.md"
+      else
+        warn "rich-ri: #{RichRI.sanitize(e.message)}\nRun rich-ri --help for usage."
+      end
+      1
+    rescue Interrupt
+      130
+    end
+
+    private
+
+    def optional_dependency(error)
+      error.path if error.is_a?(LoadError) && %w[profile webrick].include?(error.path)
+    end
+
+    def incompatible_cache?(error)
+      (error.is_a?(TypeError) && error.message.match?(/class RDoc::Markup::\w+ not a struct/)) ||
+        (error.is_a?(ArgumentError) && error.message == "dump format error")
+    end
+
+    def color?(mode)
+      mode == "always" || (mode == "auto" && $stdout.tty? && ENV["TERM"] != "dumb" && ENV.fetch("NO_COLOR", "").empty?)
+    end
+
+    def action(name, value = nil, options:)
+      case name
+      when :help then help(options)
+      when :version then puts "rich-ri #{VERSION}"
+      when :config_path then puts options.configuration_path
+      when :show_config then puts Psych.dump(options.settings)
+      when :completion then puts File.read(File.expand_path("../../completions/rich-ri.#{value}", __dir__))
+      when :man_path then puts Manual.new.path
+      when :man then return Manual.new.show(color: color?(options.color), theme: options.theme)
+      when :install_man
+        unless options.driver_options[:names].empty?
+          raise ArgumentError, "--install-man does not accept lookup names; use --install-man=DIR"
+        end
+
+        return Manual.new.install(value)
+      end
+      0
+    end
+
+    def dump(path)
+      unless File.file?(path) && File.readable?(path)
+        raise ArgumentError, "RI cache must be a readable regular file: #{path}"
+      end
+
+      Driver.dump(path)
+    end
+
+    def help(options)
+      options.parser.to_s.each_line do |line|
+        role = line.start_with?("Usage:") ? :title : :heading
+        styled = line.match?(/\A\S.*:/) ? options.theme.paint(line, role, enabled: color?(options.color)) : line
+        print styled
+      end
+    end
+
+    def with_pager(command = nil)
+      previous_pager = ENV.fetch("RI_PAGER", nil)
+      ENV["RI_PAGER"] = command if command
+      previous = ENV.fetch("LESS", nil)
+      ENV["LESS"] = "#{previous || '-Fi'} -R"
+      yield
+    ensure
+      ENV["LESS"] = previous
+      ENV["RI_PAGER"] = previous_pager
+    end
+  end
+end

data/lib/rich_ri/color.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RichRI
+  # Explicit colors degrade to the closest xterm palette entry. Named ANSI
+  # colors stay symbolic so terminal themes retain control over their palette.
+  class Color
+    NAMES = %w[black red green yellow blue magenta cyan white].freeze
+    BASIC = [
+      [0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
+      [0, 0, 128], [128, 0, 128], [0, 128, 128], [192, 192, 192],
+      [128, 128, 128], [255, 0, 0], [0, 255, 0], [255, 255, 0],
+      [0, 0, 255], [255, 0, 255], [0, 255, 255], [255, 255, 255]
+    ].map(&:freeze).freeze
+    CUBE = [0, 95, 135, 175, 215, 255].freeze
+    PALETTE = (BASIC + CUBE.repeated_permutation(3).to_a +
+      Array.new(24) { |index| Array.new(3, 8 + (index * 10)) }).map(&:freeze).freeze
+
+    def initialize(value)
+      @value = value
+      @index = NAMES.index(value.delete_prefix("bright_"))
+      @index += 8 if @index && value.start_with?("bright_")
+      @number = value.to_i if value.match?(/\A(?:0|[1-9]\d{0,2})\z/) && value.to_i <= 255
+      @rgb = value.delete_prefix("#").scan(/../).map { |part| part.to_i(16) } if value.match?(/\A#[0-9a-fA-F]{6}\z/)
+      return if @index || @number || @rgb || value == "default"
+
+      raise ArgumentError, "invalid color #{value.inspect}; use an ANSI name, 0..255, #RRGGBB or default"
+    end
+
+    def sgr(depth, background: false)
+      return background ? "49" : "39" if @value == "default"
+      return basic(@index, background:) if @index
+
+      rgb = @rgb || PALETTE.fetch(@number)
+      return basic(nearest(rgb, BASIC), background:) if depth == "basic"
+
+      prefix = background ? "48" : "38"
+      return "#{prefix};5;#{@number || nearest(rgb, PALETTE)}" if depth == "256" || @number
+
+      "#{prefix};2;#{rgb.join(';')}"
+    end
+
+    private
+
+    def basic(index, background:)
+      ((index < 8 ? 30 : 90) + (index % 8) + (background ? 10 : 0)).to_s
+    end
+
+    def nearest(rgb, palette)
+      palette.each_index.min_by do |index|
+        palette[index].zip(rgb).sum { |candidate, channel| (candidate - channel)**2 }
+      end
+    end
+  end
+end

data/lib/rich_ri/completion.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RichRI
+  # The protocol is tab-separated value/description pairs. Only source options
+  # reach the driver: pressing Tab can never start a pager, server or cache dump.
+  class Completion
+    SOURCES = /\A--(?:no-)?(?:system|site|home|gems|standard-docs)\z/
+    VALUES = %w[-w --width --server --dump --bat-theme --shell-theme --pager-command].freeze
+
+    def write(words, io)
+      # Bound discovery even when a documentation store is unusually large.
+      Timeout.timeout(4) do
+        words = words.drop(1).map { |word| shell_word(word) } if %w[--shell=bash --shell=zsh].include?(words.first)
+        candidates(words).each do |value, description|
+          next if [value, description].any? { |text| text.match?(/[\t\r\n]/) || RichRI.sanitize(text) != text }
+
+          io.puts "#{value}\t#{description}"
+        end
+      end
+    rescue StandardError
+      # A broken/missing RI store must not interrupt shell input.
+      nil
+    end
+
+    def candidates(words)
+      return [] if words[0...-1].include?("--install-man")
+
+      current, previous, prefix = context(words)
+      values = option_values(previous, current)
+      values ||= if current.start_with?("-") && !words[0...-1].include?("--")
+                   Options.new.entries
+                 else
+                   names(words[0...-1], current).map { |v| [v, ""] }
+                 end
+      values.select { |value, _| value.start_with?(current) }
+            .map { |value, desc| [prefix + value, desc] }.uniq.sort
+    end
+
+    private
+
+    def option_values(previous, current)
+      case previous
+      when "--color" then %w[auto always never].map { |v| [v, "Color mode"] }
+      when "--format", "-f" then Options.formats.map { |v| [v, "RDoc formatter"] }
+      when "--completion" then %w[bash zsh fish].map { |v| [v, "Shell completion script"] }
+      when "--theme" then Theme::NAMES.map { |v| [v, "Page theme"] }
+      when "--color-depth" then Theme::DEPTHS.map { |v| [v, "Terminal color depth"] }
+      when "--style" then styles(current)
+      when "--config" then paths(current)
+      when "--doc-dir", "-d", "--install-man" then directories(current)
+      when *VALUES then []
+      end
+    end
+
+    def shell_word(word)
+      # Bash and Zsh retain quotes in their words. Shellwords removes them without
+      # evaluating substitutions; the current word may have an unclosed quote.
+      ["", "'", '"'].each do |suffix|
+        parts = Shellwords.split(word + suffix)
+        return parts.first.to_s if parts.length <= 1
+      rescue ArgumentError
+        next
+      end
+      word
+    end
+
+    def context(words)
+      current = words.last || ""
+      previous = words[-2]
+      prefix = ""
+      if current.start_with?("--") && current.include?("=")
+        previous, current = current.split("=", 2)
+        prefix = "#{previous}="
+      elsif previous == "--color"
+        # Optional values require '='; a bare switch does not consume a name.
+        previous = nil
+      end
+      [current, previous, prefix]
+    end
+
+    def styles(prefix)
+      return [] if prefix.include?("=")
+
+      RichRI::COLORS.keys.map { |role| ["#{role}=", "Override #{role} style"] }
+    end
+
+    def directories(prefix)
+      paths(prefix, directories_only: true).map { |path, _description| [path, "Documentation directory"] }
+    end
+
+    def paths(prefix, directories_only: false)
+      # Escape glob metacharacters typed by the user; do not interpret patterns.
+      escaped = prefix.gsub(/[\[\]{}*?\\]/) { |char| "\\#{char}" }
+      Dir.glob("#{escaped}*").filter_map do |path|
+        directory = File.directory?(path)
+        next if directories_only && !directory
+        next unless directory || File.file?(path)
+
+        [directory ? "#{path}/" : path, directory ? "Directory" : "Configuration file"]
+      end
+    end
+
+    def names(words, prefix)
+      defaults = Shellwords.split(ENV.fetch("RI", ""))
+      configured = Configuration.new(words).arguments
+      args = [defaults, configured, words].flat_map { |layer| source_arguments(layer) }
+      options = Options.new.parse(args, defaults: "", configuration: false).driver_options
+      Driver.new(options.merge(use_stdout: true, interactive: false)).complete(prefix)
+    end
+
+    def source_arguments(words)
+      args = []
+      flags = Options.new.entries.map { |flag, _description| flag.delete_suffix("=") }
+      index = 0
+      while index < words.length
+        word = words[index]
+        break if word == "--"
+
+        raise OptionParser::InvalidOption, word if word.start_with?("--") && !flags.include?(word.split("=", 2).first)
+
+        if word.match?(SOURCES) || word.start_with?("--doc-dir=") || (word.start_with?("-d") && word.length > 2)
+          args << word
+        elsif %w[--doc-dir -d].include?(word)
+          args.concat(words[index, 2])
+          index += 1
+        elsif Configuration::VALUE_OPTIONS.include?(word) || word == "--config"
+          # An option value that resembles a source flag is still just data.
+          index += 1
+        end
+        index += 1
+      end
+      args
+    end
+  end
+end

data/lib/rich_ri/configuration.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module RichRI
+  # Only the user's selected file is read; documentation directories never
+  # supply configuration, and YAML values are data rather than Ruby objects.
+  class Configuration
+    KEYS = %w[theme color color_depth width pager bat_theme shell_theme all expand_refs doc_dirs sources styles].freeze
+    SOURCES = %w[system site home gems].freeze
+    ENVIRONMENT = {
+      "RICH_RI_THEME" => "theme", "RICH_RI_COLOR" => "color", "RICH_RI_COLOR_DEPTH" => "color_depth",
+      "RICH_RI_WIDTH" => "width", "RICH_RI_BAT_THEME" => "bat_theme", "RICH_RI_SHELL_THEME" => "shell_theme"
+    }.freeze
+    VALUE_OPTIONS = %w[-w --width -f --format -d --doc-dir --dump --completion --theme --color-depth
+                       --style --bat-theme --shell-theme --pager-command].freeze
+    MAX_BYTES = 65_536
+
+    attr_reader :path, :arguments
+
+    def initialize(argv, env: ENV, load: true)
+      @env = env
+      @path, explicit = select_path(argv)
+      @arguments = []
+      return unless load
+
+      data = @path && (explicit || File.exist?(@path)) ? read_file : {}
+      @arguments = file_arguments(data) + environment_arguments
+    rescue Psych::Exception => e
+      raise ArgumentError, "Invalid configuration #{@path}: #{e.message}"
+    end
+
+    def self.switches(argv)
+      options = []
+      index = 0
+      while index < argv.length
+        word = argv[index]
+        break if word == "--"
+
+        options << [word, argv[index + 1]]
+        index += VALUE_OPTIONS.include?(word) || word == "--config" ? 2 : 1
+      end
+      options
+    end
+
+    def self.text!(value, name)
+      if value.is_a?(String) && !value.strip.empty? && RichRI.sanitize(value) == value && !value.match?(/[\r\n\t]/)
+        return
+      end
+
+      raise ArgumentError, "#{name} must be a nonempty string without control characters"
+    end
+
+    private
+
+    def select_path(argv)
+      base = @env["XDG_CONFIG_HOME"]
+      base = File.join(@env.fetch("HOME") { Dir.home }, ".config") unless base&.start_with?("/")
+      explicit = !@env.fetch("RICH_RI_CONFIG", "").empty?
+      path = explicit ? @env.fetch("RICH_RI_CONFIG") : File.join(base, "rich-ri/config.yml")
+      self.class.switches(argv).each do |word, argument|
+        if word == "--no-config"
+          path = nil
+        elsif word == "--config" || word.start_with?("--config=")
+          path = word == "--config" ? argument : word.split("=", 2).last
+          raise ArgumentError, "--config requires a nonempty file path" if path.nil? || path.empty?
+
+          explicit = true
+        end
+      end
+      self.class.text!(path, "Configuration path") if path
+      [path && File.expand_path(path), explicit]
+    end
+
+    def read_file
+      raise ArgumentError, "Configuration is not a readable regular file: #{@path}" unless File.file?(@path)
+
+      content = File.read(@path, MAX_BYTES + 1)
+      raise ArgumentError, "Configuration exceeds #{MAX_BYTES} bytes: #{@path}" if content.bytesize > MAX_BYTES
+
+      stream = Psych.parse_stream(content, filename: @path)
+      raise ArgumentError, "Configuration must contain one YAML document: #{@path}" if stream.children.length > 1
+
+      check_duplicate_keys(stream)
+      data = Psych.safe_load(content, permitted_classes: [], permitted_symbols: [], aliases: false, filename: @path)
+      data = {} if data.nil?
+      mapping!(data, KEYS, "configuration")
+      data
+    end
+
+    def check_duplicate_keys(root)
+      pending = [[root, 0]]
+      until pending.empty?
+        node, depth = pending.pop
+        raise ArgumentError, "Configuration nesting exceeds 20 levels: #{@path}" if depth > 20
+
+        if node.is_a?(Psych::Nodes::Mapping)
+          keys = node.children.each_slice(2).map { |key, _value| key.value if key.is_a?(Psych::Nodes::Scalar) }
+          raise ArgumentError, "Duplicate configuration key in #{@path}" unless keys.uniq.length == keys.length
+        end
+        pending.concat(Array(node.children).map { |child| [child, depth + 1] })
+      end
+    end
+
+    def mapping!(value, keys, context)
+      raise ArgumentError, "#{context} must be a mapping" unless value.is_a?(Hash)
+
+      unknown = value.keys - keys
+      raise ArgumentError, "Unknown #{context} key: #{unknown.first.inspect}" unless unknown.empty?
+    end
+
+    def file_arguments(data)
+      args = data.except("sources", "styles", "doc_dirs").flat_map { |key, value| setting(key, value) }
+      sources = data.fetch("sources", {})
+      mapping!(sources, SOURCES, "sources")
+      args.concat(sources.flat_map { |key, value| boolean(key, value) })
+      styles = data.fetch("styles", {})
+      mapping!(styles, COLORS.keys.map(&:to_s), "styles")
+      args.concat(styles.flat_map { |key, value| style(key, value) })
+      directories = data.fetch("doc_dirs", [])
+      raise ArgumentError, "doc_dirs must be a list of directory paths" unless directories.is_a?(Array)
+
+      directories.each do |directory|
+        self.class.text!(directory, "doc_dirs")
+        args.push("--doc-dir", File.expand_path(directory, File.dirname(@path)))
+      end
+      args
+    end
+
+    def environment_arguments
+      args = ENVIRONMENT.flat_map do |name, key|
+        value = @env[name]
+        next [] if value.nil? || value.empty?
+
+        setting(key, key == "width" && value.match?(/\A[0-9]+\z/) ? value.to_i : value)
+      end
+      args.concat(setting("bat_theme", @env["BAT_THEME"])) if @env["BAT_THEME"] && !@env["BAT_THEME"].empty? &&
+                                                              @env.fetch("RICH_RI_BAT_THEME", "").empty?
+      unless @env.fetch("RI_PAGER", "").empty?
+        self.class.text!(@env["RI_PAGER"], "RI_PAGER")
+        args << "--pager-command=#{@env['RI_PAGER']}"
+      end
+      @env.each do |name, value|
+        next unless name.start_with?("RICH_RI_STYLE_") && !value.to_s.empty?
+
+        args.concat(style(name.delete_prefix("RICH_RI_STYLE_").downcase, value))
+      end
+      args
+    end
+
+    def setting(key, value)
+      return boolean(key.tr("_", "-"), value) if %w[all expand_refs].include?(key)
+      return boolean("pager", value) if key == "pager" && [true, false].include?(value)
+
+      if key == "width"
+        raise ArgumentError, "width must be an integer of at least 20" unless value.is_a?(Integer) && value >= 20
+      else
+        self.class.text!(value, key)
+      end
+      values = { "theme" => Theme::NAMES, "color" => %w[auto always never], "color_depth" => Theme::DEPTHS }[key]
+      raise ArgumentError, "#{key} must be one of: #{values.join(', ')}" if values && !values.include?(value)
+
+      flag = key == "pager" ? "pager-command" : key.tr("_", "-")
+      key == "pager" ? ["--pager", "--#{flag}=#{value}"] : ["--#{flag}=#{value}"]
+    end
+
+    def boolean(key, value)
+      raise ArgumentError, "#{key} must be true or false" unless [true, false].include?(value)
+
+      ["--#{'no-' unless value}#{key}"]
+    end
+
+    def style(role, value)
+      self.class.text!(value, "style #{role}")
+      Theme.new(styles: { role => value })
+      ["--style=#{role}=#{value}"]
+    end
+  end
+end

data/lib/rich_ri/configuration_options.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RichRI
+  # Configuration switches share the normal parser, so defaults and explicit
+  # arguments use the same validation and completion descriptions.
+  module ConfigurationOptions
+    attr_reader :theme, :bat_theme, :shell_theme, :pager_command, :configuration_path
+
+    def configuration_options
+      @theme_name = "terminal"
+      @color_depth = "auto"
+      @styles = {}
+      @bat_theme = "base16"
+      @shell_theme = "ansi"
+      @pager_enabled = true
+      @parser.separator ""
+      @parser.separator "Configuration and themes:"
+      @parser.on("--config=FILE", "Read a YAML configuration file instead of the user default.") do |path|
+        Configuration.text!(path, "Configuration path")
+        @configuration_path = File.expand_path(path)
+      end
+      @parser.on("--no-config", "Skip the configuration file; environment options still apply.") do
+        @configuration_path = nil
+      end
+      @parser.on("--config-path", "Print the selected configuration path; blank when disabled.") do
+        @action = [:config_path]
+      end
+      @parser.on("--show-config", "Print effective preferences as YAML without opening documentation.") do
+        @action = [:show_config]
+      end
+      theme_options
+    end
+
+    def theme_options
+      @parser.on("--theme=NAME", Theme::NAMES, "Palette: terminal (default), dark or light.") { |name| @theme_name = name }
+      @parser.on("--color-depth=DEPTH", Theme::DEPTHS,
+                 "Color depth: auto (default), basic, 256 or truecolor.") do |depth|
+        @color_depth = depth
+      end
+      @parser.on("--style=ROLE=STYLE",
+                 "Override a style role; repeat for several roles. Example: method=green:bold.") do |value|
+        role, style = value.split("=", 2)
+        Theme.new(styles: { role => style })
+        @styles[role] = style
+      end
+      @parser.on("--bat-theme=NAME", "bat theme for tagged non-Ruby, non-shell code (default: base16).") do |name|
+        Configuration.text!(name, "bat_theme")
+        @bat_theme = name
+      end
+      @parser.on("--shell-theme=NAME", "bat theme for shell input (default: ansi).") do |name|
+        Configuration.text!(name, "shell_theme")
+        @shell_theme = name
+      end
+      @parser.on("--pager-command=COMMAND", "Choose a trusted pager command, overriding RI_PAGER/PAGER.") do |command|
+        Configuration.text!(command, "pager command")
+        @pager_command = command
+      end
+    end
+
+    def settings
+      { "theme" => @theme_name, "color" => @color, "color_depth" => @color_depth,
+        "width" => @driver_options.fetch(:width), "pager" => @pager_enabled && (@pager_command || true),
+        "bat_theme" => @bat_theme, "shell_theme" => @shell_theme,
+        "all" => @driver_options.fetch(:show_all), "expand_refs" => @driver_options.fetch(:expand_refs),
+        "doc_dirs" => @driver_options.fetch(:extra_doc_dirs).map(&:dup),
+        "sources" => Configuration::SOURCES.to_h { |key| [key, @driver_options.fetch(:"use_#{key}")] },
+        "styles" => @styles.transform_values(&:dup) }
+    end
+
+    private
+
+    def configured_defaults(argv, defaults, enabled)
+      selection = Configuration.new(argv, load: false)
+      @configuration_path = selection.path
+      return [] if Configuration.switches(argv).any? { |word, _| word == "--config-path" }
+
+      words = Shellwords.split(defaults)
+      @parser.parse!(words)
+      @parser.parse!(Configuration.new(argv).arguments) if enabled
+      words
+    rescue ArgumentError, OptionParser::ParseError, SystemCallError
+      raise unless recovery_request?(argv)
+
+      initialize
+      @configuration_path = selection&.path
+      []
+    end
+
+    def recovery_request?(argv)
+      Configuration.switches(argv).any? do |word, _|
+        %w[--help -h --version -v --config-path --completion].include?(word) || word.start_with?("--completion=")
+      end
+    end
+  end
+end

data/lib/rich_ri/driver.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RichRI
+  class Driver < RDoc::RI::Driver
+    # RDoc's class listing writes directly to its pager, outside the formatter.
+    class ListOutput
+      def initialize(io)
+        @io = io
+      end
+
+      def puts(*values)
+        @io.puts(*values.map { |value| RichRI.sanitize(value.to_s) })
+      end
+
+      def tty?
+        @io.tty?
+      end
+    end
+
+    def self.default_options
+      columns = $stdout.tty? ? $stdout.winsize.last : 80
+      columns = 80 unless columns.positive?
+      super.merge(width: (columns - 2).clamp(30, 96))
+    rescue SystemCallError
+      super
+    end
+
+    def initialize(options)
+      @rich_ri_color = options.delete(:rich_ri_color)
+      @rich_ri_theme = options.delete(:rich_ri_theme) || Theme.new
+      @rich_ri_bat_theme = options.delete(:rich_ri_bat_theme) || ENV.fetch("BAT_THEME", "base16")
+      @rich_ri_shell_theme = options.delete(:rich_ri_shell_theme) || "ansi"
+      super
+    end
+
+    def formatter(io)
+      return super if @formatter_klass
+
+      Formatter.new(color: @rich_ri_color, classes: classes, theme: @rich_ri_theme,
+                    bat_theme: @rich_ri_bat_theme, shell_theme: @rich_ri_shell_theme)
+    end
+
+    def run
+      return super unless @list_doc_dirs && !@formatter_klass
+
+      puts(@doc_dirs.map { |path| RichRI.sanitize(path) })
+    end
+
+    def page
+      super { |io| yield(@list && !@formatter_klass ? ListOutput.new(io) : io) }
+    end
+
+    def start_server
+      # Surface missing dependencies through CLI errors instead of RDoc's abort.
+      require "webrick"
+      super
+    end
+
+    def complete(name)
+      # RI completes classes/methods but does not offer ruby: or gem pages.
+      # Use the loaded stores so discovery follows this Ruby and --doc-dir.
+      if (match = /\A([^:]+):([^:]*)\z/.match(name))
+        source, prefix = match.captures
+        matching = stores.select do |store|
+          store.source == source || (store.type == :gem && store.source.match?(/\A#{Regexp.escape(source)}-\d/))
+        end
+        return matching.flat_map { |store| store.cache[:pages] || [] }
+                       .select { |page| page.start_with?(prefix) }
+                       .map { |page| "#{source}:#{page}" }.uniq.sort
+      end
+
+      candidates = super
+      candidates.push("#{name}#", "#{name}.", "#{name}::") if classes.key?(name)
+      unless name.match?(/[.#:]/)
+        stores.each do |store|
+          next if (store.cache[:pages] || []).empty?
+
+          source = store.type == :gem ? store.source.sub(/-\d[^-]*\z/, "") : store.source
+          candidates << "#{source}:" if source.start_with?(name)
+        end
+      end
+      candidates.uniq.sort
+    end
+
+    def render_method_arguments(out, arglists)
+      start = out.parts.length
+      super
+      return if @formatter_klass
+
+      out.parts[start..].grep(RDoc::Markup::Verbatim).each { |part| part.format = :rich_ri_signature }
+    end
+
+    def render_method_type_signature(out, lines)
+      start = out.parts.length
+      super
+      return if @formatter_klass
+
+      out.parts[start..].grep(RDoc::Markup::Verbatim).each { |part| part.format = :rbs }
+    end
+
+    def add_method_list(out, methods, name)
+      return super if @formatter_klass
+      return if methods.empty?
+
+      out << RDoc::Markup::Heading.new(2, "#{name}:")
+      out << RDoc::Markup::BlankLine.new
+      out << MethodList.new(2, methods.join(", "))
+      out << RDoc::Markup::BlankLine.new
+    end
+  end
+end