raindown 0.7.0 → 0.8.0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require 'csv'
-require 'date'
 require 'fileutils'
 require 'open3'
+require 'time'
 
 module Raindown
   module TUI
@@ -26,8 +26,8 @@ module Raindown
     # felt at, which a node can count, like the README's code debt. A feeling about code that's since changed, or gone, moves to
     # .raindown/memories.csv, so the feelings stay few, and the history's kept.
     class FeelingsLog
-      TEMPERS = %w[frolic hope numb woe dread malice].freeze
-      HEADER = %i[when where method temper note commit checksum].freeze
+      TEMPERS = %w[frolic numb woe dread malice].freeze
+      HEADER = %i[timestamp commit checksum location method temper note].freeze
       def initialize(root:)
         @root = root
         @csv = File.join(root, '.raindown', 'feelings.csv')
@@ -39,13 +39,13 @@ module Raindown
       def add(feeling)
         method = feeling.method
         row = {
-          when: Date.today.iso8601,
-          where: where(method),
+          timestamp: Time.now.utc.iso8601,
+          commit:,
+          checksum: method.checksum,
+          location: location(method),
           method: method.label,
           temper: feeling.temper,
-          note: feeling.note,
-          commit:,
-          checksum: method.checksum
+          note: feeling.note
         }
         changed, others = rows.reject { felt_row?(it, method) }.partition { about?(it, method) }
         append_memories(changed)
@@ -53,9 +53,9 @@ module Raindown
       end
 
       # Moves the feelings about methods that have changed, or gone, since they were felt, from the methods there are
-      # now, to the memories. A row from before checksums were kept stays while its method's there.
+      # now, to the memories.
       def move_stale_to_memories(methods)
-        now = methods.flat_map { [[relative(it.path), it.label, it.checksum], [relative(it.path), it.label, '']] }.to_set
+        now = methods.to_set { method_key(it) }
         stale, current = rows.partition { !now.include?(key(it)) }
         return if stale.empty?
 
@@ -70,11 +70,12 @@ module Raindown
         @rows ||= CSV.read(@csv, headers: true, header_converters: :symbol).map(&:to_h)
       end
 
-      # Whether the method's been felt, by its file, name and code's checksum, wherever its line is now. A row from before
-      # checksums were kept has none, so it counts until the method's felt again.
+      # Whether the method's been felt, by its file, name and code's checksum, wherever its line is now. The answer's kept
+      # until a feeling's added.
       def felt?(method)
         @felt ||= rows.to_set { key(it) }
-        [method.checksum, ''].any? { @felt.include?([relative(method.path), method.label, it]) }
+        @felt_methods ||= {}
+        @felt_methods.fetch(method) { @felt_methods[method] = @felt.include?(method_key(method)) }
       end
 
       # How the method last felt, while its code's the same as when it was felt, or nil.
@@ -88,15 +89,16 @@ module Raindown
 
       private
 
-      def felt_row?(row, method) = about?(row, method) && [method.checksum, ''].include?(row[:checksum].to_s)
+      def felt_row?(row, method) = key(row) == method_key(method)
 
       def about?(row, method) = path(row) == relative(method.path) && row[:method] == method.label
 
       # The row's file, without the line the method was on.
-      def path(row) = row[:where].sub(/:\d+\z/, '')
+      def path(row) = row[:location].sub(/:\d+\z/, '')
 
-      # The row's file, method and checksum, which is empty for a row from before checksums were kept.
-      def key(row) = [path(row), row[:method], row[:checksum].to_s]
+      # The row's file, method and checksum, to match a method's.
+      def key(row) = [path(row), row[:method], row[:checksum]]
+      def method_key(method) = [relative(method.path), method.label, method.checksum]
 
       # Adds the rows to the memories, of feelings about code that's since changed or gone.
       def append_memories(rows)
@@ -115,10 +117,11 @@ module Raindown
           csv << HEADER
           rows.each { csv << it.values_at(*HEADER) }
         end
-        @rows = @felt = nil
+        @rows = @felt = @felt_methods = nil
       end
 
-      def where(method) = "#{relative(method.path)}:#{method.line}"
+      # The method's file and line.
+      def location(method) = "#{relative(method.path)}:#{method.line}"
 
       def relative(path) = path.delete_prefix(File.join(@root, ''))
 

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

@@ -2,60 +2,69 @@
 
 require 'zlib'
 
-require_relative '../../stat'
 require_relative '../renderers/renderer'
 require_relative 'bins'
-require_relative 'code_box'
-require_relative 'scene'
-require_relative 'waffle'
+require_relative 'feelings_code_box'
+require_relative 'magnifier'
+require_relative 'motion'
+require_relative 'celebration/scene'
+require_relative 'waffle/waffle'
 
 module Raindown
   module TUI
     # Code feelings, right of the files: the methods as clusters of digits in a grid, with the selected one highlighted
-    # and its code below, then why it felt that way while that's typed, then the six bins and how many each holds.
+    # and its code below, then why it felt that way while that's typed, then the five bins and how many each holds.
     # When the batch is refined, it rains over them, then there's a waffle:
     #     0  0  2  2  2  5  5  9  9  9  9  1
     #     1  3  3  7  7  7  6  4  4  0  8  8
     #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
     #    │ def segments_between(line, from, to)                              │
     #    ╰───────────────────────────────────────────────────────────────────╯
-    #    ╭─ 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 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
     class FeelingsRenderer < Renderer
       include Bins
-      include CodeBox
+      include FeelingsCodeBox
+      include Magnifier
+      include Motion
       include Waffle
 
-      # The columns and lines a cell takes, its digit small on the first line, with room around it for the digit magnified
-      # in a stat's block digits, over the line above and the spaces beside it, when its method's selected or the mouse is
-      # over it.
-      CELL = 6
-      CELL_LINES = 2
-      # The code box's lines of code that a batch is sized for.
-      FILLED_CODE_LINES = 1
-      # The drift from which a method's cells flicker, and the ticks, half a second each, between a cell's flickers.
+      # The columns a cell takes, on a line of its own, its digit small in the middle, which is magnified in a stat's block
+      # digits across the cell and over the cells above and below it when the mouse is over its method.
+      CELL = 3
+      # The drift from which a method's cells are restless, and flicker now and then.
       RESTLESS = 7
-      FLICKER_TICKS = 12
-      # How far a cell's digit is from its method's drift, by its roll out of NOISE_ROLL, so about three in ten are off.
-      NOISE = { 0 => -1, 1 => 1, 2 => -1, 3 => 1, 4 => -2, 5 => 2 }.freeze
+      # How far a cell's digit is from its method's drift, by its roll out of NOISE_ROLL, so about four in ten are off.
+      NOISE = { 0 => -1, 1 => 1, 2 => -1, 3 => 1, 4 => -2, 5 => 2, 6 => -3, 7 => 3 }.freeze
       NOISE_ROLL = 20
-      BUTTONS = [['Tab', 'Pane', :tab], ['1-6', 'Feel', nil], ['e', 'Edit', :edit], ['x', 'Fix', :execute],
+      # The smallest grid that's worth refining, below which the pane's red, saying the screen's too small, under a
+      # window with arrows out from its corners, when there's room for it.
+      MIN_COLUMNS = 15
+      MIN_ROWS = 5
+      TOO_SMALL = 'Screen too small.'
+      TOO_SMALL_ART = ['↖       ↗', '  ┌───┐  ', '  └───┘  ', '↙       ↘', ''].freeze
+      TITLE = 'Weekly Batch'
+      BUTTONS = [['Tab', 'Pane', :tab], ['1-5', 'Feel', nil], ['e', 'Edit', :edit], ['x', 'Fix', :execute],
                  ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
 
       def buttons = BUTTONS
       def page = 'Code feelings'
 
-      # How much of the batch has been refined, on the right of the line above the panes.
+      # The pane's title, in the middle of the line above the panes, with the border either side, in its colour.
       def spacer
-        progress = "#{view.batch.progress} "
-        progress_width = display_width(progress)
-        padded([segment('', :blank, width: [width - progress_width, 0].max), segment(progress, :body, width: progress_width)])
+        title = " #{TITLE} "
+        title_width = display_width(title)
+        left = [(width - title_width) / 2, 0].max
+        padded([segment('', :blank, width: left), segment(title, :divider, width: title_width),
+                segment('', :blank, width: [width - left - title_width, 0].max)])
       end
 
-      # The cells come first, as the first draw picks the batch to fill them.
+      # The cells come first, as the first draw picks the batch to fill them, unless the screen's too small for a grid.
       def lines
+        return too_small if too_small?
+
         cells = view.cells(columns, filled_rows)
         return instead if view.code_methods.empty? || view.celebration
 
@@ -67,74 +76,42 @@ module Raindown
 
       def view = navigator.view
 
-      # Instead of the grid, that there's nothing to feel, or rain and fireworks over the pane when the batch is refined,
-      # then a waffle.
+      # Instead of the grid, that there's nothing to feel, or the celebration.
       def instead
         return blank(" No functions or methods in #{File.basename(navigator.root)} to feel") if view.code_methods.empty?
-        return Scene.new(width:, height:).lines(view.celebration.frame) if view.animating?
 
-        waffle
+        celebration(view.celebration)
+      end
+
+      # Rain and fireworks over the pane when the batch is refined, then a waffle popping out, among confetti, balloons and
+      # sparkles.
+      def celebration(celebration)
+        return Scene.new(width:, height:).lines(celebration.frame) if celebration.raining?
+
+        waffle(Scene.new(width:, height:, animations: [Confetti, Balloons, Sparkles]).lines(celebration.popping), celebration.popping)
       end
 
-      # The rows of the grid around the selected method's, each its cells' lines, below a blank line that leaves the first
-      # row room to be magnified, above the lines below it, and blank lines for any left over.
+      # The rows of the grid around the selected method's, between blank lines that leave the first and last rows room to
+      # be magnified, above the lines below it, and blank lines for any left over.
       def grid(cells, below)
+        @cells = cells
         lines = [height - below, 0].max
-        rows = [(lines - 1) / CELL_LINES, 0].max
+        rows = [lines - 2, 0].max
         first = first_row(cells, columns, rows)
-        grid = magnified([padded([]), *grid_rows(cells, first, rows)], cells, first, rows)
+        grid = magnified([progress_line(cells, first, rows), *grid_rows(cells, first, rows), padded([])], cells, first, rows)
 
-        [*grid, *Array.new(lines - grid.length) { padded([]) }].first(lines)
+        [*grid, *Array.new([lines - grid.length, 0].max) { padded([]) }].first(lines)
       end
 
       # The cells' lines of the rows from the first.
-      def grid_rows(cells, first, rows)
-        Array.new(rows * CELL_LINES) { grid_line(cells, (first + (it / CELL_LINES)) * columns, columns, it % CELL_LINES) }
-      end
-
-      # The lines with the digits of the selected method, and the one the mouse is over, magnified, over the line above them
-      # and beside them, each across its whole cell and the line above it.
-      def magnified(lines, cells, first, rows)
-        magnified_cells(cells, first, rows).each do |index, click|
-          magnify_cell(lines, ((index / columns) - first) * CELL_LINES, cells[index], index, click)
-        end
-        lines
-      end
-
-      # The cell's digit magnified over the lines from the top one, across the whole cell.
-      def magnify_cell(lines, top, owner, index, click)
-        style = magnified_style(owner)
-        Stat::DIGITS[digit(owner, index).to_s].each_with_index do |text, line|
-          magnify(lines, top + line, segment(" #{text}  ", style, width: CELL, event: click), 1 + (index % columns * CELL))
-        end
-      end
-
-      # The selected method's cells, across the whole of each, on the selection's blue, so they join into one block.
-      def magnified_style(owner)
-        return :selected if owner == view.cursor
-
-        :feelings
-      end
-
-      # The cells of the rows from the first that are the selected method's, or the one the mouse is over's, with its click,
-      # unless they're blank.
-      def magnified_cells(cells, first, rows)
-        (first * columns...(first + rows) * columns).filter_map do |index|
-          owner = cells[index]
-          click = Click.new(pane:, index: owner, action: :focus)
-          [index, click] if owner && (owner == view.cursor || navigator.hovered == click) && !hidden?(owner)
-        end
-      end
-
-      def magnify(lines, line, segment, column)
-        lines[line] = overlay_segments(lines[line], [segment], column:)
-      end
+      def grid_rows(cells, first, rows) = Array.new(rows) { grid_line(cells, (first + it) * columns, columns) }
 
       def columns = [(width - 1) / CELL, 1].max
 
-      # The grid's rows with a code box of FILLED_CODE_LINES, between its top and bottom, which a batch fills. A taller box
-      # takes rows from the grid, which then scrolls to keep the selected method in view.
-      def filled_rows = [(height - BIN_LINES - 3 - FILLED_CODE_LINES) / CELL_LINES, 1].max
+      # The grid's rows between its blank lines, above the code box, as tall as it always is until it's expanded, and the
+      # bins, which a batch fills. An expanded box takes rows from the grid, which then scrolls to keep the selected method
+      # in view.
+      def filled_rows = [height - 2 - CODE_LINES - BOX_LINES - BIN_LINES, 1].max
 
       # The first row that shows, with the selected method's row in the middle where there's room.
       def first_row(cells, columns, rows)
@@ -143,37 +120,59 @@ module Raindown
       end
 
       # The cells' line of the row from the index.
-      def grid_line(cells, from, columns, line)
+      def grid_line(cells, from, columns)
         segments = (from...(from + columns)).filter_map do |index|
           owner = cells[index]
           next unless owner
 
           click = Click.new(pane:, index: owner, action: :focus)
-          segment(cell_text(owner, index, line), :feelings, width: CELL, event: click)
+          segment(cell_text(owner, index), grid_style(owner, index), width: CELL, event: click)
         end
         padded([segment('', :blank, width: 1), *segments])
       end
 
-      # The cell's line: its digit small on the first, or blank once its method's felt, but still there to select, which
-      # shows it again with its code.
-      def cell_text(owner, index, line)
-        return ' ' * CELL if hidden?(owner) || line.nonzero?
+      # The cell's digit, small, where it moves, or blank once its method's felt, but still there to select, which shows it
+      # again with its code.
+      def cell_text(owner, index)
+        return ' ' * CELL if hidden?(owner)
+
+        column = digit_column(owner, index)
+        "#{' ' * column}#{digit(owner, index)}#{' ' * (CELL - 1 - column)}"
+      end
+
+      # The selected method's cells, across the whole of each, on the selection's blue, so they join into one block, or on
+      # green when it's already been felt, and others as they move.
+      def grid_style(owner, index)
+        return cell_style(index) unless owner == view.cursor
+        return :felt_selected if view.batch.felt?(view.code_methods[owner])
 
-        "  #{digit(owner, index)}   "
+        :feelings_selected
       end
 
-      # Whether the method's felt, and not selected, so its cells are blank.
-      def hidden?(owner) = owner != view.cursor && view.batch.felt?(view.code_methods[owner])
+      # Whether the method's felt, and not selected, so its cells are blank, asked once a frame for each method.
+      def hidden?(owner)
+        @hidden ||= Hash.new { |hidden, felt| hidden[felt] = felt != view.cursor && view.batch.felt?(view.code_methods[felt]) }
+        @hidden[owner]
+      end
 
-      # Near the method's drift, from 0 to 9: a cell's checksum rolls a small chance of it being one or two away.
-      # A heavy method's cells also flicker one lower now and then, each at its own time, so they look restless.
+      # Near the method's drift, from 0 to 9: a cell's checksum rolls a small chance of it being one to three away, and a
+      # restless one flickers one lower now and then.
       def digit(owner, index)
         drift = view.code_methods[owner].drift
-        seed = Zlib.crc32("#{owner}:#{index}")
-        digit = (drift + NOISE.fetch(seed % NOISE_ROLL, 0)).clamp(0, 9)
-        return digit if drift < RESTLESS || ((view.tick + seed) % FLICKER_TICKS).nonzero?
+        (drift + NOISE.fetch(Zlib.crc32("#{owner}:#{index}") % NOISE_ROLL, 0)).clamp(0, 9) + flicker(owner, index)
+      end
 
-        digit - 1
+      def too_small? = columns < MIN_COLUMNS || filled_rows < MIN_ROWS
+
+      # The pane in red, saying the screen's too small, in the middle, with the cells laid out without picking a batch for
+      # so small a grid, so the keys still move between them.
+      def too_small
+        view.cells(columns)
+        shown = [*TOO_SMALL_ART, TOO_SMALL]
+        shown = [TOO_SMALL] if shown.length > height
+        lines = Array.new(height, '')
+        lines[(height - shown.length) / 2, shown.length] = shown
+        lines.map { [segment(it.center(width), :too_small)] }
       end
 
       def blank(message)

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative '../code_box'
 require_relative '../events'
-require_relative 'celebration'
+require_relative 'cell_moves'
+require_relative 'celebration/celebration'
 require_relative 'code_methods'
 require_relative 'feelings_log'
 require_relative 'weekly_batch'
@@ -10,29 +12,31 @@ module Raindown
   module TUI
     # Code feelings, like Severance's macrodata refinement: the project's functions and methods, in any language,
     # as clusters of digits in a grid, where long methods, and ones whose files keep changing, drift. The cursor moves
-    # between them, the selected one's code shows below the grid, its first lines or with Enter all that fits, and 1 to 6
-    # sort how it feels into a bin: frolic, hope, numb, woe, dread or malice, which notes it down in the FeelingsLog,
+    # between them, the selected one's code shows below the grid, its first lines or with Enter all that fits, and 1 to 5
+    # sort how it feels into a bin: frolic, numb, woe, dread or malice, which notes it down in the FeelingsLog,
     # staying on it. Woe, dread and malice ask why first, typed until Enter, or Esc to leave it out. E opens the method in the
     # editor, and X asks Claude Code to fix it, and either way it's read again after, to be felt again.
     class FeelingsView
+      include CellMoves
+      include ShownCode
+
       # Best to worst, as CodeHealth scores them, so the keys rate the code.
-      BINS = { bin1: 'frolic', bin2: 'hope', bin3: 'numb', bin4: 'woe', bin5: 'dread', bin6: 'malice' }.freeze
+      BINS = { bin1: 'frolic', bin2: 'numb', bin3: 'woe', bin4: 'dread', bin5: 'malice' }.freeze
       # The tempers that ask why.
       NOTED = %w[woe dread malice].freeze
       # Its own keys, besides the bins: Enter and Space show all of the selected method's code, or its first lines again.
       # Ctrl+T celebrates, to try the rain and the waffle, and isn't shown with the buttons.
-      KEYS = %i[up down left right edit execute tick enter toggle expand celebrate].freeze
+      KEYS = %i[up down left right edit execute enter toggle expand celebrate].freeze
 
       # The temper being noted, and the note typed so far, while it's asking why, whether the selected method's code
       # shows all that fits, until another's selected, and the rain then the waffle, once the batch is refined.
-      attr_reader :noting, :note, :cursor, :tick, :log, :expanded, :celebration
+      attr_reader :noting, :note, :cursor, :log, :celebration
 
       def initialize(root:)
         @root = root
         @log = FeelingsLog.new(root:)
         @last_feelings = {}
         @cursor = 0
-        @tick = 0
         @week = WeeklyBatch.new(log: @log)
       end
 
@@ -42,8 +46,17 @@ module Raindown
       def path = nil
       def changed? = false
       def typing? = !noting.nil?
-      def animating? = celebration&.raining? == true
-      def status(_navigator) = [:info, "This week's code to feel, #{batch.week}"]
+
+      # As fast as an animation while it celebrates, through the rain and the waffle, and otherwise reactive, so its digits
+      # tremble at the same pace whether it's used with the keys or the mouse.
+      def pace(_hovered)
+        return :animation if celebration
+
+        :reactive
+      end
+
+      # Opening it says nothing, as its title is above the grid.
+      def status(_navigator) = [:info, '']
 
       # Reads the code again, keeping the batch, like after a method's edited or fixed, and the selected method, by its
       # file and name, even when the methods around it change, moving the feelings about code that's changed, or gone, to
@@ -53,6 +66,11 @@ module Raindown
         every = CodeMethods.list(@root)
         @log.move_stale_to_memories(every)
         @week.read(every)
+        reselect(was)
+      end
+
+      # Selects the method again, by its file and name, wherever it is now, or keeps the cursor where it was.
+      def reselect(was)
         self.cursor = code_methods.index { [it.path, it.label] == [was&.path, was&.label] } || @cursor
       end
 
@@ -68,15 +86,6 @@ module Raindown
         @cursor = index
       end
 
-      # 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.
-      def cells(columns, rows = nil)
-        @week.fill(columns * rows) if rows
-        @columns = columns
-        @cells = code_methods.each_with_index.flat_map { |method, index| [index] * method.size }
-      end
-
       # Every key while it's asking why or celebrating, and otherwise its own, but Tab to the files, or left from the
       # first method.
       def next_step?(key)
@@ -88,7 +97,6 @@ module Raindown
       def next_step(key)
         return note_step(key) if typing?
         return @celebration = nil if celebration&.over?(key)
-        return (@tick += 1).then { nil } if key == :tick
         return (@celebration = Celebration.new).then { nil } if key == :celebrate
         return unless selected
         return feel(BINS[key]) if BINS.key?(key)
@@ -107,25 +115,13 @@ module Raindown
         when :down then move_row(1)
         when :edit then Edit.new(path: selected.path, line: selected.line)
         when :execute then fix
-        when :enter, :toggle, :expand then (@expanded = !@expanded).then { nil }
+        when :enter, :toggle, :expand then toggle_expanded
         end
       end
 
       # Asks to fix the method, with how it last felt, by its file and name, which stay the same when its lines change.
       def fix = Fix.new(feeling: @last_feelings[[selected.path, selected.label]] || Feeling.new(method: selected, temper: nil, note: nil))
 
-      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
-
       # Frolic and numb are noted down straight away, while the rest ask why first.
       def feel(temper)
         return note_down(temper, nil) unless NOTED.include?(temper)

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../stat'
+
+module Raindown
+  module TUI
+    # Code feelings' magnified digits: the method the mouse is over's, in purple and lavender by turns, so the digits
+    # beside and below each other stand apart, each in a stat's block digits across its cell and the cells above and below
+    # it, drawn over the grid.
+    module Magnifier
+      private
+
+      # The lines with the digits of the method the mouse is over magnified, each across its cell and the cells above and
+      # below it.
+      def magnified(lines, cells, first, rows)
+        magnified_cells(cells, first, rows).each do |index|
+          magnify_cell(lines, (index / columns) - first, cells[index], index)
+        end
+        lines
+      end
+
+      # The cell's digit magnified over its row's line, the top one, and the lines above and below it.
+      def magnify_cell(lines, top, owner, index)
+        style = magnified_style(index)
+        Stat::DIGITS[digit(owner, index).to_s].each_with_index do |text, line|
+          magnify(lines, top + line, segment(text, style, width: FeelingsRenderer::CELL), 1 + (index % columns * FeelingsRenderer::CELL))
+        end
+      end
+
+      # Purple and lavender in turn, along the cell's row and down its column, like a chessboard's squares.
+      def magnified_style(index)
+        return :feelings_purple if ((index / columns) + (index % columns)).odd?
+
+        :feelings
+      end
+
+      # How much of the batch is refined, at the right of the line above the grid, or nothing while a magnified digit
+      # reaches it there.
+      def progress_line(cells, first, rows)
+        progress = "#{view.batch.progress} "
+        start = width - display_width(progress)
+        return padded([]) if magnified_from?(cells, first, rows, start)
+
+        padded([segment('', :blank, width: [start, 0].max), segment(progress, :body, width: display_width(progress))])
+      end
+
+      # Whether a magnified digit in the first row reaches the column, or past it.
+      def magnified_from?(cells, first, rows, column)
+        magnified_cells(cells, first, rows).any? { (it / columns) == first && 1 + (((it % columns) + 1) * FeelingsRenderer::CELL) > column }
+      end
+
+      # The cells of the rows from the first that are the method the mouse is over's, unless they're blank or selected,
+      # which keeps its selection's style.
+      def magnified_cells(cells, first, rows)
+        (first * columns...(first + rows) * columns).select do |index|
+          owner = cells[index]
+          owner && owner != view.cursor && navigator.hovered == Click.new(pane:, index: owner, action: :focus) && !hidden?(owner)
+        end
+      end
+
+      # The segment over the line at the column, clicking whatever cell it covers, so the mouse over it is over that cell.
+      def magnify(lines, line, segment, column)
+        covered = segments_between(lines[line], column, column + display_width(segment.text)).first
+        lines[line] = overlay_segments(lines[line], [segment.with(event: covered&.event)], column:)
+      end
+    end
+  end
+end