raindown 0.5.0 → 0.6.0

data/lib/raindown/tui/renderers/dashboard_renderer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'renderer'
+
+module Raindown
+  module TUI
+    # The dashboard, right of the files: a card for each of the projects' charts, as wide as its chart,
+    # with as many in a row as fit. With more than one project, each project's charts are under its path.
+    # A card has its file and heading, and its directive, both cut to the chart's width, then the chart,
+    # in a border with rounded corners:
+    #    ╭─────────────────────────────╮  ╭────────────────────────────────╮
+    #    │ raindown.rd › Charts        │  │ raindown.rd › Commits          │
+    #    │ chart: 'data/downloads.csv' │  │ chart: 'data/commits.csv' min… │
+    #    │ Jun  ██████▊           640  │  │ c2f98fc  -18  █│███▊      +96  │
+    #    ╰─────────────────────────────╯  ╰────────────────────────────────╯
+    class DashboardRenderer < Renderer
+      BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['e', 'Edit', :edit], ['r', 'Reload', :reload],
+                 ['q', 'Quit', :quit]].freeze
+      PROJECTS_BUTTON = ['p', 'Projects', :projects].freeze
+
+      # Room for the project menu's button, when there's more than one project.
+      def buttons
+        if navigator.projects? then BUTTONS.dup.insert(3, PROJECTS_BUTTON)
+        else BUTTONS
+        end
+      end
+
+      def page = 'Dashboard'
+
+      def lines
+        cards = dashboard.cards
+        return blank(height, " No charts in #{File.basename(navigator.root)} yet, like <{ chart: '3 5 2 8' }>") if cards.empty?
+
+        rows = dashboard.rows(width)
+        @headings = headings(rows, cards)
+        grid(rows, cards)
+      end
+
+      private
+
+      def dashboard = navigator.dashboard
+
+      # Each project's path above its first row of cards, by the row's index, when there's more than one project.
+      def headings(rows, cards)
+        firsts = rows.each_index.chunk_while { |a, b| cards[rows[a].first].project == cards[rows[b].first].project }.map(&:first)
+        return {} if firsts.one?
+
+        firsts.to_h { [it, cards[rows[it].first].project] }
+      end
+
+      # The rows of cards from the first that's scrolled to, each card's lines side by side, with a line between rows.
+      def grid(rows, cards)
+        heights = rows.each_with_index.map { |row, index| row_height(row, cards) + (@headings.key?(index) ? 1 : 0) }
+        first = dashboard.scroll(heights, height)
+        lines = (first...rows.length).flat_map { |index| row_lines(rows[index], cards, heading: @headings[index]) }
+
+        (lines + blank(height)).first(height)
+      end
+
+      # The tallest card's lines, in its border, and one line below it.
+      def row_height(row, cards)
+        row.map { cards[it].box_height }.max + 1
+      end
+
+      def row_line(row, cards, line)
+        segments = [segment('', :blank, width: 1)]
+
+        row.each_with_index do |index, column|
+          segments << segment('', :blank, width: DashboardView::GAP) unless column.zero?
+          segments.concat(card_line(cards[index], index, line))
+        end
+
+        padded(segments)
+      end
+
+      # A card opens chart source when it's clicked, like Enter, but not the space below a card shorter than its row.
+      # The selected card's title is highlighted, like a selected row.
+      def card_line(card, index, line)
+        title_style = dashboard.cursor == index ? row_style(pane, nil, true) : :heading
+        event = Click.new(pane:, index:, action: :enter) if line < card.box_height
+        box_width = card.box_width(within: dashboard.card_widths(width))
+        card.format_line(line, box_width:, title_style:).map do |text, style, part_width|
+          segment(text, style, width: part_width, event:)
+        end
+      end
+
+      # A row of cards' lines, under its project's heading when it's the project's first row.
+      def row_lines(row, cards, heading:)
+        [*([heading_line(heading)] if heading), *Array.new(row_height(row, cards)) { |line| row_line(row, cards, line) }]
+      end
+
+      # A project's path from the home folder, above its charts.
+      def heading_line(project)
+        [segment(" #{from_home(project)}", :project)]
+      end
+
+      def blank(count, message = '')
+        [[segment(message, :info)], *Array.new([count - 1, 0].max) { [segment('', :blank)] }].first(count)
+      end
+    end
+  end
+end

data/lib/raindown/tui/renderers/endpoint_renderer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'renderer'
+require_relative 'outline_renderer'
+
+module Raindown
+  module TUI
+    # An endpoint opened from the files, right of them: its URL in a bar with rounded corners, and a button to run it,
+    # then its response:
+    #    ╭──────────────────────────────────────────╮
+    #    │ GET https://httpbin.org/uuid     [ Run ] │
+    #    ╰──────────────────────────────────────────╯
+    #
+    #    Response · json · fetched 2026-10-26
+    #    {
+    #      "uuid": "48024974-f1b1-431a-a0cf-5cac0099a1a5"
+    #    }
+    class EndpointRenderer < Renderer
+      RUN = '[ Run ]'
+      RUN_WIDTH = RUN.length
+      BUTTONS = OutlineRenderer::BUTTONS.reject { it.last == :write_back }.freeze
+
+      def buttons = BUTTONS
+      def page = navigator.view.endpoint.text
+
+      def lines
+        view = navigator.view
+        top = [*url_bar(view.endpoint), [segment('', :blank, width:)], about(view)]
+
+        (top + response(view, height - top.length)).first(height)
+      end
+
+      private
+
+      # A click on the response moves the focus to it, to scroll it.
+      def focus = Click.new(pane:, index: 0, action: :focus)
+
+      def response(view, lines)
+        texts = view.visible([lines, 0].max)
+        Array.new([lines, 0].max) { [segment(texts[it] ? " #{texts[it]}" : '', :response, width:, event: focus)] }
+      end
+
+      # The bar is a column in from each side of the pane, with the URL and the button inside its border.
+      def url_bar(endpoint)
+        inner = [width - 6, 0].max
+        [edge('╭', '╮', inner), padded([margin, segment('│ ', :border, width: 2), *request(endpoint, inner)]),
+         edge('╰', '╯', inner)]
+      end
+
+      # The method in its colour, then the URL, cut to what the method and button leave, then the button,
+      # and the border's side.
+      def request(endpoint, inner)
+        method_width = display_width(endpoint.method)
+        url_width = [inner - method_width - RUN_WIDTH - 1, 0].max
+
+        [segment(endpoint.method, endpoint.style, width: method_width), segment(" #{endpoint.url} ", :url, width: url_width + 1),
+         run_button, segment(' │', :border, width: 2)]
+      end
+
+      def run_button = segment(RUN, :run, width: RUN_WIDTH, event: Click.new(pane:, index: 0, action: :execute))
+
+      def edge(left, right, inner)
+        padded([margin, segment("#{left}#{'─' * (inner + 2)}#{right}", :border, width: inner + 4)])
+      end
+
+      def margin = segment('', :blank, width: 1)
+
+      def about(view)
+        text = if view.error then view.error
+               elsif view.response.empty? then 'No response yet. X runs the request.'
+               else ['Response', view.language, ("fetched #{view.fetched}" if view.fetched)].reject { it.to_s.empty? }.join(' · ')
+               end
+        [segment(" #{text}", view.error ? :error : :heading, width:)]
+      end
+    end
+  end
+end

data/lib/raindown/tui/renderers/list_renderer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'renderer'
+
+module Raindown
+  module TUI
+    # A ListView's rows in its pane, like the files in the nav or a file's outline, each with its buttons.
+    class ListRenderer < Renderer
+      def lines
+        list = navigator.content(pane).visible(height)
+        Array.new(height) { |index| cell(pane, *list, index, width) }
+      end
+    end
+  end
+end

data/lib/raindown/tui/renderers/outline_renderer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'list_renderer'
+
+module Raindown
+  module TUI
+    # The open file's outline, right of the files: a row on each line, with its buttons.
+    class OutlineRenderer < ListRenderer
+      BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['x', 'Run', :execute], ['e', 'Edit', :edit],
+                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['q', 'Quit', :quit]].freeze
+
+      def buttons = BUTTONS
+
+      def page
+        if navigator.path then navigator.relative(navigator.path)
+        else 'No Markdown files'
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/renderers/renderer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative '../rows'
+require_relative '../text'
+
+module Raindown
+  module TUI
+    # Draws what's in a pane, :nav or :main, as lines of the pane's width and height, which the Layout puts in it.
+    Renderer = Struct.new(:navigator, :pane, :width, :height) do
+      include Rows
+      include Text
+    end
+  end
+end

data/lib/raindown/tui/row.rb

@@ -3,14 +3,21 @@
 module Raindown
   module TUI
     # A line of a pane. Target is what it's about: a folder or file path, a Heading or Directive, or a line number.
-    # Buttons are [label, event] pairs, like ['[Run]', :execute].
-    Row = Data.define(:text, :depth, :kind, :target, :buttons) do
-      def initialize(buttons: [], **) = super
+    # Buttons are [label, event] pairs, like ['[Run]', :execute], and a tag is an Endpoint, whose method is before its text.
+    # Open is the Navigator's next step on Enter, like an Open of a file, and fold, a block that folds or expands the row.
+    Row = Data.define(:text, :depth, :kind, :target, :buttons, :tag, :open, :fold) do
+      def initialize(buttons: [], tag: nil, open: nil, fold: nil, **) = super
+
+      # A separator is space between a pane's sections, which the cursor skips and clicks don't reach.
+      def selectable? = kind != :separator
 
       # The line the editor opens at for the row.
       def line
         target.is_a?(Integer) ? target : target.line
       end
     end
+
+    # Space between a pane's sections, like the Dashboard and the files.
+    Row::SEPARATOR = Row.new(text: '', depth: 0, kind: :separator, target: nil)
   end
 end

data/lib/raindown/tui/rows.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A ListRenderer's rows, like the files and the outline, each a line of the pane's width: a row's text, after its tag,
+    # like an endpoint's method, then its buttons.
+    module Rows
+      private
+
+      # A row as its text, then its buttons, or blank below its last row.
+      def cell(pane, rows, offset, index, cell_width)
+        row = rows[index]
+        return [segment('', :blank, width: cell_width)] unless row&.selectable?
+
+        index += offset
+        selected = navigator.content(pane).cursor == index
+        buttons = row_buttons(row, pane:, index:, selected:, cell_width:)
+        text_width = cell_width - display_width(buttons.map(&:text).join)
+        parts = row_parts(row, row_style(pane, row, selected), selected)
+
+        [*spread_segments(parts, text_width, event: Click.new(pane:, index:, action: :enter)), *buttons]
+      end
+
+      # A line's segments, then blank to the edge.
+      def padded(segments) = [*segments, segment('', :blank, width: [width - segments.sum { display_width(it.text) }, 0].max)]
+
+      # [text, style] parts side by side in the width, each a segment.
+      def spread_segments(parts, width, event: nil)
+        parts.zip(spread(parts.map(&:first), width)).map { |(text, style), part| segment(text, style, width: part, event:) }
+      end
+
+      # The row's text, after its tag in the tag's style, unless the row's selected.
+      def row_parts(row, style, selected)
+        lead = " #{Text::INDENT * row.depth}"
+        return [["#{lead}#{row.text}", style]] unless row.tag
+
+        [["#{lead}#{row.tag.method} ", selected ? style : row.tag.style], [row.text, style]]
+      end
+
+      # The row's buttons, right of its text, unless they'd take more than half the pane.
+      def row_buttons(row, pane:, index:, selected:, cell_width:)
+        buttons = row.buttons.map do |label, event|
+          style = selected ? :"#{row_style(pane, row, true)}_button" : :button
+          segment(" #{label}", style, width: display_width(" #{label}"), event: Click.new(pane:, index:, action: event))
+        end
+        display_width(buttons.map(&:text).join) > cell_width / 2 ? [] : buttons
+      end
+
+      # The cursor's row is highlighted in the pane with the focus, and dimmer in the other, like the file a chart opened.
+      def row_style(pane, row, selected)
+        return row.kind unless selected
+
+        navigator.focus == pane ? :selected : :cursor
+      end
+    end
+  end
+end

data/lib/raindown/tui/{input.rb → terminal/input.rb}

@@ -11,27 +11,26 @@ module Raindown
         Curses::KEY_UP => :up, 'k' => :up, Curses::KEY_DOWN => :down, 'j' => :down,
         Curses::KEY_LEFT => :left, 'h' => :left, Curses::KEY_RIGHT => :right, 'l' => :right,
         "\t" => :tab, Curses::KEY_BTAB => :tab, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
-        ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'q' => :quit
+        ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'd' => :dashboard,
+        'p' => :projects, "\e" => :escape, 'q' => :quit
       }.freeze
 
       module_function
 
       # A key from getch, which is a string for a printable character and otherwise a number.
+      # Letters are the same with Shift, as the buttons show them as capitals.
       def key_event(key)
         key = key.chr if key.is_a?(Integer) && key < 256
-        KEYS[key]
+        KEYS[key.is_a?(String) ? key.downcase : key]
       end
 
-      # A scroll of the wheel moves the cursor, and a click sends the event of what's under it.
-      def mouse_event(event, zones)
-        wheel.find { |button, _| event.bstate.anybits?(button) }&.last || click(zones, column: event.x, row: event.y)
-      end
+      # The mouse buttons that click, which are the left button's. Scrolling does nothing, and since older ncurses,
+      # like macOS's, has no button for scrolling down, it can't be mistaken for a click.
+      CLICKS = Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED
 
-      # Older ncurses has no fifth button, which is the wheel scrolling down.
-      def wheel
-        { Curses::BUTTON4_PRESSED => :up }.tap do |buttons|
-          buttons[Curses::BUTTON5_PRESSED] = :down if Curses.const_defined?(:BUTTON5_PRESSED)
-        end
+      # A click sends the event of what's under it.
+      def mouse_event(event, zones)
+        click(zones, column: event.x, row: event.y) if event.bstate.anybits?(CLICKS)
       end
 
       # Where each of a Layout's segments with an event is on the screen, as [row, columns, event].

data/lib/raindown/tui/terminal/ncurses_shim.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'curses'
+
+module Raindown
+  module TUI
+    # ncurses before 6.1, like macOS's, repeats a character with the terminal's rep capability by writing one byte of it,
+    # so a run of █ in a bar chart draws as ?. Terminals with their own terminfo entries, like Ghostty's and kitty's,
+    # have rep, while the system's entries from those ncurses versions don't. So with old ncurses, a terminal whose
+    # entry isn't the system's starts curses as xterm-256color, which they draw the same, and TERM is put back after,
+    # for the commands run from the screen, like the editor.
+    module NcursesShim
+      FALLBACK = 'xterm-256color'
+      SYSTEM_TERMINFO = %w[/usr/share/terminfo /usr/lib/terminfo /lib/terminfo].freeze
+      FIXED_VERSION = [6, 1].freeze
+
+      module_function
+
+      def starting(version: Curses::VERSION)
+        term = ENV.fetch('TERM', nil)
+        ENV['TERM'] = FALLBACK if fallback?(term, version)
+        yield
+      ensure
+        ENV['TERM'] = term
+      end
+
+      def fallback?(term, version)
+        return false if term.nil? || term.empty? || term == FALLBACK
+
+        old?(version) && !system_entry?(term)
+      end
+
+      def old?(version)
+        numbers = version.to_s[/ncurses (\d+)\.(\d+)/, 0]&.scan(/\d+/)&.map(&:to_i)
+        numbers ? (numbers <=> FIXED_VERSION).negative? : false
+      end
+
+      # Entries are in a folder named by their first letter, or on macOS, its hex code, like 78/xterm-256color.
+      def system_entry?(term)
+        SYSTEM_TERMINFO.any? do |folder|
+          [term[0], term[0].ord.to_s(16)].any? { File.exist?(File.join(folder, it, term)) }
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/terminal/quiet.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Raindown
+  module TUI
+    # Keeps text off the screen while it's up, since it would be written over it, and scroll it from the bottom line.
+    module Quiet
+      module_function
+
+      # What's written to stderr while the block runs, like a warning, is written once it's done.
+      def holding_stderr
+        stderr = $stderr
+        $stderr = StringIO.new
+        yield
+      ensure
+        held = $stderr.string
+        $stderr = stderr
+        $stderr.write(held) unless held.empty?
+      end
+
+      # Ruby's warnings are off while the block runs.
+      def quietly
+        verbose = $VERBOSE
+        $VERBOSE = nil
+        yield
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+  end
+end

data/lib/raindown/tui/{screen.rb → terminal/screen.rb}

@@ -3,7 +3,9 @@
 require 'curses'
 
 require_relative 'input'
-require_relative 'layout'
+require_relative '../layout'
+require_relative 'quiet'
+require_relative 'ncurses_shim'
 require_relative 'styles'
 
 module Raindown
@@ -20,14 +22,20 @@ module Raindown
       end
 
       def run
+        Quiet.holding_stderr { loop_screen }
+      end
+
+      private
+
+      def loop_screen
         start
 
         loop do
           draw
-          effect = @navigator.handle(read)
+          effect = @navigator.next_step(read)
           break if effect == :quit
 
-          perform(*effect) if effect.is_a?(Array)
+          perform(effect)
         end
       rescue Interrupt
         nil
@@ -35,23 +43,18 @@ module Raindown
         stop
       end
 
-      private
-
-      def perform(name, *args)
-        case name
-        when :run
-          suspend { system(*args.first) }
-          @navigator.ran
-        when :wait
-          message, task = args
-          show(message)
-          task.call
+      # Runs a command, like the editor, then tells the Navigator, or shows a message while a slow task runs.
+      def perform(effect)
+        case effect
+        in Run(command:) then suspend { system(*command) }.then { @navigator.ran }
+        in Wait(message:, task:) then show(message).then { task.call }
+        else nil
         end
       end
 
       def start
         ENV['ESCDELAY'] ||= '25'
-        Curses.init_screen
+        NcursesShim.starting { Curses.init_screen }
         @styles = Styles.start
         Curses.noecho
         Curses.cbreak
@@ -59,7 +62,8 @@ module Raindown
         Curses.curs_set(0)
         Curses.stdscr.keypad(true)
         Curses.stdscr.timeout = TICK
-        Curses.mousemask(Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED | Input.wheel.keys.sum)
+        # The terminal sends the app its mouse events, so scrolling doesn't scroll the terminal either.
+        Curses.mousemask(Input::CLICKS)
         Curses.mouseinterval(0)
       end
 
@@ -80,9 +84,19 @@ module Raindown
           segments.each { |segment| paint(window, segment) }
         end
 
+        repaint_title(lines.first, window)
         window.refresh
       end
 
+      # The title's rain cloud is one column to ncurses, and two in terminals like iTerm and kitty, which would put
+      # the rest of the title a column out when ncurses changes part of it. So when it changes, the screen is
+      # repainted, and the title is written in one go.
+      def repaint_title(title, window)
+        text = title&.map(&:text)&.join
+        window.redraw if @title && text != @title
+        @title = text
+      end
+
       def paint(window, segment)
         window.attron(@styles.fetch(segment.style, Curses::A_NORMAL)) { window.addstr(segment.text) }
       end
@@ -102,8 +116,9 @@ module Raindown
         Input.key_event(key)
       end
 
+      # The curses gem warns the first time it makes a MouseEvent, that it's "undefining the allocator" of the class.
       def mouse
-        event = Curses.getmouse
+        event = Quiet.quietly { Curses.getmouse }
         Input.mouse_event(event, @zones) if event
       end
 

data/lib/raindown/tui/terminal/styles.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'curses'
+
+module Raindown
+  module TUI
+    # The curses attributes of a Layout's styles. The title is white on blue, and the selected row white on a lighter
+    # blue, or on dark grey in the panes without the focus, while other colours are on the terminal's own background.
+    # With only 8 colours, there's no dark grey, so those rows are underlined, and without colours,
+    # the rest are in reverse.
+    module Styles
+      COLORS = { directive: Curses::COLOR_CYAN, button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED,
+                 folder: Curses::COLOR_BLUE }.freeze
+      # The colours of endpoints' HTTP methods, like GET in green, from the 256 colours most terminals have,
+      # which are the same in every theme, unlike the 8 they all do, where green can look yellow.
+      METHODS = { get: 40, post: 33, delete: 196, put: 220, patch: 171, head: 44, options: 44 }.freeze
+      BASIC_METHODS = { get: Curses::COLOR_GREEN, post: Curses::COLOR_BLUE, delete: Curses::COLOR_RED,
+                        put: Curses::COLOR_YELLOW, patch: Curses::COLOR_MAGENTA, head: Curses::COLOR_CYAN,
+                        options: Curses::COLOR_CYAN }.freeze
+      # The title's and the selected row's blues, from the 256 colours most terminals have, or the 8 they all do.
+      BLUES = { title: 25, selected: 33 }.freeze
+      BASIC_BLUES = { title: Curses::COLOR_BLUE, selected: Curses::COLOR_CYAN }.freeze
+      BRIGHT_WHITE = 15
+      DARK_GREY = 238
+
+      module_function
+
+      # Sets up the colours, once the screen has started, and returns the attribute of each style.
+      def start
+        return plain unless Curses.has_colors?
+
+        start_colors
+        colored
+      end
+
+      def plain
+        { title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, selected_button: Curses::A_REVERSE,
+          cursor: Curses::A_UNDERLINE, cursor_button: Curses::A_UNDERLINE | Curses::A_BOLD, heading: Curses::A_BOLD,
+          body: Curses::A_DIM, error: Curses::A_BOLD, button: Curses::A_BOLD, folder: Curses::A_BOLD, project: Curses::A_BOLD, dashboard: Curses::A_BOLD,
+          key: Curses::A_REVERSE, border: Curses::A_DIM, run: Curses::A_REVERSE | Curses::A_BOLD, divider: Curses::A_BOLD,
+          selected_divider: Curses::A_REVERSE, cursor_divider: Curses::A_BOLD }
+      end
+
+      def colored
+        plain.merge(
+          title: pair(:title) | Curses::A_BOLD, selected: pair(:selected) | white_bold,
+          selected_button: pair(:selected_button) | Curses::A_BOLD, directive: pair(:directive),
+          error: pair(:error) | Curses::A_BOLD, button: pair(:button) | Curses::A_BOLD, divider: pair(:divider),
+          selected_divider: pair(:selected_divider), run: pair(:run) | Curses::A_BOLD, **files, **unfocused
+        )
+      end
+
+      def files
+        { folder: pair(:folder) | Curses::A_BOLD, project: pair(:directive) | Curses::A_BOLD,
+          dashboard: pair(:directive) | Curses::A_BOLD, **METHODS.keys.to_h { [:"method_#{it}", pair(:"method_#{it}") | Curses::A_BOLD] } }
+      end
+
+      # The selected rows of the panes without the focus, on dark grey where there's one.
+      def unfocused
+        return { cursor_button: pair(:button) | Curses::A_BOLD, cursor_divider: pair(:divider) } unless Curses.colors >= 256
+
+        { cursor: pair(:cursor), cursor_button: pair(:cursor_button) | Curses::A_BOLD, cursor_divider: pair(:cursor_divider) }
+      end
+
+      # Each colour pair as [name, foreground, background], where -1 is the terminal's own background.
+      def pairs
+        many = Curses.colors >= 256
+        blues = many ? BLUES : BASIC_BLUES
+        white = many ? BRIGHT_WHITE : Curses::COLOR_WHITE
+
+        [*COLORS.map { |name, color| [name, color, -1] },
+         *(many ? METHODS : BASIC_METHODS).map { |name, color| [:"method_#{name}", color, -1] },
+         [:title, white, blues[:title]],
+         [:selected, white, blues[:selected]], [:selected_button, Curses::COLOR_YELLOW, blues[:selected]],
+         [:cursor, white, DARK_GREY], [:cursor_button, Curses::COLOR_YELLOW, DARK_GREY], [:divider, blues[:title], -1],
+         [:selected_divider, blues[:title], blues[:selected]], [:cursor_divider, blues[:title], DARK_GREY],
+         [:run, white, Curses::COLOR_GREEN]]
+      end
+
+      def pair(name)
+        Curses.color_pair(pairs.index { it.first == name } + 1)
+      end
+
+      # The 8 colour white is grey, which bold brightens.
+      def white_bold
+        Curses.colors >= 256 ? Curses::A_NORMAL : Curses::A_BOLD
+      end
+
+      def start_colors
+        Curses.start_color
+        Curses.use_default_colors
+        pairs.each.with_index(1) { |(_name, foreground, background), index| Curses.init_pair(index, foreground, background) }
+      end
+    end
+  end
+end