raindown 0.5.1 → 0.7.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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:
+    #    ╭─ 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▏                 │
+    #    ╰───────────────────────────────────────────────────────────────────╯
+    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
+      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.
+      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('╰', '╯')]
+      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)
+        shown = CODE_LINES
+        shown = [room, CODE_LINES].max if view.expanded
+        lines = highlighted_code.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
+
+      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]
+        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
+
+      # 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 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(' │ ', :feelings, width: 3), *code_segments(parts, width - 6, event:), segment(' │', :feelings, 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}", :feelings, width: width - 1)])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'zlib'
+
+module Raindown
+  module TUI
+    # A function or method in a project's code, to sort how it feels: where it is, its lines, how many commits changed
+    # its file, and how much it drifts, from 0 to 9, which is how it ranks among the project's by both of them.
+    CodeMethod = Data.define(:path, :owner, :name, :line, :lines, :changes, :drift) do
+      # Like Layout#lines, or lines alone outside a class or the like.
+      def label = [owner, name].compact.join('#')
+
+      # A cell for every few lines, up to 8.
+      def size = ((lines.length / 4) + 1).clamp(1, 8)
+
+      # What drift ranks: long methods in files that keep changing weigh most.
+      def weight = lines.length * (changes + 1)
+
+      # Its code's checksum, which changes when its code does, but not its indent, trailing spaces or blank lines.
+      def checksum = Zlib.crc32(lines.map(&:strip).reject(&:empty?).join("\n")).to_s(16)
+    end
+
+    # Every function and method in a project's code, in any language: from Universal Ctags when it's installed,
+    # which knows over 100 languages, or else from how the code's indented. Specs, tests, and folders a project
+    # doesn't write, like vendor, are left out.
+    module CodeMethods
+      SKIPPED = %w[.git spec test tests vendor tmp pkg node_modules].freeze
+      # The kinds Ctags gives functions and methods, across languages.
+      KINDS = %w[function method singletonMethod procedure subroutine func constructor].freeze
+      # The files the indentation fallback reads, by extension.
+      EXTENSIONS = %w[rb py js mjs ts tsx jsx go rs java kt swift c h cc cpp cs php ex exs lua sh scala].freeze
+      MODIFIERS = '(?:(?:export|default|async|static|public|private|protected|pub(?:\(\w+\))?|override|final)\s+)*'
+      # A line that starts a function, with its name, like "def area", "pub fn draw(" or "func (s *Square) Area(".
+      DEFINITION = /\A\s*#{MODIFIERS}(?:def|function|fn|func|sub|proc)\s+(?:\([^)]*\)\s*)?(?:self\.)?([\w?!=]+)/
+      # A line that starts a class or the like, with its name, which names the functions inside it.
+      OWNER = /\A\s*#{MODIFIERS}(?:class|module|struct|impl|interface|trait|object)\s+(\w+(?:::\w+)*)/
+      # A line that closes a block, at the indent of the line that opened it.
+      CLOSER = /\A\s*(?:end\b|[}\])])/
+
+      module_function
+
+      def list(root)
+        changes = file_changes(root)
+        drifting((tagged(root) || indented(root)).map { it.with(changes: changes.fetch(it.path, 0)) })
+      end
+
+      # Each method with its drift, from 0 for the lightest to 9 for the heaviest, where methods that weigh the same
+      # drift the same, so the digits spread out in any project, whatever its language or size.
+      def drifting(methods)
+        weights = methods.map(&:weight).sort
+        methods.map { |method| method.with(drift: weights.bsearch_index { it >= method.weight } * 9 / [weights.length - 1, 1].max) }
+      end
+
+      # From Universal Ctags, or nil when it isn't installed, or the ctags installed is another, without JSON.
+      def tagged(root)
+        json, status = Open3.capture2('ctags', '--output-format=json', '--fields=+ne', '-R', '-f', '-',
+                                      *SKIPPED.map { "--exclude=#{it}" }, '.', chdir: root, err: File::NULL)
+        return unless status.success?
+
+        sources = Hash.new { |hash, path| hash[path] = File.readlines(path, chomp: true) }
+        json.each_line.filter_map { tag_method(root, JSON.parse(it), sources) }.sort_by { [it.path, it.line] }
+      rescue SystemCallError, JSON::ParserError
+        nil
+      end
+
+      def tag_method(root, tag, sources)
+        return unless tag['_type'] == 'tag' && KINDS.include?(tag['kind']) && tag['end']
+
+        path = File.join(root, tag['path'].delete_prefix('./'))
+        lines = sources[path][(tag['line'] - 1)...tag['end']]
+        CodeMethod.new(path:, owner: tag['scope']&.split(/\.|::/)&.last, name: tag['name'], line: tag['line'], lines:, changes: 0, drift: 0)
+      end
+
+      def indented(root)
+        files(root).flat_map { indented_in(it) }
+      end
+
+      def files(root)
+        Dir.glob('**/*', File::FNM_DOTMATCH, base: root)
+           .select { EXTENSIONS.include?(File.extname(it).delete_prefix('.')) }
+           .reject { it.split('/').intersect?(SKIPPED) }.sort.map { File.join(root, it) }
+      end
+
+      # Each line that starts a function, to where the indent comes back to its own, named after the class it's in.
+      def indented_in(path)
+        lines = File.readlines(path, chomp: true)
+        lines.each_index.filter_map do |index|
+          name = lines[index][DEFINITION, 1]
+          next unless name
+
+          CodeMethod.new(path:, owner: owner_of(lines, index), name:, line: index + 1,
+                         lines: lines[index..block_end(lines, index)], changes: 0, drift: 0)
+        end
+      rescue SystemCallError, ArgumentError
+        []
+      end
+
+      # The block's last line: the last one indented further than its first, or the line closing it, like "end".
+      def block_end(lines, index)
+        start = indent(lines[index])
+        last = index
+        lines.each_with_index.drop(index + 1).each do |line, number|
+          next if line.strip.empty?
+          return number if indent(line) == start && line.match?(CLOSER)
+          return last if indent(line) <= start
+
+          last = number
+        end
+        last
+      end
+
+      # The class or the like that the line's inside, by the nearest line above that's indented less and starts one.
+      def owner_of(lines, index)
+        depth = indent(lines[index])
+        owner = lines[0...index].reverse_each.find { indent(it) < depth && it.match?(OWNER) }
+        owner && owner[OWNER, 1].split('::').last
+      end
+
+      def indent(line) = line[/\A\s*/].length
+
+      # How many commits changed each file, from git log, or none outside a repository.
+      def file_changes(root)
+        log, status = Open3.capture2('git', '-C', root, 'log', '--format=', '--name-only', '--relative', err: File::NULL)
+        return {} unless status.success?
+
+        log.split("\n").reject(&:empty?).tally.transform_keys { File.join(root, it) }
+      rescue SystemCallError
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'date'
+require 'fileutils'
+require 'open3'
+
+module Raindown
+  module TUI
+    # How a method felt: one of Severance's four tempers, woe, frolic, dread or malice, or numb, with an optional note.
+    Feeling = Data.define(:method, :temper, :note) do
+      # What Claude Code is asked, to fix the method.
+      def prompt
+        "Refactor #{method.label} in #{method.path}:#{method.line}. #{felt} " \
+          "Keep its behaviour, follow the project's CLAUDE.md if it has one, and run the specs."
+      end
+
+      def felt
+        return 'It needs a second look.' unless temper
+
+        "It felt like #{temper}#{": #{note}" if note}."
+      end
+    end
+
+    # The feelings everyone's sorted about the code as it is now, kept in .raindown/feelings.csv with the commit they were
+    # 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
+      def initialize(root:)
+        @root = root
+        @csv = File.join(root, '.raindown', 'feelings.csv')
+        @memories = File.join(root, '.raindown', 'memories.csv')
+      end
+
+      # Adds the feeling, as the newest, in place of one about the method before, which moves to the memories if it was
+      # about the method's code before it changed.
+      def add(feeling)
+        method = feeling.method
+        row = {
+          when: Date.today.iso8601,
+          where: where(method),
+          method: method.label,
+          temper: feeling.temper,
+          note: feeling.note,
+          commit:,
+          checksum: method.checksum
+        }
+        changed, others = rows.reject { felt_row?(it, method) }.partition { about?(it, method) }
+        append_memories(changed)
+        write_rows(others + [row])
+      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.
+      def move_stale_to_memories(methods)
+        now = methods.flat_map { [[relative(it.path), it.label, it.checksum], [relative(it.path), it.label, '']] }.to_set
+        stale, current = rows.partition { !now.include?(key(it)) }
+        return if stale.empty?
+
+        append_memories(stale)
+        write_rows(current)
+      end
+
+      # Read once, and again after a feeling's added.
+      def rows
+        return [] unless File.exist?(@csv)
+
+        @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.
+      def felt?(method)
+        @felt ||= rows.to_set { key(it) }
+        [method.checksum, ''].any? { @felt.include?([relative(method.path), method.label, it]) }
+      end
+
+      # How the method last felt, while its code's the same as when it was felt, or nil.
+      def temper(method) = rows.reverse.find { felt_row?(it, method) }&.fetch(:temper)
+
+      # How many feelings there are of each temper, in the bins' order.
+      def counts
+        tally = rows.map { it[:temper] }.tally
+        TEMPERS.to_h { [it, tally.fetch(it, 0)] }
+      end
+
+      private
+
+      def felt_row?(row, method) = about?(row, method) && [method.checksum, ''].include?(row[:checksum].to_s)
+
+      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/, '')
+
+      # 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]
+
+      # Adds the rows to the memories, of feelings about code that's since changed or gone.
+      def append_memories(rows)
+        return if rows.empty?
+
+        header = !File.exist?(@memories)
+        CSV.open(@memories, 'a') do |csv|
+          csv << HEADER if header
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+      end
+
+      def write_rows(rows)
+        FileUtils.mkdir_p(File.dirname(@csv))
+        CSV.open(@csv, 'w') do |csv|
+          csv << HEADER
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+        @rows = @felt = nil
+      end
+
+      def where(method) = "#{relative(method.path)}:#{method.line}"
+
+      def relative(path) = path.delete_prefix(File.join(@root, ''))
+
+      def commit
+        sha, status = Open3.capture2('git', '-C', @root, 'rev-parse', '--short', 'HEAD', err: File::NULL)
+        sha.strip if status.success?
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../../stat'
+require_relative '../renderers/renderer'
+require_relative 'bins'
+require_relative 'code_box'
+require_relative 'scene'
+require_relative '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.
+    # 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 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    class FeelingsRenderer < Renderer
+      include Bins
+      include CodeBox
+      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.
+      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
+      NOISE_ROLL = 20
+      BUTTONS = [['Tab', 'Pane', :tab], ['1-6', '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.
+      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)])
+      end
+
+      # The cells come first, as the first draw picks the batch to fill them.
+      def lines
+        cells = view.cells(columns, filled_rows)
+        return instead if view.code_methods.empty? || view.celebration
+
+        below = [*code_box, *bins]
+        (grid(cells, below.length) + below).first(height)
+      end
+
+      private
+
+      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.
+      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
+      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.
+      def grid(cells, below)
+        lines = [height - below, 0].max
+        rows = [(lines - 1) / CELL_LINES, 0].max
+        first = first_row(cells, columns, rows)
+        grid = magnified([padded([]), *grid_rows(cells, first, rows)], cells, first, rows)
+
+        [*grid, *Array.new(lines - grid.length) { 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 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 first row that shows, with the selected method's row in the middle where there's room.
+      def first_row(cells, columns, rows)
+        last = [((cells.length - 1) / columns) - rows + 1, 0].max
+        ((cells.index(view.cursor).to_i / columns) - (rows / 2)).clamp(0, last)
+      end
+
+      # The cells' line of the row from the index.
+      def grid_line(cells, from, columns, line)
+        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)
+        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?
+
+        "  #{digit(owner, index)}   "
+      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])
+
+      # 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.
+      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?
+
+        digit - 1
+      end
+
+      def blank(message)
+        [[segment(message, :feelings)], *Array.new([height - 1, 0].max) { [segment('', :blank)] }].first(height)
+      end
+    end
+  end
+end