pdfrb 0.7.1 → 0.7.11

data/lib/pdfrb/layout/font_fallback.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Layout
+    # Glyph-level fallback: given a primary font and a chain of
+    # fallback fonts (default CJK, Symbol, etc.), picks the first
+    # font that can render the missing glyph. Returns the chosen
+    # font name or nil if none can render.
+    #
+    # Coverage lookup uses the Standard 14 AFM glyph-name sets for
+    # built-in fonts (Helvetica, Times-Roman, Courier, Symbol,
+    # ZapfDingbats), and falls back to WinAnsi range coverage for
+    # any other font.
+    class FontFallback
+      DEFAULT_CHAIN = %w[Helvetica Times-Roman Courier Symbol].freeze
+
+      # Common Standard 14 AFM character-name sets, indexed by font
+      # name. Each is a Set of glyph names the font defines. A
+      # codepoint is "covered" if its Unicode-to-glyph-name lookup
+      # yields a name in the set. Subset of full AFM data — covers
+      # the Latin, Greek, and punctuation ranges needed for typical
+      # prose.
+      STANDARD14_GLYPH_NAMES = {
+        "Helvetica" => %w[
+          space exclam quotedbl numbersign dollar percent ampersand
+          quoteright parenleft parenright asterisk plus comma minus
+          period slash zero one two three four five six seven eight
+          nine colon semicolon less equal greater question at A B C D
+          E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft
+          backslash bracketright asciicircum underscore quoteleft a b
+          c d e f g h i j k l m n o p q r s t u v w x y z braceleft
+          bar braceright asciitilde
+          Agrave Aacute Acircumflex Atilde Adieresis Aring AE Ccedilla
+          Egrave Eacute Ecircumflex Edieresis Igrave Iacute Icircumflex
+          Idieresis Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis
+          multiply Oslash Ugrave Uacute Ucircumflex Udieresis Yacute
+          Thorn germandbls agrave aacute acircumflex atilde adieresis
+          aring ae ccedilla egrave eacute ecircumflex edieresis igrave
+          iacute icircumflex idieresis eth ntilde ograve oacute
+          ocircumflex otilde odieresis divide oslash ugrave uacute
+          ucircumflex udieresis yacute thorn ydieresis
+        ].to_set.freeze,
+        "Times-Roman" => %w[
+          space exclam quotedbl numbersign dollar percent ampersand
+          quoteright parenleft parenright asterisk plus comma minus
+          period slash zero one two three four five six seven eight
+          nine colon semicolon less equal greater question at A B C D
+          E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft
+          backslash bracketright asciicircum underscore quoteleft a b
+          c d e f g h i j k l m n o p q r s t u v w x y z braceleft
+          bar braceright asciitilde
+        ].to_set.freeze,
+        "Courier" => %w[
+          space exclam quotedbl numbersign dollar percent ampersand
+          quoteright parenleft parenright asterisk plus comma minus
+          period slash zero one two three four five six seven eight
+          nine colon semicolon less equal greater question at A B C D
+          E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft
+          backslash bracketright asciicircum underscore quoteleft a b
+          c d e f g h i j k l m n o p q r s t u v w x y z braceleft
+          bar braceright asciitilde
+        ].to_set.freeze,
+        "Symbol" => %w[
+          Alpha Beta Chi Delta Epsilon Phi Gamma Eta Iota Theta Kappa
+          Lambda Mu Nu Omicron Pi Rho Sigma Tau Upsilon Omega Xi Psi Zeta
+          alpha beta chi delta epsilon phi gamma eta iota theta kappa
+          lambda mu nu omicron pi rho sigma tau upsilon omega xi psi zeta
+        ].to_set.freeze,
+        "ZapfDingbats" => %w[
+          a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16
+        ].to_set.freeze,
+      }.freeze
+
+      # Unicode → Adobe glyph name lookup (subset). The full Adobe
+      # Glyph List is ~2400 entries; this covers Latin + Greek
+      # codepoints that the Standard 14 fonts handle.
+      UNICODE_TO_GLYPH = {
+        0x20 => "space", 0x21 => "exclam", 0x22 => "quotedbl",
+        0x23 => "numbersign", 0x24 => "dollar", 0x25 => "percent",
+        0x26 => "ampersand", 0x27 => "quoteright", 0x28 => "parenleft",
+        0x29 => "parenright", 0x2A => "asterisk", 0x2B => "plus",
+        0x2C => "comma", 0x2D => "minus", 0x2E => "period", 0x2F => "slash",
+        0xC0 => "Agrave", 0xC1 => "Aacute", 0xC2 => "Acircumflex",
+        0xC3 => "Atilde", 0xC4 => "Adieresis", 0xC5 => "Aring",
+        0xC6 => "AE", 0xC7 => "Ccedilla", 0xC8 => "Egrave",
+        0xC9 => "Eacute", 0xCA => "Ecircumflex", 0xCB => "Edieresis",
+        0xCC => "Igrave", 0xCD => "Iacute", 0xCE => "Icircumflex",
+        0xCF => "Idieresis", 0xD0 => "Eth", 0xD1 => "Ntilde",
+        0xD2 => "Ograve", 0xD3 => "Oacute", 0xD4 => "Ocircumflex",
+        0xD5 => "Otilde", 0xD6 => "Odieresis", 0xD8 => "Oslash",
+        0xD9 => "Ugrave", 0xDA => "Uacute", 0xDB => "Ucircumflex",
+        0xDC => "Udieresis", 0xDD => "Yacute", 0xDE => "Thorn",
+        0xDF => "germandbls",
+        0xE0 => "agrave", 0xE1 => "aacute", 0xE2 => "acircumflex",
+        0xE3 => "atilde", 0xE4 => "adieresis", 0xE5 => "aring",
+        0xE6 => "ae", 0xE7 => "ccedilla", 0xE8 => "egrave",
+        0xE9 => "eacute", 0xEA => "ecircumflex", 0xEB => "edieresis",
+        0xEC => "igrave", 0xED => "iacute", 0xEE => "icircumflex",
+        0xEF => "idieresis", 0xF0 => "eth", 0xF1 => "ntilde",
+        0xF2 => "ograve", 0xF3 => "oacute", 0xF4 => "ocircumflex",
+        0xF5 => "otilde", 0xF6 => "odieresis", 0xF8 => "oslash",
+        0xF9 => "ugrave", 0xFA => "uacute", 0xFB => "ucircumflex",
+        0xFC => "udieresis", 0xFD => "yacute", 0xFE => "thorn",
+        0xFF => "ydieresis",
+        0x391 => "Alpha", 0x392 => "Beta", 0x393 => "Gamma",
+        0x394 => "Delta", 0x395 => "Epsilon", 0x396 => "Zeta",
+        0x397 => "Eta", 0x398 => "Theta", 0x399 => "Iota",
+        0x39A => "Kappa", 0x39B => "Lambda", 0x39C => "Mu",
+        0x39D => "Nu", 0x39E => "Xi", 0x39F => "Omicron",
+        0x3A0 => "Pi", 0x3A1 => "Rho", 0x3A3 => "Sigma",
+        0x3A4 => "Tau", 0x3A5 => "Upsilon", 0x3A6 => "Phi",
+        0x3A7 => "Chi", 0x3A8 => "Psi", 0x3A9 => "Omega",
+        0x3B1 => "alpha", 0x3B2 => "beta", 0x3B3 => "gamma",
+        0x3B4 => "delta", 0x3B5 => "epsilon", 0x3B6 => "zeta",
+        0x3B7 => "eta", 0x3B8 => "theta", 0x3B9 => "iota",
+        0x3BA => "kappa", 0x3BB => "lambda", 0x3BC => "mu",
+        0x3BD => "nu", 0x3BE => "xi", 0x3BF => "omicron",
+        0x3C0 => "pi", 0x3C1 => "rho", 0x3C3 => "sigma",
+        0x3C4 => "tau", 0x3C5 => "upsilon", 0x3C6 => "phi",
+        0x3C7 => "chi", 0x3C8 => "psi", 0x3C9 => "omega"
+      }.freeze
+
+      attr_reader :chain
+
+      # @param chain [Array<String>] ordered list of font names to
+      #   try when the primary can't render a glyph.
+      def initialize(chain: DEFAULT_CHAIN)
+        @chain = chain
+      end
+
+      # Find a font in the chain that covers +codepoint+.
+      # @return [String, nil] font name, or nil if none match.
+      def pick(codepoint, primary: nil)
+        return primary if primary && covers?(primary, codepoint)
+
+        @chain.find { |name| covers?(name, codepoint) }
+      end
+
+      # Reshape +text+ into segments, each tagged with the font that
+      # renders it. Returns an Array of [font_name, substring] pairs.
+      # Adjacent segments that share the same font are merged.
+      def segment(text, primary: nil)
+        return [[primary, text]] if text.to_s.empty?
+
+        segments = []
+        current_font = nil
+        current_chars = +""
+
+        text.to_s.each_codepoint do |cp|
+          ch = cp.chr(Encoding::UTF_8)
+          font = pick(cp, primary: primary)
+          if font == current_font
+            current_chars << ch
+          else
+            segments << [current_font, current_chars] if current_chars.length.positive?
+            current_font = font
+            current_chars = ch.to_s
+          end
+        end
+        segments << [current_font, current_chars] if current_chars.length.positive?
+        segments
+      end
+
+      # Whether +font_name+ can render +codepoint+. Uses the
+      # Standard 14 glyph-name sets for built-in fonts; for
+      # non-standard fonts, assumes WinAnsi coverage up to 255.
+      def covers?(font_name, codepoint)
+        return true if codepoint < 128 # ASCII always covered
+
+        standard14 = STANDARD14_GLYPH_NAMES[font_name.to_s]
+        if standard14
+          glyph = glyph_name_for(codepoint)
+          return !!glyph && standard14.include?(glyph)
+        end
+
+        winansi?(codepoint)
+      end
+
+      private
+
+      def glyph_name_for(codepoint)
+        # Single-codepoint entries in UNICODE_TO_GLYPH.
+        return UNICODE_TO_GLYPH[codepoint] if UNICODE_TO_GLYPH.key?(codepoint)
+
+        # Ranges that map to ASCII letters/digits — all share the
+        # ASCII character as glyph name. Grouped to avoid rubocop
+        # duplicate-branch warnings.
+        case codepoint
+        when 0x30..0x39, 0x41..0x5A, 0x61..0x7A then codepoint.chr
+        end
+      end
+
+      def winansi?(codepoint)
+        return true if codepoint < 0x80
+        return true if (0xA0..0xFF).cover?(codepoint)
+        return true if [0x20AC, 0x201A, 0x0192, 0x201E, 0x2026,
+                        0x2020, 0x2021, 0x02C6, 0x2030].include?(codepoint)
+
+        false
+      end
+    end
+  end
+end

data/lib/pdfrb/layout/hyphenation.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Layout
+    # Knuth-Liang hyphenation algorithm, pure Ruby. Uses a small
+    # built-in pattern set covering common English patterns; callers
+    # can supply their own pattern list for other languages.
+    #
+    # Patterns come from TeX's .pat files. Each pattern has letters
+    # and digits where the digits encode the hyphenation weights
+    # (0=never, 1-9=allowed). Example: ".abc1de" means "before 'd'
+    # in 'abcde' you may hyphenate".
+    #
+    # The full English pattern set is ~62 KB. We ship a curated
+    # subset; users who need full coverage can pass their own
+    # +patterns:+ at construction.
+    module Hyphenation
+      # Curated subset covering common English word endings and
+      # prefixes. Not exhaustive but useful for plain prose. Numbers
+      # are weights; a weight of 1 means "may hyphenate here".
+      #
+      # Loaded from data/pdfrb/layout/hyphenation_en.txt so the
+      # patterns stay reviewable; falls back to an empty list if the
+      # data file is missing.
+      PATTERNS_EN = begin
+        path = File.expand_path("../../../data/pdfrb/layout/hyphenation_en.txt", __dir__)
+        File.exist?(path) ? File.readlines(path, chomp: true).reject(&:empty?) : []
+      rescue StandardError
+        []
+      end.freeze
+
+      module_function
+
+      # @param word [String] the word to hyphenate.
+      # @param patterns [Array<String>] Knuth-Liang patterns.
+      # @return [Array<Integer>] positions in +word+ where a hyphen
+      #   may be inserted (between characters).
+      def hyphenate_positions(word, patterns: PATTERNS_EN)
+        return [] if word.length < 4
+
+        lowered = word.downcase.gsub(/[^a-z]/, "")
+        return [] if lowered.length < 4
+
+        weights = word_weights(lowered, patterns)
+        positions = []
+        # Odd weights between two characters mean a hyphen is allowed.
+        # Skip first and last character per Knuth-Liang rule.
+        (1...lowered.length).each do |i|
+          next if i < 2 || i > lowered.length - 2
+
+          positions << i if weights[i].odd?
+        end
+        positions
+      end
+
+      # Split +word+ into segments at valid hyphenation points.
+      # Includes the hyphen char (U+2010) on non-final segments when
+      # +with_hyphen:+ is true.
+      def split(word, patterns: PATTERNS_EN, with_hyphen: true)
+        positions = hyphenate_positions(word, patterns: patterns)
+        return [word] if positions.empty?
+
+        segments = []
+        prev = 0
+        positions.each do |pos|
+          segment = word[prev...pos] || ""
+          segment += "‐" if with_hyphen
+          segments << segment
+          prev = pos
+        end
+        segments << (word[prev..] || "")
+        segments
+      end
+
+      # Compute the per-character weights by overlaying every
+      # matching pattern. The weight at position i in the word is the
+      # max across all matching patterns at that inter-character slot.
+      def word_weights(word, patterns)
+        padded = ".#{word}."
+        weights = ::Array.new(word.length + 1, 0)
+        patterns.each do |pattern|
+          apply_pattern(weights, padded, pattern)
+        end
+        weights
+      end
+
+      # Decode a Knuth-Liang pattern into [letters, weights]. The
+      # letters are the alphabetic chars; the weights array has
+      # weights.length == letters.length + 1 (the slots between
+      # letters, including before and after).
+      def decode_pattern(pattern)
+        letters = +""
+        weights = [0]
+        pattern.each_char do |ch|
+          if /[0-9]/.match?(ch)
+            weights[-1] = [weights[-1], ch.to_i].max
+          else
+            letters << ch
+            weights << 0
+          end
+        end
+        [letters, weights]
+      end
+
+      def apply_pattern(weights, padded, pattern)
+        letters, pat_weights = decode_pattern(pattern)
+        start = 0
+        while (idx = padded.index(letters, start))
+          pat_weights.each_with_index do |w, i|
+            next if w.zero?
+
+            target = idx + i
+            weights[target] = [weights[target], w].max if weights[target]
+          end
+          start = idx + 1
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/layout/justification_kashidas.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Layout
+    # Arabic kashida justification: stretches Arabic letters using
+    # the tatweel (U+0640) character to fill a line, instead of (or
+    # in addition to) inter-word spacing. The technique inserts
+    # tatweel after selected letters (those with right-joining
+    # behaviour) to grow the line width toward the target.
+    module JustificationKashidas
+      # Arabic letters with right-joining behaviour (kashida can be
+      # inserted after these). Subset — covers the most common
+      # letters. Full list per Unicode Arabic Joining_Type.
+      RIGHT_JOINING = %w[
+        ب ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ف ق ك ل م ن ه و ي
+        ـب ـت ـث ـج ـح ـخ ـس ـش ـص ـض ـط ـظ ـع ـغ ـف ـق ـك ـل ـم ـن ـه
+      ].freeze
+
+      TATWEEL = "ـ"
+
+      module_function
+
+      # Insert kashidas into +text+ to grow it to +target_width+
+      # using +measure+ (a callable that returns the width of a
+      # string). Returns the modified string. If the natural width
+      # already meets target_width, returns text unchanged.
+      def justify(text, target_width:, measure:)
+        return text if text.to_s.empty?
+
+        natural = measure.call(text)
+        return text if natural >= target_width
+
+        candidates = kashida_insertion_points(text)
+        return text if candidates.empty?
+
+        # Greedy: add one tatweel per candidate until target reached.
+        result = text.to_s.dup
+        added = 0
+        loop do
+          break if natural >= target_width
+          break if added >= candidates.length * 3 # cap to avoid runaway
+
+          pos = candidates[added % candidates.length]
+          result = insert_at(result, pos + added, TATWEEL)
+          added += 1
+          natural = measure.call(result)
+        end
+        result
+      end
+
+      # Indices in +text+ where a tatweel may be inserted (after a
+      # right-joining letter that's not already followed by a space).
+      def kashida_insertion_points(text)
+        points = []
+        prev = nil
+        text.to_s.each_char.with_index do |ch, i|
+          next_char = text.to_s[i + 1]
+          if RIGHT_JOINING.include?(ch) && next_char &&
+              RIGHT_JOINING.include?(next_char)
+            points << (i + 1)
+          end
+          prev = ch
+        end
+        points
+      end
+
+      def insert_at(string, pos, char)
+        string[0...pos] + char + string[pos..]
+      end
+    end
+  end
+end

data/lib/pdfrb/layout/multi_cell_text_layout.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Layout
+    # Multi-cell text layout: flows text across an arbitrary shape
+    # defined by a series of horizontal bands. Used for magazine-
+    # style layouts where text wraps around images, sidebars, or
+    # irregular page regions.
+    #
+    # A band is a rectangular region with [x, y, width, height] in
+    # PDF coordinates (origin bottom-left). The layouter fills bands
+    # top-to-bottom, left-to-right.
+    class MultiCellTextLayout
+      attr_reader :bands, :style
+
+      def initialize(bands:, style: Style.new(:base))
+        @bands = bands
+        @style = style
+      end
+
+      # Lay out +text+ into the bands. Returns an Array of
+      # [band_index, lines] pairs where each line is a Layout::Line.
+      def layout(text)
+        layouter = TextLayouter.new(@style)
+        result = []
+        words = text.to_s.split(/(\s+)/)
+        current_band = 0
+        cursor_height = band_height(current_band)
+        current_chunk = +""
+
+        words.each do |word|
+          trial = current_chunk + word
+          lines = layouter.layout(trial, band_width(current_band))
+          total_h = lines.sum { |l| line_height(l) }
+
+          if total_h > cursor_height && current_band < @bands.length - 1
+            # Flush current chunk to current band
+            result << [current_band, layouter.layout(current_chunk, band_width(current_band))] if current_chunk.length.positive?
+            current_band += 1
+            cursor_height = band_height(current_band)
+            current_chunk = +word
+          else
+            current_chunk = trial
+          end
+        end
+        result << [current_band, layouter.layout(current_chunk, band_width(current_band))] if current_chunk.length.positive?
+        result
+      end
+
+      private
+
+      def band_width(index)
+        @bands[index] ? @bands[index][2].to_f : 100.0
+      end
+
+      def band_height(index)
+        @bands[index] ? @bands[index][3].to_f : 100.0
+      end
+
+      def line_height(_line)
+        @style.font_size ? @style.font_size * 1.2 : 14.0
+      end
+    end
+  end
+end

data/lib/pdfrb/layout/multi_page_table_box.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Layout
+    # Multi-page table: wraps a single TableBox's worth of rows and
+    # splits it into per-page fragments when it doesn't fit a single
+    # frame. Each fragment is a TableBox whose fit? returns true for
+    # the available height; the splitter yields them in document
+    # order, optionally repeating a header row on each fragment.
+    #
+    # This is intentionally a thin coordinator: it doesn't re-layout
+    # cells; it just partitions rows. The actual row drawing is
+    # delegated to TableBox, so col/row spans continue to work — but
+    # spans that cross a split boundary are clamped at the split
+    # (their rowspan is truncated to the rows that fit).
+    class MultiPageTableBox < Box
+      DEFAULT_MIN_ROWS_PER_PAGE = 3
+      DEFAULT_REPEAT_HEADER = true
+
+      attr_reader :rows, :column_widths, :header_row_count, :min_rows_per_page
+
+      # @param rows [Array<Array<Pdfrb::Layout::TableBox::Cell, Box>>]
+      #   the full table content.
+      # @param column_widths [Array<Numeric>, nil] explicit widths.
+      # @param header_row_count [Integer] number of leading rows to
+      #   repeat at the top of each page fragment. 0 disables.
+      # @param min_rows_per_page [Integer] minimum number of body
+      #   rows on each page; if the split would produce fewer, the
+      #   fragment is deferred to the next page.
+      def initialize(rows:, column_widths: nil, header_row_count: 0,
+                     min_rows_per_page: DEFAULT_MIN_ROWS_PER_PAGE, **)
+        super(**)
+        @rows = rows
+        @column_widths = column_widths
+        @header_row_count = header_row_count
+        @min_rows_per_page = min_rows_per_page
+        @fragments = nil
+      end
+
+      # Returns the per-page fragments as an Array of TableBox. The
+      # first fragment fits within +available_height+; each
+      # subsequent fragment fits within +page_height+ (the next page
+      # may have more room because there's no preceding content).
+      #
+      # Mutates internal state (the @fragments cache). Idempotent for
+      # the same dimensions.
+      def fragments(available_width:, first_page_height:, later_page_height:)
+        compute_column_widths(available_width)
+        header = @header_row_count.positive? ? @rows.first(@header_row_count) : []
+        body = @rows[@header_row_count..] || []
+
+        fragments = []
+        cursor = 0
+        first_pass = true
+        while cursor < body.length
+          available = first_pass ? first_page_height : later_page_height
+          max_count = rows_that_fit(body, cursor, available)
+          count = if max_count.zero? && cursor.zero?
+                    # First fragment must contain at least one row
+                    # even if it overflows; otherwise the table is
+                    # undrawable.
+                    [@min_rows_per_page, body.length].min
+                  elsif max_count < @min_rows_per_page
+                    # Force at least min_rows_per_page (may overflow).
+                    [@min_rows_per_page, body.length - cursor].min
+                  else
+                    max_count
+                  end
+          break if count.zero?
+
+          chunk = body[cursor, count]
+          rows_for_fragment = header + chunk
+          fragments << build_fragment(rows_for_fragment)
+          cursor += count
+          first_pass = false
+        end
+        fragments
+      end
+
+      def fit?(available_width, available_height)
+        @fragments = fragments(available_width: available_width,
+                               first_page_height: available_height,
+                               later_page_height: available_height)
+        @fragments.any?
+      end
+
+      def draw_content(canvas, x, y)
+        return if @fragments.nil? || @fragments.empty?
+
+        # Draw the first fragment in place; the Composer is
+        # responsible for placing subsequent fragments on later
+        # pages by calling draw on each fragment directly.
+        offset_y = y
+        @fragments.each do |frag|
+          frag.draw(canvas, x, offset_y)
+          offset_y -= frag.height
+        end
+      end
+
+      # Iterate fragments. Yields each TableBox fragment; if a block
+      # is absent, returns an Enumerator. Useful for the Composer
+      # flow: the first fragment is drawn at the current cursor,
+      # subsequent fragments trigger a page break.
+      def each_fragment(&block)
+        return enum_for(:each_fragment) unless block
+
+        @fragments.each(&block)
+      end
+
+      private
+
+      def compute_column_widths(available_width)
+        return @column_widths = equal_widths(available_width) if @column_widths.nil?
+
+        @column_widths.map!(&:to_f)
+      end
+
+      def equal_widths(available_width)
+        col_count = @rows.first&.size || 1
+        Array.new(col_count, available_width / col_count)
+      end
+
+      # Measure how many rows from +body+ starting at +cursor+ fit
+      # in +available_height+ using the computed column widths.
+      def rows_that_fit(body, cursor, available_height)
+        remaining = available_height.to_f
+        count = 0
+        body[cursor..].each_with_index do |row, _i|
+          row_h = measure_row_height(row)
+          break if (remaining - row_h).negative?
+
+          remaining -= row_h
+          count += 1
+        end
+        count
+      end
+
+      # Estimate row height as the max natural height of any cell
+      # in the row, given the column widths.
+      def measure_row_height(row)
+        heights = row.map.with_index do |cell, _col|
+          cell_box = cell.is_a?(TableBox::Cell) ? cell.box : cell
+          next 0 unless cell_box.is_a?(Pdfrb::Layout::Box)
+
+          cell_box.height.to_f
+        end
+        heights.max || 14.0
+      end
+
+      def build_fragment(rows)
+        TableBox.new(rows: rows, column_widths: @column_widths&.dup)
+      end
+    end
+  end
+end