raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/blueprints/blueprints_view.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative '../code_box'
+require_relative '../events'
+require_relative '../../blueprints'
+require_relative 'traced_code'
+require_relative 'canvas'
+require_relative 'code_comments'
+require_relative 'filter'
+
+module Raindown
+  module TUI
+    # The blueprints from Claude Code's replies, in the project's .raindown/blueprints.md, newest first, then those in its
+    # code's comments, one at a time, of
+    # those its Filter's keywords match, each traced to its code: the arrows move between the boxes drawn in one, or a
+    # click on one, the code each box names shows below, Space or another click moving on to
+    # the next it names, Enter showing more of it, and E opens it, or the blueprint when the box names none.
+    # The file's read again when it changes, like when a reply's saved more, showing the newest then.
+    class BlueprintsView
+      include Canvas
+      include TracedCode
+      include ShownCode
+      include Filter
+
+      # Left and right move between the boxes drawn in a blueprint, in reading order, and up and down to the nearest box
+      # above or below, while up and down move between the filter's matches.
+      BOX_MOVES = { left: -1, right: 1 }.freeze
+      MOVES = { up: -1, down: 1 }.freeze
+      BOX_ROWS = { up: :above?, down: :below? }.freeze
+      # Space moves on to the next code the selected box names, Enter or clicking its more lines shows them, and E opens it.
+      ACTIONS = { toggle: :next_code, enter: :toggle_expanded, expand: :toggle_expanded, edit: :edit }.freeze
+
+      attr_reader :cursor
+
+      def initialize(root:)
+        @root = root
+        @path = File.join(root, Blueprints::FILE)
+        @all = []
+        @cursor = 0
+        select_box(0)
+      end
+
+      def renderer = BlueprintsRenderer
+      def target = self
+      def path = nil
+      def pace(_hovered) = :active
+
+      def status(_navigator)
+        commented = @all.count { it.time.nil? }
+        [:info, "#{count(@all.length - commented, 'blueprint')} from Claude Code, in #{Blueprints::FILE}, and #{commented} in comments"]
+      end
+
+      # Whether there are any blueprints yet, saved or in the code's comments, which are looked for once until it's loaded.
+      def any? = File.exist?(@path) || commented.any?
+
+      # Whether the file's changed since it was read, so it's read again on the next tick.
+      def changed? = mtime != @read_at
+
+      def load
+        @read_at = mtime
+        newest = @all.first&.time
+        @commented = nil
+        @all = Blueprints.read(@root) + commented
+        self.cursor = 0 unless @all.first&.time == newest
+        self.cursor = @cursor
+      end
+
+      def selected = blueprints[@cursor]
+
+      # Another blueprint's shown from its first box, while the same one keeps its box and canvas, like when it's clicked.
+      def cursor=(index)
+        shown = selected
+        @cursor = index.clamp(0, [blueprints.length - 1, 0].max)
+        return if selected == shown
+
+        select_box(0)
+        follow(from_start: true)
+      end
+
+      # The selected box, of those drawn in the selected blueprint, or nil when it has none.
+      def box = (@box.to_i.clamp(0, boxes.length - 1) if boxes.any?)
+
+      # Every key but Tab to the files, or left from the first box, while the filter's closed.
+      def next_step?(key) = !%i[tab tick].include?(key) && !(key == :left && box.to_i.zero? && !typing?)
+
+      # The selected blueprint's characters by the columns they're shown in, with its boxes' sides straightened, and the
+      # boxes drawn in it, found again when another's selected.
+      def drawing
+        @drawing = [selected, Blueprints.tidied(Blueprints.columns(selected&.lines || []), boxes)] unless @drawing&.first == selected
+        @drawing.last
+      end
+
+      def boxes
+        @boxes = [selected, Blueprints.boxes(selected&.lines || [])] unless @boxes&.first == selected
+        @boxes.last
+      end
+
+      def next_step(key)
+        return filter_step(key) if typing?
+        return open_filter if %i[feelings filter].include?(key)
+        return clicked(key) unless key.is_a?(Symbol)
+        return move_box(BOX_MOVES[key]) if BOX_MOVES.key?(key)
+        return move_row(BOX_ROWS[key]) if BOX_ROWS.key?(key)
+        return scroll(*SCROLLS[key]) if SCROLLS.key?(key)
+
+        send(ACTIONS[key]) if ACTIONS.key?(key)
+      end
+
+      private
+
+      # The selected box's code, or the blueprint when the box names none.
+      def edit
+        return unless selected
+
+        method = code
+        return Edit.new(path: method.path, line: method.line) if method
+
+        Edit.new(path: File.join(@root, selected.path), line: selected.line)
+      end
+
+      # A click on a box drawn in the blueprint, which moves on to the next code it names when it's already selected.
+      def clicked(action)
+        return next_code if boxes.index(action) == box
+
+        select_box(boxes.index(action))
+      end
+
+      def move_box(by)
+        select_box((box + by).clamp(0, boxes.length - 1)) if box
+      end
+
+      # The nearest box above or below the selected one, if there's one that way.
+      def move_row(way)
+        from = boxes[box] if box
+        nearest = boxes.select { from && it.public_send(way, from) }.min_by { it.distance(from) }
+        select_box(boxes.index(nearest)) if nearest
+      end
+
+      def count(number, noun) = "#{number} #{number == 1 ? noun : "#{noun}s"}"
+
+      def mtime = File.exist?(@path) ? File.mtime(@path) : nil
+
+      def commented = @commented ||= CodeComments.blueprints(@root)
+    end
+  end
+end

data/lib/raindown/tui/blueprints/canvas.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A blueprint's drawing seen through the canvas, a window of a fixed size, from its offset: the columns and rows of
+    # the drawing off its left and top. The canvas follows the selected box, bringing it into view, until it's scrolled,
+    # with Shift and the arrows or by dragging the mouse, and follows again when another box is selected.
+    module Canvas
+      # Shift and an arrow scroll the canvas by columns across, or by rows up and down, like the arrows' own steps.
+      SCROLLS = { scroll_left: [-4, 0], scroll_right: [4, 0], scroll_up: [0, -1], scroll_down: [0, 1] }.freeze
+
+      # The offset for a canvas of the width and height, with the selected box in view while it's followed, and the
+      # drawing no further off than it can be while still filling the canvas.
+      def canvas(width, height)
+        column, row = @offset || [0, 0]
+        column, row = into_view(column, row, width, height) if @following && box
+        @offset = [column.clamp(0, [drawing_width - width, 0].max), row.clamp(0, [drawing_height - height, 0].max)]
+      end
+
+      # Whether there's more of the drawing past the canvas, to the left, right, top and bottom.
+      def beyond(width, height)
+        column, row = @offset
+        { left: column.positive?, right: drawing_width > column + width, up: row.positive?, down: drawing_height > row + height }
+      end
+
+      # Dragging the drawing moves it with the mouse, so the canvas scrolls the other way.
+      def drag(drag)
+        scroll(-drag.columns, -drag.rows)
+      end
+
+      private
+
+      def scroll(columns, rows)
+        column, row = @offset || [0, 0]
+        @offset = [[column + columns, 0].max, [row + rows, 0].max]
+        @following = false
+        nil
+      end
+
+      # Shown from its first column and row, following the selected box, like when another blueprint's selected.
+      def follow(from_start: false)
+        @offset = [0, 0] if from_start
+        @following = true
+      end
+
+      # The offset moved as little as it can for the box to be in view, or its top left when it's bigger than the canvas.
+      def into_view(column, row, width, height)
+        selected_box = boxes[box]
+        column = selected_box.right - width + 1 if selected_box.right >= column + width
+        row = selected_box.bottom - height + 1 if selected_box.bottom >= row + height
+        [[column, selected_box.left].min, [row, selected_box.top].min]
+      end
+
+      def drawing_width = drawing.map(&:length).max.to_i
+      def drawing_height = drawing.length
+    end
+  end
+end

data/lib/raindown/tui/blueprints/code_comments.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../../blueprints'
+require_relative '../feelings/code_methods'
+
+module Raindown
+  module TUI
+    # The blueprints drawn in the comments above a project's classes and methods, like this codebase's renderers', each a
+    # run of lines indented further than the comment's prose, described by the prose above it, but not a code block,
+    # like an example of a file.
+    module CodeComments
+      # A comment's line, by what's after its marker and a space, in the languages Code feelings reads.
+      COMMENT = %r{\A\s*(?:#|//)(?: |\z)(.*)\z}
+      # A line of a comment that's drawn, indented further than its prose.
+      DRAWN_LINE = /\A  /
+
+      module_function
+
+      # The blueprints in the comments of the project's code, by file, from the top of each.
+      def blueprints(root)
+        CodeMethods.files(root).flat_map { |path| in_file(path, path.delete_prefix(File.join(root, ''))) }
+      end
+
+      def in_file(path, relative)
+        lines = File.readlines(path, chomp: true)
+        comments(lines).flat_map { |start, texts| drawings(texts, start, relative) }
+      rescue SystemCallError, ArgumentError
+        []
+      end
+
+      # Each block of comment lines above a class or method, by the index of its first line, with each line's text.
+      def comments(lines)
+        lines.each_index.filter_map do |index|
+          next unless lines[index].match?(COMMENT)
+          next if index.positive? && lines[index - 1].match?(COMMENT)
+
+          texts = lines[index..].take_while { it.match?(COMMENT) }.map { it[COMMENT, 1] }
+          [index, texts] if defines?(lines[index + texts.length])
+        end
+      end
+
+      def defines?(line) = line.to_s.match?(CodeMethods::DEFINITION) || line.to_s.match?(CodeMethods::OWNER)
+
+      # The comment's runs of indented lines that are blueprints, each described by the prose above it, if any.
+      def drawings(texts, start, path)
+        index = start
+        [[], *runs(texts)].each_cons(2).filter_map do |prose, drawn|
+          index += prose.length
+          next unless drawn.first.match?(DRAWN_LINE)
+
+          blueprint(drawn, prose.join(' ').strip, path:, line: index + 1)
+        end
+      end
+
+      # The comment's lines in runs of prose and of indented lines, by turns.
+      def runs(texts) = texts.slice_when { |before, after| before.match?(DRAWN_LINE) != after.match?(DRAWN_LINE) }
+
+      # The drawn lines, without the indent they share, as a blueprint when they're a drawing.
+      def blueprint(lines, prose, path:, line:)
+        indent = lines.map { it[/\A */].length }.min
+        lines = lines.map { it[indent..] }
+        return unless drawing?(lines)
+
+        Blueprints::Blueprint.new(time: nil, kind: Blueprints.kind(lines), lines:, path:, line:, description: (prose unless prose.empty?))
+      end
+
+      # Whether the lines are drawn, and whole, rather than a code block.
+      def drawing?(lines) = lines.none? { it.start_with?('```') } && lines.join.match?(Blueprints::DRAWN) && Blueprints.whole?(lines)
+    end
+  end
+end

data/lib/raindown/tui/blueprints/filter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The blueprints filtered by keywords, each a word in one or in its kind, ignoring case, typed into a box like
+    # Teleport's, which f or a click on the title opens. Up and down move between all the blueprints that match, as
+    # they're shown, with the box listing those around the selected one, Enter or a click keeps the filter, and Esc
+    # clears it.
+    module Filter
+      # The most matches the box lists at once.
+      LIMIT = 10
+
+      # The keywords typed, and whether the box is open, taking what's typed.
+      attr_reader :query
+
+      def typing? = @filtering == true
+
+      # The blueprints with every keyword, or all of them, filtered again only when the keywords or the blueprints change,
+      # as what's drawn asks for the selected one many times a frame.
+      def blueprints
+        @filtered = [query, @all, filtered(query.to_s.downcase.split)] unless filtered_now?
+        @filtered.last
+      end
+
+      # The box's matches, from the first it lists, each with its text and where it is, and the selected one, which is
+      # the one shown.
+      def matches = blueprints[first_match, LIMIT].to_a
+      def match = @cursor
+
+      # The first match the box lists, scrolled as little as it takes to list the selected one.
+      def first_match
+        first = @first_match.to_i.clamp(@cursor - LIMIT + 1, @cursor)
+        @first_match = [first, 0].max
+      end
+
+      # The f key opens the filter here, rather than Code feelings.
+      def own_key?(key) = key == :feelings
+
+      private
+
+      def filtered_now? = @filtered && @filtered[0] == query && @filtered[1].equal?(@all)
+
+      def filtered(keywords)
+        return @all if keywords.empty?
+
+        @all.select { |blueprint| keywords.all? { blueprint.words.downcase.include?(it) || blueprint.kind.include?(it) } }
+      end
+
+      def open_filter
+        @query = query.to_s
+        @filtering = true
+        nil
+      end
+
+      def filter_step(key)
+        case key
+        when Type then filter_to(query + key.text)
+        when :backspace then filter_to(query[0...-1])
+        when :up, :down then self.cursor = @cursor + self.class::MOVES[key]
+        when :enter then @filtering = false
+        when :escape then close_filter
+        end
+        nil
+      end
+
+      def filter_to(keywords)
+        @query = keywords
+        self.cursor = 0
+      end
+
+      def close_filter
+        filter_to('')
+        @filtering = false
+      end
+    end
+  end
+end

data/lib/raindown/tui/blueprints/traced_code.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../feelings/code_methods'
+
+module Raindown
+  module TUI
+    # The code a blueprint's box names, found among the project's methods, read once, when they're first needed, and which
+    # of it's shown.
+    module TracedCode
+      # The code the box names, each once, in the order it names it: by a method, like Watcher.listen or
+      # Navigator#next_step, or a class, like Workers, whose first method it is, or a method's name alone that only one
+      # method has.
+      def codes(box)
+        (@codes ||= {})[box] ||= box.text.scan(/[A-Z]\w*(?:::\w+)*(?:[.#][a-z_]\w*[?!]?)?|[a-z_]\w*[?!]?/).filter_map { named(it) }.uniq
+      end
+
+      # The code shown of what the selected box names, which Space or a click on the box moves on to the next of, or nil.
+      def code
+        named = codes(boxes[box]) if box
+        named[@code % named.length] if named&.any?
+      end
+
+      private
+
+      # The box at the index, showing the first code it names, from its first lines.
+      def select_box(index)
+        @box = index
+        @code = 0
+        @expanded = false
+        follow
+        nil
+      end
+
+      def next_code
+        @code += 1
+        @expanded = false
+        nil
+      end
+
+      # The method a name in a box names, by its owner and name, or its owner's first, or its name if only one has it.
+      def named(name)
+        owner, method = name.split(/[.#]/, 2)
+        owner = owner.split('::').last
+        return methods.find { it.owner == owner && it.name == method } if method
+        return first_method(owner) if owner.match?(/\A[A-Z]/)
+
+        found = methods.select { it.name == name }
+        found.first if found.one?
+      end
+
+      def first_method(owner) = methods.select { it.owner == owner }.min_by { [it.path, it.line] }
+
+      def methods = @methods ||= CodeMethods.list(@root)
+    end
+  end
+end

data/lib/raindown/tui/blueprints/tracing.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../code_box'
+
+module Raindown
+  module TUI
+    # A blueprint traced to its code: its lines and text cornflower blue, the selected box highlighted, on a canvas that
+    # scrolls, with a marker at each edge there's more beyond, then the code the selected box names in a box below it,
+    # as tall whether or not there's code, so the canvas above stays still.
+    module Tracing
+      include CodeBox
+
+      # The rows the canvas keeps when the code box is expanded.
+      MIN_CANVAS_ROWS = 2
+      # The line above the canvas, and the rows for its up and down markers.
+      AROUND_CANVAS = 3
+      # The most lines its description wraps onto, above the canvas.
+      DESCRIPTION_LINES = 3
+
+      private
+
+      # When it was saved and which one it is, then its description, then the canvas, between the rows for its up and
+      # down markers, then the code its selected box names, in a CodeBox, which takes rows from the canvas when it's
+      # expanded.
+      def traced_lines
+        box = code_box
+        description = description_lines
+        @canvas_height = [height - box.length - description.length - AROUND_CANVAS, 1].max
+        canvas = canvas_lines
+        [about(view.selected), *description, marker_line(:up, '▲'), *canvas, marker_line(:down, '▼'), *box].first(height)
+      end
+
+      # The paragraph above it in Claude Code's reply, below a blank line, in the text's own colour, wrapped.
+      def description_lines
+        description = view.selected.description
+        return [] unless description
+
+        lines = wrap(description, width - 2).first(DESCRIPTION_LINES).map { [segment(" #{it.rstrip}", :text)] }
+        [[segment('', :blank)], *lines]
+      end
+
+      # The canvas's rows of the drawing, from its offset, which follows the selected box.
+      def canvas_lines
+        column, row = view.canvas(canvas_width, canvas_height)
+        @beyond = view.beyond(canvas_width, canvas_height)
+        Array.new(canvas_height) { canvas_line(row + it, column, middle: it == canvas_height / 2) }
+      end
+
+      # The pane's width, less a column at each side for the left and right markers.
+      def canvas_width = [width - 2, 1].max
+
+      # The rows between the line above, the markers' rows and the code box.
+      attr_reader :canvas_height
+
+      # A row of the drawing seen through the canvas, from its column, with the left and right markers on the middle row.
+      def canvas_line(row, column, middle:)
+        segments = drawn_segments(view.drawing[row].to_a, row, column)
+        drawn = segments.sum { display_width(it.text) }
+        [marker(:left, '◀', middle), *segments, segment('', :blank, width: [canvas_width - drawn, 0].max), marker(:right, '▶', middle)]
+      end
+
+      # The line's columns across the canvas, from its column, in runs of the same style and box.
+      def drawn_segments(line, row, column)
+        runs = (column...[column + canvas_width, line.length].min).chunk_while { drawn_part(row, _1) == drawn_part(row, _2) }
+        runs.map { |run| run_segment(line, run, row) }
+      end
+
+      def marker(side, arrow, shown)
+        return segment(arrow, :divider, width: 1) if shown && @beyond[side]
+
+        segment(' ', :blank, width: 1)
+      end
+
+      # The row above or below the canvas, with its marker in the middle when there's more of the drawing that way.
+      def marker_line(side, arrow)
+        return [segment('', :blank)] unless @beyond[side]
+
+        [segment(arrow.center(width), :divider)]
+      end
+
+      def drawn_part(row, column) = [part_style(row, column), box_click(row, column)]
+
+      # The line's characters at the run of columns, in their style, which select their box when they're clicked, with half
+      # a wide character, cut at the canvas's edge, left blank.
+      def run_segment(line, run, row)
+        segment(line[run.first..run.last].join, part_style(row, run.first), width: run.size, event: box_click(row, run.first))
+      end
+
+      def box_click(row, column)
+        clicked = view.boxes.find { it.cover?(row, column) }
+        Click.new(pane:, index: view.cursor, action: clicked) if clicked
+      end
+
+      # The selected box highlighted, and the rest cornflower blue.
+      def part_style(row, column)
+        return :selected if view.box && view.boxes[view.box].cover?(row, column)
+
+        :divider
+      end
+
+      # The code box shows the code the selected box names, or that it names none.
+      def boxed_method = view.code
+      def box_style = :divider
+      def box_footer = []
+      def box_room = height - AROUND_CANVAS - BOX_LINES - MIN_CANVAS_ROWS
+
+      def box_title(method)
+        return 'No code' unless method
+
+        "#{where(method)} · #{method.owner}##{method.name}"
+      end
+
+      # Which of the code the box names is shown, at the right of the box's top, when it names more than one.
+      def box_note(method)
+        named = view.codes(view.boxes[view.box]) if method
+        return '' unless named && named.length > 1
+
+        " #{named.index(method) + 1} of #{named.length} ─"
+      end
+
+      # The method's code highlighted, or that the box names no code.
+      def box_parts(method)
+        return [[['Nothing in this box names a class or method in the code.', :body]]] unless method
+
+        highlighted(method)
+      end
+    end
+  end
+end

data/lib/raindown/tui/code_box.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'highlighter'
+
+module Raindown
+  module TUI
+    # A box of a method's code, highlighted, its first lines or, expanded, all that fit, like Code feelings' below its
+    # grid, with why it felt that way while that's typed, below a line, or Blueprints' below a blueprint:
+    #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
+    #    │ def segments_between(line, from, to)                              │
+    #    │ [12 more lines]                                                   │
+    #    ├───────────────────────────────────────────────────────────────────┤
+    #    │ Why DREAD? > column maths, a character at a time▏                 │
+    #    ╰───────────────────────────────────────────────────────────────────╯
+    # The renderer gives the method shown, as boxed_method, or nil, and box_title, box_note for the top's right, box_style,
+    # box_room, the most lines of code that fit expanded, box_parts, the lines it shows, and box_footer, any lines below them.
+    # Its view keeps what it shows, as ShownCode.
+    module CodeBox
+      # The most of a method's code that shows, until it's expanded, and the rows the grid keeps when it is.
+      CODE_LINES = 6
+      MIN_GRID_ROWS = 2
+      # The box's top and bottom, and the line of how many more lines there are.
+      BOX_LINES = 3
+
+      private
+
+      # The method's code in a box, then the lines below it.
+      def code_box
+        method = boxed_method
+        footer = box_footer
+        code = code_lines(box_parts(method), box_room - footer.length)
+        top = box_edge("╭─ #{box_title(method)} ", "#{box_note(method)}╮")
+        [top, *code, *blank_lines(code.length + footer.length), *footer, box_edge('╰', '╯')]
+      end
+
+      # Blank lines after a short method's code and its footer, so the box is always as tall as it gets until it's expanded,
+      # and what's above it stays still.
+      def blank_lines(used) = Array.new([CODE_LINES + 1 - used, 0].max) { boxed([]) }
+
+      # The first lines of the parts, or all that fit in the room when it's expanded, wrapped to fit the box, then how
+      # many more there are, clicked to show them, or a line to show fewer again.
+      def code_lines(parts, room)
+        shown = CODE_LINES
+        shown = [room, CODE_LINES].max if view.expanded
+        lines = parts.map { wrapped(it) }
+        fitting = lines.take_while { (shown -= it.length) >= 0 }
+        code = fitting.flatten(1).map { boxed(it) }
+        return code if lines.sum(&:length) <= CODE_LINES
+
+        [*code, more_line(lines.length - fitting.length)]
+      end
+
+      # The highlighted line's [text, style] parts in as many lines as it takes to fit the box, like a note's, those
+      # after the first carrying on after an ellipsis.
+      def wrapped(parts)
+        room = width - 6
+        lead = [carried_lead(parts, room), box_style]
+        rest = room - display_width(lead[0])
+        return [parts] if rest < 1
+
+        first, *others = line_breaks(parts.map { printable(it[0]) }.join, room, rest).each_cons(2).map { parts_between(parts, *it) }
+        [first, *others.map { [lead, *it] }]
+      end
+
+      # Where the text breaks into lines, the first fitting the room and the others the rest.
+      def line_breaks(text, room, rest)
+        breaks = [0]
+        fits = room
+        while text.length - breaks.last > fits
+          breaks << line_break(text, breaks.last, fits)
+          fits = rest
+        end
+        breaks << text.length
+      end
+
+      # Where a line from the column breaks: after the last space that fits, or where it's full when none does.
+      def line_break(text, from, fits)
+        space = text[from, fits].rindex(' ').to_i
+        return from + fits unless space.positive?
+
+        from + space + 1
+      end
+
+      # An ellipsis at the line's own indent, up to half the room, which the lines it's wrapped onto start with.
+      def carried_lead(parts, room) = "#{' ' * [parts.map(&:first).join[/\A */].length, room / 2].min}… "
+
+      # The parts' text between two columns, in their styles.
+      def parts_between(parts, from, to)
+        segments = parts.map { |text, style| Text::Segment.new(text: printable(text), style:, event: nil) }
+        segments_between(segments, from, to).map { [it.text, it.style] }
+      end
+
+      def more_line(hidden)
+        text = "[#{hidden} more lines]"
+        text = '[1 more line]' if hidden == 1
+        text = "[Fewer lines]#{" · #{hidden} more don't fit" if hidden.positive?}" if view.expanded
+        boxed([[text, :button]], event: Click.new(pane:, index: view.cursor, action: :expand))
+      end
+
+      # The method's code highlighted, kept by the view while it's shown.
+      def highlighted(method) = view.highlighted(method) { Highlighter.lines(dedented(method.lines), filename: method.path) }
+
+      # The lines without the indent they share, like a method's in its class.
+      def dedented(lines)
+        indent = lines.reject { it.strip.empty? }.map { it[/\A */].length }.min.to_i
+        lines.map { it[indent..].to_s }
+      end
+
+      def where(method) = "#{navigator.relative(method.path)}:#{method.line}"
+
+      # A line of the box, a column in from each side of the pane, of [text, style] parts, like highlighted code's.
+      def boxed(parts, event: nil)
+        padded([segment(' │ ', box_style, width: 3), *code_segments(parts, width - 6, event:), segment(' │', box_style, width: 2)])
+      end
+
+      # The box's top or bottom, with the left text cut short, rather than the corner, when there isn't room.
+      def box_edge(left, right)
+        room = width - 2 - display_width(right)
+        left = "#{fit(left, room - 1)} " if display_width(left) > room
+        fill = [room - display_width(left), 0].max
+        padded([segment(" #{left}#{'─' * fill}#{right}", box_style, width: width - 1)])
+      end
+    end
+
+    # What a view keeps of the code its CodeBox shows: whether it's expanded, and its highlighting, from frame to frame
+    # while it's the one shown.
+    module ShownCode
+      attr_reader :expanded
+
+      def highlighted(method)
+        @highlighted = { method => yield } unless @highlighted&.key?(method)
+        @highlighted[method]
+      end
+
+      private
+
+      def toggle_expanded
+        @expanded = !@expanded
+        nil
+      end
+    end
+  end
+end