charming 0.2.1 → 0.2.3

data/lib/charming/presentation/ui/adaptive_color.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Charming
+  module UI
+    # AdaptiveColor is a color value that resolves to its light or dark variant
+    # at render time, based on the detected terminal background. Build one with
+    # `UI.adaptive(light:, dark:)` and use it anywhere a color is accepted.
+    class AdaptiveColor
+      def initialize(light:, dark:)
+        @light = light
+        @dark = dark
+      end
+
+      # The variant readable on the current terminal background.
+      def resolve
+        Background.dark? ? @dark : @light
+      end
+    end
+  end
+end

data/lib/charming/presentation/ui/ansi_codes.rb

@@ -57,8 +57,10 @@ module Charming
       end
 
       # Resolves *color* to SGR codes, downconverting to the terminal's capability
-      # (see UI::ColorSupport): truecolor → 256 → 16 → none.
+      # (see UI::ColorSupport): truecolor → 256 → 16 → none. Adaptive colors
+      # resolve against the terminal background first.
       def color_codes(color, foreground:)
+        color = color.resolve if color.respond_to?(:resolve)
         return [] unless color
         return [] if ColorSupport.level == :none
         return indexed_color_code(color, foreground: foreground) if color.is_a?(Integer)
@@ -82,7 +84,8 @@ module Charming
 
       def truecolor_codes(color, foreground:)
         hex = color.to_s.delete_prefix("#")
-        raise ArgumentError, "truecolor must be #rrggbb" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+        hex = hex.chars.map { |digit| digit * 2 }.join if hex.match?(/\A[0-9a-fA-F]{3}\z/)
+        raise ArgumentError, "truecolor must be #rgb or #rrggbb" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
         return [foreground ? 38 : 48, 5, ColorSupport.hex_to_256(hex)] if ColorSupport.level == :color256
         return basic_color_code(ColorSupport.hex_to_16(hex), foreground: foreground) if ColorSupport.level == :color16
 

data/lib/charming/presentation/ui/background.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Charming
+  module UI
+    # Background tracks whether the terminal has a dark or light background so
+    # adaptive colors and the markdown :auto style can pick the readable variant.
+    #
+    # The runtime feeds a definitive answer from an OSC 11 query when the
+    # terminal replies to one (see TTYBackend#query_background_color); otherwise
+    # detection falls back to the COLORFGBG convention and finally assumes dark —
+    # the overwhelmingly common terminal default. `Background.assume = :light`
+    # overrides everything (useful in tests and for user preference).
+    module Background
+      MODES = %i[dark light].freeze
+
+      # ITU-R BT.601 luma threshold on 8-bit channels: below this is "dark".
+      LUMA_THRESHOLD = 128
+
+      module_function
+
+      # True when the terminal background is dark (the assumed mode, or detection).
+      def dark?
+        (@assumed || detect(ENV)) == :dark
+      end
+
+      # Overrides detection with :dark or :light; nil returns to auto-detection.
+      def assume=(value)
+        raise ArgumentError, "unknown background: #{value.inspect}" if value && !MODES.include?(value)
+
+        @assumed = value
+      end
+
+      # Detects the background from an environment hash via the COLORFGBG
+      # convention ("<fg>;<bg>", where bg 7 or 15 means a light background).
+      # Defaults to :dark when the environment says nothing.
+      def detect(env)
+        bg_index = env["COLORFGBG"].to_s.split(";").last
+        %w[7 15].include?(bg_index) ? :light : :dark
+      end
+
+      # Classifies an 8-bit RGB triple as :dark or :light by luma.
+      def classify(red, green, blue)
+        luma = (0.299 * red) + (0.587 * green) + (0.114 * blue)
+        (luma < LUMA_THRESHOLD) ? :dark : :light
+      end
+
+      # Parses an OSC 11 reply ("\e]11;rgb:RRRR/GGGG/BBBB" + BEL or ST) and
+      # classifies the reported color. Returns nil for anything unparseable.
+      def parse_osc11(reply)
+        match = reply.to_s.match(%r{\e\]11;rgb:(\h{2,4})/(\h{2,4})/(\h{2,4})})
+        return unless match
+
+        red, green, blue = match.captures.map { |channel| channel[0, 2].to_i(16) }
+        classify(red, green, blue)
+      end
+    end
+  end
+end

data/lib/charming/presentation/ui/border.rb

@@ -10,7 +10,11 @@ module Charming
         @horizontal, @vertical = edges
       end
 
+      # Resolves *name* to a Border: a Border instance passes through (custom
+      # borders), anything else is looked up in the built-in STYLES.
       def self.fetch(name)
+        return name if name.is_a?(Border)
+
         STYLES.fetch(name.to_sym)
       end
     end
@@ -27,7 +31,16 @@ module Charming
       ),
       double: Border.new(
         corners: ["╔", "╗", "╚", "╝"], edges: ["═", "║"]
+      ),
+      square: Border.new(
+        corners: ["┌", "┐", "└", "┘"], edges: ["─", "│"]
+      ),
+      hidden: Border.new(
+        corners: [" ", " ", " ", " "], edges: [" ", " "]
+      ),
+      block: Border.new(
+        corners: ["█", "█", "█", "█"], edges: ["█", "█"]
       )
-    }.freeze
+    }.tap { |styles| styles[:ascii] = styles[:normal] }.freeze
   end
 end

data/lib/charming/presentation/ui/border_painter.rb

@@ -2,14 +2,21 @@
 
 module Charming
   module UI
+    # BorderPainter draws a Border's glyphs around content lines, optionally
+    # coloring the border. *foreground* is a single color or a per-side hash
+    # (`{top:, right:, bottom:, left:}`); corners take the top/bottom row's
+    # color. *background* colors border cells; when it merely inherits the box
+    # background (background_explicit: false) it only paints alongside a
+    # foreground, preserving unstyled borders on unstyled boxes.
     class BorderPainter
       DEFAULT_SIDES = %i[top right bottom left].freeze
 
-      def initialize(border:, sides: nil, foreground: nil, background: nil)
+      def initialize(border:, sides: nil, foreground: nil, background: nil, background_explicit: false)
         @border = border
         @sides = Array(sides || DEFAULT_SIDES).map(&:to_sym)
         @foreground = foreground
         @background = background
+        @background_explicit = background_explicit
       end
 
       def paint(lines, inner_width)
@@ -22,34 +29,39 @@ module Charming
       private
 
       def border_line(line, width)
-        left = @sides.include?(:left) ? render_border(@border.vertical) : ""
-        right = @sides.include?(:right) ? render_border(@border.vertical) : ""
+        left = @sides.include?(:left) ? render_border(@border.vertical, :left) : ""
+        right = @sides.include?(:right) ? render_border(@border.vertical, :right) : ""
 
-        "#{left}#{line}#{" " * (width - Width.measure(line))}#{right}"
+        "#{left}#{Width.pad_to(line, width)}#{right}"
       end
 
       def top_border(horizontal)
         return unless @sides.include?(:top)
-        return render_border(horizontal) unless full_horizontal?
+        return render_border(horizontal, :top) unless full_horizontal?
 
-        render_border("#{@border.top_left}#{horizontal}#{@border.top_right}")
+        render_border("#{@border.top_left}#{horizontal}#{@border.top_right}", :top)
       end
 
       def bottom_border(horizontal)
         return unless @sides.include?(:bottom)
-        return render_border(horizontal) unless full_horizontal?
+        return render_border(horizontal, :bottom) unless full_horizontal?
 
-        render_border("#{@border.bottom_left}#{horizontal}#{@border.bottom_right}")
+        render_border("#{@border.bottom_left}#{horizontal}#{@border.bottom_right}", :bottom)
       end
 
       def full_horizontal?
         @sides.include?(:left) && @sides.include?(:right)
       end
 
-      def render_border(value)
-        return value unless @foreground
+      def render_border(value, side)
+        foreground = side_foreground(side)
+        return value unless foreground || @background_explicit
 
-        Style.new(foreground: @foreground, background: @background).render(value)
+        Style.new(foreground: foreground, background: @background).render(value)
+      end
+
+      def side_foreground(side)
+        @foreground.is_a?(Hash) ? @foreground[side] : @foreground
       end
     end
   end

data/lib/charming/presentation/ui/braille_canvas.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Charming
+  module UI
+    # BrailleCanvas is a monochrome subpixel drawing surface backed by Unicode braille glyphs
+    # (U+2800–U+28FF). Each character cell packs a 2×4 grid of dots, so the canvas addresses
+    # `width`×`height` *pixels* while rendering to `cols`×`rows` *cells* — 8× the vertical and 2× the
+    # horizontal resolution of plain text. It's pure text (works on every terminal) and composes via
+    # `row`/`column`/`Canvas` like any other block. Used by {Charming::Components::Chart}.
+    class BrailleCanvas
+      # The first braille code point; OR-ing dot bits onto it yields the glyph for a cell.
+      BASE = 0x2800
+
+      # Dot bit for each (x%2, y%4) position within a cell, indexed `DOTS[y % 4][x % 2]`.
+      DOTS = [[0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80]].freeze
+
+      # *width* and *height* are the drawable area in pixels (dots).
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @cols = (width + 1) / 2
+        @rows = (height + 3) / 4
+        @cells = Array.new(@rows) { Array.new(@cols, 0) }
+      end
+
+      attr_reader :width, :height, :cols, :rows
+
+      # Turns the dot at pixel (*x*, *y*) on (or off when `on: false`). Out-of-range points are
+      # ignored. Returns self for chaining.
+      def set(x, y, on: true)
+        return self unless x.between?(0, @width - 1) && y.between?(0, @height - 1)
+
+        bit = DOTS[y % 4][x % 2]
+        if on
+          @cells[y / 4][x / 2] |= bit
+        else
+          @cells[y / 4][x / 2] &= ~bit
+        end
+        self
+      end
+
+      # Turns the dot at pixel (*x*, *y*) off. Returns self.
+      def unset(x, y)
+        set(x, y, on: false)
+      end
+
+      # Draws a straight line between (*x0*, *y0*) and (*x1*, *y1*) with Bresenham's algorithm.
+      # Returns self.
+      def line(x0, y0, x1, y1)
+        dx = (x1 - x0).abs
+        dy = -(y1 - y0).abs
+        sx = (x0 < x1) ? 1 : -1
+        sy = (y0 < y1) ? 1 : -1
+        err = dx + dy
+        x = x0
+        y = y0
+        loop do
+          set(x, y)
+          break if x == x1 && y == y1
+
+          e2 = 2 * err
+          if e2 >= dy
+            err += dy
+            x += sx
+          end
+          if e2 <= dx
+            err += dx
+            y += sy
+          end
+        end
+        self
+      end
+
+      # Renders the canvas as `rows` lines of `cols` braille glyphs.
+      def to_s
+        @cells.map { |row| row.map { |bits| (BASE + bits).chr(Encoding::UTF_8) }.join }.join("\n")
+      end
+    end
+  end
+end

data/lib/charming/presentation/ui/canvas.rb

@@ -44,6 +44,7 @@ module Charming
 
       def self.offset(value, available, size)
         return [(available - size) / 2, 0].max if value == :center
+        return [((available - size) * value).round, 0].max if value.is_a?(Float)
 
         value
       end

data/lib/charming/presentation/ui/gradient.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Charming
+  module UI
+    # Gradient interpolates between two hex colors: blend a single point, build
+    # an evenly spaced ramp, or paint text with a per-character color sweep.
+    module Gradient
+      module_function
+
+      # Blends *start_hex* and *end_hex* ("#rrggbb") at fractional *amount*
+      # (0.0 → start, 1.0 → end), returning a "#rrggbb" string.
+      def blend(start_hex, end_hex, amount)
+        mixed = rgb(start_hex).zip(rgb(end_hex)).map do |from, to|
+          (from + ((to - from) * amount)).round
+        end
+        format("#%02x%02x%02x", *mixed)
+      end
+
+      # An evenly spaced ramp of *count* colors from *start_hex* to *end_hex*,
+      # endpoints included.
+      def steps(start_hex, end_hex, count)
+        return [blend(start_hex, end_hex, 0.0)] if count <= 1
+
+        Array.new(count) { |index| blend(start_hex, end_hex, index.to_f / (count - 1)) }
+      end
+
+      # Paints each grapheme cluster of plain-text *text* with a foreground color
+      # swept from *from* to *to* across its visible characters.
+      def colorize(text, from:, to:)
+        clusters = text.to_s.scan(Width::GRAPHEME)
+        span = [clusters.length - 1, 1].max
+
+        clusters.each_with_index.map do |cluster, index|
+          Style.new(foreground: blend(from, to, index.to_f / span)).render(cluster)
+        end.join
+      end
+
+      # Decomposes "#rrggbb" into [r, g, b] integers.
+      def rgb(hex)
+        value = hex.to_s.delete_prefix("#")
+        raise ArgumentError, "gradient colors must be #rrggbb" unless value.match?(/\A[0-9a-fA-F]{6}\z/)
+
+        [value[0..1], value[2..3], value[4..5]].map { |part| part.to_i(16) }
+      end
+    end
+  end
+end

data/lib/charming/presentation/ui/style.rb

@@ -18,6 +18,7 @@ module Charming
         @options = {
           attributes: [],
           padding: [0, 0, 0, 0],
+          margin: [0, 0, 0, 0],
           align: :left
         }.merge(options)
       end
@@ -49,11 +50,31 @@ module Charming
         with(padding: expand_box_values(values))
       end
 
+      # Returns a new Style with the margin set — blank space applied outside the border and
+      # untouched by the style's colors. Accepts the same CSS-style shorthand as `padding`.
+      def margin(*values)
+        with(margin: expand_box_values(values))
+      end
+
+      # Per-side setters: padding_top/right/bottom/left and margin_top/right/bottom/left,
+      # each returning a new Style with just that side changed.
+      %i[padding margin].each do |box|
+        %i[top right bottom left].each_with_index do |side, index|
+          define_method(:"#{box}_#{side}") do |value|
+            values = @options.fetch(box).dup
+            values[index] = value
+            with(box => values)
+          end
+        end
+      end
+
       # Returns a new Style with the border set. *style* is a border name (e.g., :normal,
-      # :rounded). *sides* optionally restricts the border to specific sides. *foreground*
-      # sets the border color.
-      def border(style = :normal, sides: nil, foreground: nil)
-        with(border: style, border_sides: sides, border_foreground: foreground)
+      # :rounded, :square, :hidden, :block) or a custom Border instance. *sides* optionally
+      # restricts the border to specific sides. *foreground* colors the border — a single
+      # color, or a per-side hash like `{top: :red, left: :green}`. *background* colors the
+      # border independently of the box background.
+      def border(style = :normal, sides: nil, foreground: nil, background: nil)
+        with(border: style, border_sides: sides, border_foreground: foreground, border_background: background)
       end
 
       # Returns a new Style that fixes the rendered width to *value* (in display columns).
@@ -66,19 +87,50 @@ module Charming
         with(height: value)
       end
 
+      # Returns a new Style that caps the rendered width to *value* display columns.
+      # Unlike `width`, content narrower than the cap is not padded out to it.
+      def max_width(value)
+        with(max_width: value)
+      end
+
+      # Returns a new Style that caps the rendered height to *value* rows. Unlike
+      # `height`, content shorter than the cap is not filled with blank rows.
+      def max_height(value)
+        with(max_height: value)
+      end
+
+      # Returns a new Style that word-wraps overflowing lines at the fixed width
+      # instead of clipping them.
+      def wrap
+        with(fit: :wrap)
+      end
+
+      # Returns a new Style that marks lines clipped at the fixed width with a
+      # trailing *ellipsis* instead of cutting them silently.
+      def truncate(ellipsis: Truncate::ELLIPSIS)
+        with(fit: :truncate, ellipsis: ellipsis)
+      end
+
       # Returns a new Style with horizontal alignment set (`:left`, `:right`, or `:center`).
       def align(value)
         with(align: value)
       end
 
+      # Returns a new Style with vertical alignment within a fixed height set
+      # (`:top`, `:middle`, or `:bottom`).
+      def align_vertical(value)
+        with(align_vertical: value)
+      end
+
       # Applies the configured style to *value* and returns the styled string. Steps:
-      # 1. wrap to `:width`, 2. align horizontally, 3. expand to `:height`, 4. apply padding,
-      # 5. paint border, 6. emit ANSI attribute/foreground/background escapes.
+      # 1. wrap to `:width`, 2. align horizontally and vertically, 3. expand to `:height`,
+      # 4. apply padding, 5. paint border, 6. emit ANSI attribute/foreground/background
+      # escapes, 7. surround with unstyled margin space.
       def render(value)
         lines = apply_dimensions(value.to_s.lines(chomp: true))
         lines = apply_padding(lines)
         lines = apply_border(lines)
-        apply_ansi(lines.join("\n"))
+        apply_margin(apply_ansi(lines.join("\n")))
       end
 
       private
@@ -91,40 +143,87 @@ module Charming
       # Wraps each line to the target width and applies horizontal alignment, then expands
       # to the target height.
       def apply_dimensions(lines)
+        lines = wrap_lines(lines)
         content_width = target_content_width(lines)
         dimensioned = lines.map { |line| align_line(fit_line(line, content_width), content_width) }
-        apply_height(dimensioned, content_width)
+        apply_max_height(apply_height(dimensioned, content_width))
+      end
+
+      # Word-wraps lines at the fixed width when the style is in wrap mode.
+      def wrap_lines(lines)
+        wrap_width = @options[:width]
+        return lines unless wrap_width && @options[:fit] == :wrap
+
+        wrapper = TextWrapper.new(width: wrap_width)
+        lines.flat_map { |line| wrapper.wrap(line).lines(chomp: true) }
       end
 
       # Returns the target content width: the explicit :width if set, otherwise the natural
-      # max display width of the lines.
+      # max display width of the lines, capped to :max_width when configured.
       def target_content_width(lines)
-        explicit_width = @options[:width]
-        natural_width = lines.map { |line| Width.measure(line) }.max || 0
-        explicit_width || natural_width
+        width = @options[:width] || Width.widest(lines)
+        max = @options[:max_width]
+        max ? [width, max].min : width
       end
 
-      # Clips *line* to *width* display columns, preserving ANSI styling where possible.
+      # Fits *line* into *width* display columns: clipped by default, or marked with an
+      # ellipsis in truncate mode. Preserves ANSI styling active at the cut.
       def fit_line(line, width)
         return line if Width.measure(line) <= width
+        return Truncate.tail(line, width, ellipsis: @options.fetch(:ellipsis, Truncate::ELLIPSIS)) if @options[:fit] == :truncate
 
         UI.visible_slice(line, 0, width)
       end
 
-      # Truncates or pads the lines array to *height* rows, filling with blank rows.
+      # Truncates or pads the lines array to *height* rows, distributing blank fill
+      # rows according to :align_vertical (:top, :middle, or :bottom).
       def apply_height(lines, width)
         height = @options[:height]
         return lines unless height
 
         visible = lines.first(height)
-        visible + Array.new([height - visible.length, 0].max) { " " * width }
+        distribute_rows(visible, height - visible.length, width)
+      end
+
+      # Places *missing* blank rows around *visible* per the vertical alignment.
+      def distribute_rows(visible, missing, width)
+        blank = ->(count) { Array.new([count, 0].max) { " " * width } }
+        case @options.fetch(:align_vertical, :top)
+        when :bottom
+          blank.call(missing) + visible
+        when :middle
+          top = missing / 2
+          blank.call(top) + visible + blank.call(missing - top)
+        else
+          visible + blank.call(missing)
+        end
+      end
+
+      # Surrounds the styled block with unstyled margin space: blank rows above and
+      # below, plain-space columns left and right. Applied after ANSI styling so the
+      # margin never carries the style's colors.
+      def apply_margin(styled)
+        top, right, bottom, left = @options.fetch(:margin)
+        return styled if [top, right, bottom, left].all?(&:zero?)
+
+        lines = styled.lines(chomp: true)
+        width = Width.widest(lines)
+        body = lines.map { |line| (" " * left) + Width.pad_to(line, width) + (" " * right) }
+        blank = " " * (left + width + right)
+        (Array.new(top, blank) + body + Array.new(bottom, blank)).join("\n")
+      end
+
+      # Caps the lines array to :max_height rows without filling missing rows.
+      def apply_max_height(lines)
+        max = @options[:max_height]
+        max ? lines.first(max) : lines
       end
 
       # Applies padding by prepending/appending blank rows (vertical) and indenting each
       # line (horizontal).
       def apply_padding(lines)
         top, right, bottom, left = @options.fetch(:padding)
-        inner_width = lines.map { |line| Width.measure(line) }.max || 0
+        inner_width = Width.widest(lines)
         empty = " " * (left + inner_width + right)
         padded = lines.map do |line|
           pad_line(line, inner_width, left, right)
@@ -143,7 +242,7 @@ module Charming
 
       # Pads a single line to *inner_width*, with *left* and *right* padding spaces.
       def pad_line(line, inner_width, left, right)
-        (" " * left) + line + (" " * (inner_width - Width.measure(line) + right))
+        (" " * left) + Width.pad_to(line, inner_width) + (" " * right)
       end
 
       # Builds a BorderPainter configured for the current border options.
@@ -152,13 +251,14 @@ module Charming
           border: Border.fetch(border_name),
           sides: @options[:border_sides],
           foreground: @options[:border_foreground],
-          background: @options[:background]
+          background: @options[:border_background] || @options[:background],
+          background_explicit: !@options[:border_background].nil?
         )
       end
 
       # Returns the natural display width of the longest line in *lines*.
       def content_width(lines)
-        lines.map { |line| Width.measure(line) }.max || 0
+        Width.widest(lines)
       end
 
       # Applies the active ANSI attribute/foreground/background codes to *value*.

data/lib/charming/presentation/{markdown → ui}/text_wrapper.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Charming
-  module Markdown
-    # TextWrapper wraps Markdown text blocks to a configured terminal width.
+  module UI
+    # TextWrapper greedily word-wraps text blocks to a display width.
     class TextWrapper
       def initialize(width:)
         @width = width
@@ -19,7 +19,7 @@ module Charming
       attr_reader :width
 
       def wrap_line(line)
-        return line if UI::Width.measure(line) <= width
+        return line if Width.measure(line) <= width
 
         wrap_words(line.split(/\s+/))
       end
@@ -31,7 +31,7 @@ module Charming
       def append_word(lines, word)
         current = lines.pop.to_s
         candidate = current.empty? ? word : "#{current} #{word}"
-        return lines.push(candidate) if current.empty? || UI::Width.measure(candidate) <= width
+        return lines.push(candidate) if current.empty? || Width.measure(candidate) <= width
 
         lines.push(current.rstrip, word)
       end

data/lib/charming/presentation/ui/truncate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Charming
+  module UI
+    # Truncate cuts ANSI-styled text down to a display width, marking the cut
+    # with a trailing ellipsis. Styling active at the cut is preserved and
+    # terminated, and multi-column glyphs are never split (matching ANSISlicer).
+    module Truncate
+      ELLIPSIS = "…"
+
+      module_function
+
+      # Truncates each line of *text* to *width* display columns, appending
+      # *ellipsis* to lines that overflow. Lines that fit are returned unchanged.
+      def tail(text, width, ellipsis: ELLIPSIS)
+        text.to_s.lines(chomp: true).map { |line| tail_line(line, width, ellipsis) }.join("\n")
+      end
+
+      def tail_line(line, width, ellipsis)
+        return line if Width.measure(line) <= width
+
+        ellipsis_width = Width.measure(ellipsis)
+        return ANSISlicer.slice(line, 0, width) if ellipsis_width >= width
+
+        ANSISlicer.slice(line, 0, width - ellipsis_width) + ellipsis
+      end
+    end
+  end
+end

data/lib/charming/presentation/ui/width.rb

@@ -44,6 +44,17 @@ module Charming
       def strip_ansi(value)
         value.to_s.gsub(ANSI_PATTERN, "")
       end
+
+      # Pads *line* with trailing spaces to *width* display columns. Lines already at
+      # or beyond the target are returned unchanged.
+      def pad_to(line, width)
+        line + (" " * [width - measure(line), 0].max)
+      end
+
+      # The maximum display width across *lines*; 0 when there are none.
+      def widest(lines)
+        lines.map { |line| measure(line) }.max || 0
+      end
     end
   end
 end