raindown 0.7.0 → 0.8.0

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/{feelings/code_box.rb → code_box.rb}

@@ -1,40 +1,48 @@
 # frozen_string_literal: true
 
-require_relative '../highlighter'
+require_relative 'highlighter'
 
 module Raindown
   module TUI
-    # Code feelings' box below the grid: the selected method's code, highlighted, its first lines or, expanded, all that
-    # fit, then why it felt that way while that's typed, below a line:
+    # 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 = 8
+      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 selected method's code in a box, then why it felt that way while that's typed, below a line.
+      # The method's code in a box, then the lines below it.
       def code_box
-        notes = []
-        notes = note_lines if view.typing?
-        [box_top(view.selected), *code_lines(height - Bins::BIN_LINES - BOX_LINES - MIN_GRID_ROWS - notes.length), *notes,
-         box_edge('╰', '╯')]
+        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
 
-      # The method's first lines, or all that fit in the room when it's expanded, highlighted and 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(room)
+      # 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 = highlighted_code.map { wrapped(it) }
+        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
@@ -42,13 +50,11 @@ module Raindown
         [*code, more_line(lines.length - fitting.length)]
       end
 
-      def highlighted_code = Highlighter.lines(dedented(view.selected.lines), filename: view.selected.path)
-
       # 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), :feelings]
+        lead = [carried_lead(parts, room), box_style]
         rest = room - display_width(lead[0])
         return [parts] if rest < 1
 
@@ -91,18 +97,8 @@ module Raindown
         boxed([[text, :button]], event: Click.new(pane:, index: view.cursor, action: :expand))
       end
 
-      # Why it felt that way, as it's typed, below a line, in as many lines as it takes.
-      def note_lines = [box_edge('├', '┤'), *hanging("Why #{view.noting.upcase}? > ", "#{view.note}▏").map { boxed([[it, :feelings]]) }]
-
-      # The text after the lead, wrapped to fit the box, with the lines after the first lined up under the text.
-      def hanging(lead, text)
-        indent = ' ' * display_width(lead)
-        lines = wrap(text, width - 6 - indent.length)
-        [lead, *Array.new(lines.length - 1, indent)].zip(lines).map(&:join)
-      end
-
-      # Where the method is, its name, and how many commits changed its file.
-      def box_top(method) = box_edge("╭─ #{where(method)} · #{method.label} ", " changed #{method.changes}× ─╮")
+      # 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)
@@ -114,7 +110,7 @@ module Raindown
 
       # 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(' │ ', :feelings, width: 3), *code_segments(parts, width - 6, event:), segment(' │', :feelings, width: 2)])
+        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.
@@ -122,7 +118,25 @@ module Raindown
         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}", :feelings, width: width - 1)])
+        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

data/lib/raindown/tui/endpoints.rb

@@ -3,7 +3,7 @@
 require_relative 'endpoint'
 require_relative 'views/endpoint_view'
 require_relative 'row'
-require_relative 'workers/worker'
+require_relative '../workers/worker'
 
 module Raindown
   module TUI
@@ -22,7 +22,7 @@ module Raindown
       def load
         @endpoints = @workers.each.flat_map do |worker|
           worker.call(:endpoints)
-        rescue Worker::Error
+        rescue Workers::Worker::Error
           []
         end
       end

data/lib/raindown/tui/events.rb

@@ -9,8 +9,10 @@ module Raindown
 
     # The mouse moving over what a click there would send, if anything, to show it, like a method's cells in bold.
     Hover = Data.define(:target)
+    # The mouse moved with its button held, by columns across and rows down, like to drag a blueprint's canvas.
+    Drag = Data.define(:columns, :rows)
 
-    # A character typed while typing, like in the search, which other keys' events would take, like "j" for :down.
+    # A character typed while typing, like in Teleport, which other keys' events would take, like "j" for :down.
     Type = Data.define(:text)
 
     # What the Screen does after an event, other than drawing again, or stopping for :quit.

data/lib/raindown/tui/feelings/bins.rb

@@ -6,17 +6,17 @@ module Raindown
   module TUI
     # Code feelings' bins below the code box, one for each temper, best to worst, each a box with its key's number, its
     # temper and a bar of how many feelings it holds, highlighted when it's the chosen temper:
-    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮ ╭─ 06 ────╮
-    #    │ FROLIC  │ │ HOPE    │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
-    #    │ ███░  9 │ │ ██░░  5 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
-    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮
+    #    │ FROLIC  │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
+    #    │ ███░  9 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
     module Bins
       # A bin's lines.
       BIN_LINES = 4
 
       private
 
-      # The six bins, each a box with its number, its temper, and a bar of how many feelings it holds.
+      # The five bins, each a box with its number, its temper, and a bar of how many feelings it holds.
       def bins
         counts = view.log.counts
         most = [counts.values.max, 1].max

data/lib/raindown/tui/feelings/{celebration.rb → celebration/celebration.rb}

@@ -3,9 +3,9 @@
 module Raindown
   module TUI
     # When a batch of code feelings is refined, like Severance's waffle party: rain, a frame each tick, for about five
-    # seconds of the Screen's 60 ms frames, then a waffle, until a key's pressed.
+    # seconds of the Screen's 50 ms frames, then a waffle, until a key's pressed.
     class Celebration
-      RAIN_FRAMES = 83
+      RAIN_FRAMES = 100
 
       attr_reader :frame
 
@@ -15,6 +15,9 @@ module Raindown
 
       def raining? = frame < RAIN_FRAMES
 
+      # The frames since the rain stopped, which pop the waffle.
+      def popping = frame - RAIN_FRAMES
+
       # Each tick's a frame, and any other key puts the waffle away, which is when it's over.
       def over?(key)
         @frame += 1 if key == :tick

data/lib/raindown/tui/feelings/{scene.rb → celebration/scene.rb}

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../text'
+require_relative '../../text'
+require_relative '../waffle/balloons'
+require_relative '../waffle/confetti'
+require_relative '../waffle/sparkles'
 require_relative 'fireworks'
 require_relative 'rain'
 

data/lib/raindown/tui/feelings/cell_moves.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The cells Code feelings' methods take in its grid, and how its cursor moves between them, along them and a row up
+    # or down.
+    module CellMoves
+      # Each cell's method, by its index, in reading order, in a grid as many cells across as the columns.
+      # They're kept, so up and down move a row.
+      # The first time the grid's drawn, with its rows, right after the view opens, the batch is picked to fill them, and
+      # again a while after the screen's resized, keeping the selected method where it's still in the batch.
+      def cells(columns, rows = nil)
+        was = selected
+        reselect(was) if rows && @week.fill(columns * rows)
+        @columns = columns
+        @cells = code_methods.each_with_index.flat_map { |method, index| [index] * method.size }
+      end
+
+      private
+
+      def move(by)
+        self.cursor = @cursor + by
+        nil
+      end
+
+      # To the method in the cell above or below the selected one's first cell.
+      def move_row(by)
+        cell = @cells[@cells.index(@cursor).to_i + (by * @columns)]
+        self.cursor = cell if cell
+        nil
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_code_box.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../code_box'
+
+module Raindown
+  module TUI
+    # Code feelings' CodeBox below the grid: the selected method's code, where it is and how many commits changed its
+    # file, then why it felt that way while that's typed, below a line.
+    module FeelingsCodeBox
+      include CodeBox
+
+      private
+
+      def boxed_method = view.selected
+      def box_title(method) = "#{where(method)} · #{method.label}"
+      def box_note(method) = " changed #{method.changes}× ─"
+      def box_style = :feelings
+      def box_parts(method) = highlighted(method)
+
+      # As many lines as fit expanded, with the bins and a few of the grid's rows left above it.
+      def box_room = height - Bins::BIN_LINES - BOX_LINES - MIN_GRID_ROWS
+
+      def box_footer
+        return [] unless view.typing?
+
+        note_lines
+      end
+
+      # Why it felt that way, as it's typed, below a line, in as many lines as it takes.
+      def note_lines = [box_edge('├', '┤'), *hanging("Why #{view.noting.upcase}? > ", "#{view.note}▏").map { boxed([[it, :feelings]]) }]
+
+      # The text after the lead, wrapped to fit the box, with the lines after the first lined up under the text.
+      def hanging(lead, text)
+        indent = ' ' * display_width(lead)
+        lines = wrap(text, width - 6 - indent.length)
+        [lead, *Array.new(lines.length - 1, indent)].zip(lines).map(&:join)
+      end
+    end
+  end
+end