arrolio 0.1.0 → 0.1.2

data/lib/arrolio/renderer/pdf.rb

@@ -12,6 +12,15 @@ module Arrolio
     # subset + embed each font for the codepoints actually used
     # in the document.
     class Pdf
+
+      autoload :FontEmbedding, 'arrolio/renderer/pdf/font_embedding'
+      autoload :Assets, 'arrolio/renderer/pdf/assets'
+      autoload :Metadata, 'arrolio/renderer/pdf/metadata'
+
+      include FontEmbedding
+      include Assets
+      include Metadata
+
       MM_TO_PT = 2.83464567
 
       attr_reader :document, :fonts
@@ -41,83 +50,6 @@ module Arrolio
                         io: io.is_a?(String) ? nil : io)
       end
 
-      def apply_metadata(metadata)
-        info = @document.catalog.value[:Info]
-        info ||= @document.add({})
-        @document.catalog.value[:Info] = info
-        info.value[:Title] = metadata[:title] if metadata[:title]
-        info.value[:Author] = metadata[:author] if metadata[:author]
-        info.value[:Creator] = 'Arrolio (Ruby)'
-        info.value[:Producer] = 'Arrolio + Pdfrb'
-      end
-
-      # Emit an XMP metadata packet (RDF/XML) as a stream on the
-      # catalog's /Metadata entry. PDF readers use this for Dublin
-      # Core properties alongside the legacy /Info dict.
-      def attach_xmp_metadata(metadata)
-        xmp = XmpBuilder.new(metadata).build
-        stream = @document.add(
-          { Type: :Metadata, Subtype: :XML, Length: xmp.bytesize },
-          type: Pdfrb::Model::Cos::Stream
-        )
-        stream.stream = xmp
-        @document.catalog.value[:Metadata] =
-          Pdfrb::Model::Reference.new(stream.oid, stream.gen)
-      rescue StandardError => e
-        Arrolio::Logger.warn "XMP attach failed: #{e.class}: #{e.message[0, 80]}"
-      end
-
-      def register_logo(path)
-        return nil unless path
-
-        @document.images.add(path)
-      rescue StandardError => e
-        Arrolio::Logger.warn "logo load failed: #{e.class}: #{e.message[0, 80]}"
-        nil
-      end
-
-      def register_image(path)
-        return @images[path] if @images.key?(path)
-
-        resolved = resolve_image_for_pdfrb(path)
-        return nil unless resolved
-
-        @images[path] = @document.images.add(resolved)
-      rescue StandardError => e
-        Arrolio::Logger.warn "register_image failed for #{path}: #{e.class}: #{e.message[0, 80]}"
-        nil
-      end
-
-      # Pdfrb supports JPEG, PNG, and PDF — not SVG. If +path+ is an
-      # SVG file, rasterize it to PNG via rsvg-convert and cache the
-      # result. Returns the path to a pdfrb-compatible image file.
-      def resolve_image_for_pdfrb(path)
-        return path unless path.to_s.end_with?('.svg', '.SVG')
-        return path unless File.exist?(path)
-
-        png_path = svg_to_png_cache_path(path)
-        return png_path if File.exist?(png_path)
-
-        rasterize_svg(path, png_path)
-        File.exist?(png_path) ? png_path : path
-      end
-
-      def svg_to_png_cache_path(svg_path)
-        digest = Digest::MD5.file(svg_path).hexdigest
-        File.join(Dir.tmpdir, 'arrolio-svg-' + digest + '.png')
-      end
-
-      def rasterize_svg(svg_path, png_path)
-        require 'open3'
-        result = Open3.capture3('rsvg-convert', '-d', '96', '-p', '96',
-                                '-o', png_path, svg_path)
-        return if result[2].success?
-
-        Arrolio::Logger.warn "rsvg-convert failed: #{result[1]}"
-      rescue StandardError => e
-        Arrolio::Logger.warn "rasterize_svg failed: #{e.class}: #{e.message[0, 80]}"
-      end
-
       def header_footer_style
         return @header_footer_style if @header_footer_style
 
@@ -134,102 +66,12 @@ module Arrolio
         }.freeze
       end
 
-      def cover_logo_style
-        return @cover_logo_style if @cover_logo_style
-
-        config = @layout_spec&.cover_logo_config || {}
-        width_mm = config['width_mm'] || 35.0
-        ratio = config['aspect_ratio'] || (1459.0 / 1667.0)
-        margin_mm = config['margin_mm'] || 25.5
-        @cover_logo_style = {
-          width: width_mm * MM_TO_PT,
-          height: width_mm * ratio * MM_TO_PT,
-          margin: margin_mm * MM_TO_PT
-        }.freeze
-      end
 
       private
 
-      # Pre-scan all pages, collect codepoints per font family,
-      # then call Font::Embedder for each font_path.
-      def prepare_embedded_fonts(pages)
-        return if @font_paths.empty?
-
-        codepoints = Hash.new { |h, k| h[k] = [] }
-        pages.each { |page| collect_codepoints(page, codepoints) }
-        Arrolio::Logger.debug "collected codepoints for fonts: #{codepoints.keys.inspect}"
-        @font_paths.each do |font_name, path|
-          exists = File.exist?(path)
-          has_cp = codepoints.key?(font_name)
-          cp_count = codepoints[font_name]&.length || 0
-          Arrolio::Logger.debug "font #{font_name}: exists=#{exists} cp=#{cp_count}"
-          next unless exists
-          next unless has_cp
-
-          cps = codepoints[font_name].uniq
-          embedder = Font::Embedder.new(@document, path,
-                                        base_font_name: font_name)
-          ref = embedder.embed(cps)
-          attach_to_resources(font_name, ref)
-          @font_embedders[font_name] = embedder
-          @font_encoders[font_name] = Font::TextEncoder.new(embedder)
-          @font_refs[font_name] = ref
-        rescue StandardError => e
-          Arrolio::Logger.warn "embed failed for #{font_name}: #{e.class}: #{e.message[0,100]}"
-          Arrolio::Logger.debug e.backtrace.first(5).join("\n")
-        end
-      end
 
-      def attach_to_resources(font_name, ref)
-        catalog = @document.catalog
-        res = catalog.value[:Resources]
-        Arrolio::Logger.debug "attach_to_resources: Resources=#{res.class}"
-        unless res.is_a?(Hash) && res[:Font].is_a?(Hash)
-          catalog.value[:Resources] = { Font: {} }
-        end
-        font_hash = catalog.value[:Resources][:Font]
-        key = (format('EF%d', (font_hash.length + 1))).to_sym
-        font_hash[key] = ref
-        @embedded_resource_keys ||= {}
-        @embedded_resource_keys[font_name] = key
-      end
 
-      def collect_codepoints(page, by_font)
-        (page.static_regions.values + page.regions.values).each do |region|
-          region.placed_boxes.each do |box|
-            next unless box.kind == :text
-            next unless box.data.is_a?(Hash) && box.data[:lines]
-
-            box.data[:lines].each do |line|
-              next unless line.is_a?(TextLayout::Line)
-              line.placed_runs.each do |pr|
-                next unless pr.run.is_a?(InlineRun)
-                # Collect under the RUN'S font name, not the
-                # paragraph's. Italic/bold runs have different
-                # font_names and need their own subsets.
-                run_font = pr.run.style.font_name
-                next unless @font_paths.key?(run_font)
-                pr.run.text.each_codepoint { |cp| by_font[run_font] << cp }
-              end
-            end
-          end
-        end
-      end
 
-      def build_outline(context, _pages)
-        entries = context.heading_entries
-        return unless entries&.any?
-
-        pdfrb_pages = @document.pages.to_a
-        ob = OutlineBuilder.new(document: @document,
-                                entries: entries,
-                                pdfrb_pages: pdfrb_pages)
-        result = ob.build
-        Arrolio::Logger.debug "outline build returned: #{result.class}"
-      rescue StandardError => e
-        Arrolio::Logger.warn "outline build failed: #{e.class}: #{e.message[0,150]}"
-        Arrolio::Logger.debug e.backtrace.first(5).join("\n")
-      end
 
       def render_page(output_page)
         pdfrb_page = @document.pages.add(media_box: [0, 0,
@@ -240,6 +82,7 @@ module Arrolio
         pdfrb_page.value[:Resources] = catalog.value[:Resources]
         canvas = pdfrb_page.canvas
         render_cover_logo(canvas, output_page) if output_page.template_role == :cover && @logo_ref
+        render_page_title(canvas, output_page) if output_page.title_text
         render_header_footer(canvas, output_page) unless output_page.template_role == :cover
         render_page_footnotes(canvas, output_page) unless output_page.template_role == :cover
         (output_page.static_regions.values + output_page.regions.values).each do |region|
@@ -248,44 +91,35 @@ module Arrolio
         @link_annotator.flush(pdfrb_page)
       end
 
+      # Footnote bodies occupy the zone the engine reserved at the
+      # page bottom. The layout comes from
+      # FootnoteMarkerFlowable.body_flowable - the same policy the
+      # engine used to reserve the space - so the drawn block fits
+      # the reserved zone exactly.
       def render_page_footnotes(canvas, page)
-        return unless page.footnotes && !page.footnotes.empty?
-
-        hf = header_footer_style
-        y = hf[:margin_bottom] + 20
-        page.footnotes.each do |footnote|
-          marker = footnote.marker.to_s
-          body_text = footnote.body.map do |node|
-            node.is_a?(Arrolio::Content::Paragraph) ? node.text : node.to_s
-          end.join(' ')
-          line = "#{marker} #{body_text}".strip
-          next if line.empty?
-
-          payload = encoded_or_text(hf[:font_name], line)
-          ref = embedded_or_standard(hf[:font_name])
-          canvas.text(payload, at: [hf[:margin_lr], y], font: ref, size: 7.0)
-          y -= 9.0
+        return if page.footnotes.nil? || page.footnotes.empty?
+
+        style = footnote_style
+        body = page.body_region
+        width = body ? body.width : page.width * 0.85
+        x = body ? body.x : page.width * 0.075
+        flowables = page.footnotes.map do |footnote|
+          Flowables::FootnoteMarkerFlowable.body_flowable(footnote, style)
+        end
+        total = flowables.sum { |flow| flow.height(width) }
+        y = header_footer_style[:margin_bottom] + 20 + total
+        flowables.each do |flow|
+          boxes, = flow.emit(x, y, width, nil)
+          boxes.each { |box| render_box(canvas, box) }
+          y -= flow.height(width)
         end
       rescue StandardError => e
         Arrolio::Logger.warn "footnote render failed: #{e.class}: #{e.message[0, 80]}"
       end
 
-      def render_cover_logo(canvas, page)
-        logo_style = cover_logo_style
-        w = logo_style[:width]
-        h = logo_style[:height]
-        margin = logo_style[:margin]
-        x = page.width - margin - w
-        y = page.height - margin - h
-        invoke = invoke_xobject_op
-        return unless invoke
-
-        canvas.save_graphics_state do
-          canvas.concat(w, 0, 0, h, x, y)
-          canvas.emit_op(invoke, @logo_ref)
-        end
-      rescue StandardError => e
-        Arrolio::Logger.warn "logo render failed: #{e.class}: #{e.message[0, 80]}"
+      def footnote_style
+        style = @layout_spec&.resolve_style(:footnote)
+        style.nil? || style.font_size.nil? ? Style::Definition.new(font_size: 9.0) : style
       end
 
       def invoke_xobject_op
@@ -296,6 +130,24 @@ module Arrolio
         end
       end
 
+      def render_page_title(canvas, page)
+        header_footer_style
+        body = page.regions[:body]
+        return unless body
+
+        font_name = 'Times New Roman Bold'
+        size = 18.0
+        measurer = GlyphMeasurer.new(font_name: font_name)
+        tw = measurer.width_of_string(page.title_text, font_size: size)
+        x = (page.width - tw) / 2.0
+        baseline = body.y + body.height - 9.0
+        ref = embedded_or_standard(font_name)
+        payload = encoded_or_text(font_name, page.title_text)
+        canvas.text(payload, at: [x, baseline], font: ref, size: size)
+      rescue StandardError => e
+        Arrolio::Logger.warn "render_page_title failed: #{e.message[0, 80]}"
+      end
+
       def render_header_footer(canvas, page)
         hf_style = header_footer_style
         margin_top = hf_style[:margin_top]
@@ -344,48 +196,121 @@ module Arrolio
         when :rect then render_rect(canvas, box)
         when :line then render_line(canvas, box)
         when :image then render_image(canvas, box)
+        when :rotated_text then render_rotated_text(canvas, box)
         end
       end
 
+      def render_rotated_text(canvas, box)
+        text = box.data[:text]
+        style = box.data[:style]
+        angle = box.data[:angle].to_f
+        line_height = box.data[:line_height].to_f
+        font_name = style.font_name
+        ref = embedded_or_standard(font_name)
+        payload = encoded_or_text(font_name, text)
+        rad = angle * Math::PI / 180.0
+        cos = Math.cos(rad)
+        sin = Math.sin(rad)
+        baseline_y = box.y + line_height - GlyphMeasurer.new(font_name: font_name)
+                                                          .ascender(font_size: style.font_size)
+        # PDF text matrix is [a b c d e f] where (a,d) scale, (b,c) rotate,
+        # (e,f) translate. We rotate around the baseline starting point.
+        canvas.text(payload, at: [box.x, baseline_y], font: ref, size: style.font_size,
+                             tm: [cos, sin, -sin, cos, box.x, baseline_y])
+      rescue StandardError => e
+        Arrolio::Logger.warn "render_rotated_text failed: #{e.message[0, 80]}"
+      end
+
       def render_text(canvas, box)
         lines = box.data[:lines]
         line_height = box.data[:line_height]
         style = box.data[:style]
+        hanging_indent = box.data[:hanging_indent] || 0.0
         measurer = GlyphMeasurer.new(font_name: style.font_name)
         ascender = measurer.ascender(font_size: style.font_size)
         x_origin = box.x
         y_top = box.y + box.height
 
+        heights = box.data[:line_heights] ||
+                  Array.new(lines.length, line_height)
+        offset = 0.0
         lines.each_with_index do |line, idx|
-          baseline_y = y_top - (idx * line_height) - ascender
-          line_x = x_origin + line.x_offset
-          render_line_runs(canvas, line, line_x, baseline_y, style)
+          # A math line's slot is taller than a text line; the
+          # reference draws the stacked expression at the BOTTOM of
+          # its slot (the text-level parens stay at the line top).
+          drop = heights[idx] - line_height
+          baseline_y = y_top - offset - ascender - drop
+          indent = idx.zero? ? 0 : hanging_indent
+          line_x = x_origin + indent + line.x_offset
+          render_line_runs(canvas, line, line_x, baseline_y, style,
+                           last_line: idx == lines.length - 1)
+          offset += heights[idx]
         end
       end
 
-      def render_line_runs(canvas, line, line_x, baseline_y, _paragraph_style)
-        justify = line.justified? ? line.justify_stretch : 0.0
+      def render_line_runs(canvas, line, line_x, baseline_y, _paragraph_style, last_line: false)
+        justify = line.justified? && !last_line ? line.justify_stretch : 0.0
         extra_offset = 0.0
         line.placed_runs.each do |pr|
           run = pr.run
-          x = line_x + pr.x_offset + extra_offset
+          run_x = line_x + pr.x_offset
           font_name = run.style.font_name
           ref = embedded_or_standard(font_name)
-          payload = encoded_or_text(font_name, run.text)
           y, size = baseline_position_for(run, baseline_y)
-          opts = { at: [x, y], font: ref, size: size }
-          if run.style.character_spacing && !run.style.character_spacing.zero?
-            opts[:char_spacing] = run.style.character_spacing
-          end
-          if run.style.word_spacing && !run.style.word_spacing.zero?
-            opts[:word_spacing] = run.style.word_spacing
+          cursor = 0.0
+          run_start = nil
+          text_chunks(run.text, justify).each_with_index do |chunk, ci|
+            x = run_x + extra_offset + cursor
+            run_start ||= x
+            payload = encoded_or_text(font_name, chunk)
+            opts = { at: [x, y], font: ref, size: size }
+            if run.style.character_spacing && !run.style.character_spacing.zero?
+              opts[:char_spacing] = run.style.character_spacing
+            end
+            if run.style.word_spacing && !run.style.word_spacing.zero?
+              opts[:word_spacing] = run.style.word_spacing
+            end
+            record_link_if_needed(run, x, y, size) if cursor.zero?
+            canvas.text(payload, **opts)
+            # Advance by the width the BREAKER computed — the
+            # renderer never measures, so layout and emission
+            # cannot drift (the word-overlap bug class).
+            cursor += pr.chunk_widths[ci].to_f
+            # Justify must SHRINK as well as stretch: a compressed
+            # line (ratio > -1) relies on negative space adjustment —
+            # skipping it draws the line at natural width, past the
+            # measure.
+            extra_offset += (chunk.count(' ') * justify) unless justify.zero?
           end
-          record_link_if_needed(run, x, y, opts[:size])
-          canvas.text(payload, **opts)
-          extra_offset += (run.text.count(' ') * justify) if justify.positive?
+          draw_underline(canvas, run, run_start, y, size, cursor) if run.style.underline
         end
       end
 
+      # PDF word spacing (Tw) does not apply to two-byte CID-encoded
+      # embedded fonts, so justification cannot rely on it. Instead a
+      # justified line is drawn as one positioned text operation per
+      # word — FOP's model — with each word's x carrying the stretch
+      # accumulated so far. The separating space stays attached to
+      # the preceding word so text extraction still sees word gaps.
+      def text_chunks(text, justify)
+        return [text] if justify.zero?
+
+        text.split(/(?<=\s)(?=\S)/)
+      end
+
+      # Draws a thin horizontal rule below a run's baseline when the
+      # style's `underline` flag is set. Matches FOP/HTML convention:
+      # the rule sits ~1pt below baseline, thickness ~5% of font size.
+      def draw_underline(canvas, _run, x, baseline_y, size, width)
+        weight = [size * 0.05, 0.5].max
+        underline_y = baseline_y - (size * 0.18)
+        canvas.line(x, underline_y, x + width, underline_y)
+        canvas.line_width = weight
+        canvas.stroke
+      rescue StandardError => e
+        Arrolio::Logger.warn "draw_underline failed: #{e.message[0, 60]}"
+      end
+
       # Returns [y, font_size] for a run, applying baseline shift and
       # font size scaling for subscript/superscript runs.
       # Subscript: shift down 0.2em, scale 0.7x.

data/lib/arrolio/style/definition.rb

@@ -9,7 +9,8 @@ module Arrolio
                   :padding_top, :padding_right, :padding_bottom, :padding_left,
                   :character_spacing, :word_spacing, :line_break,
                   :keep_together, :page_break_before, :page_break_after,
-                  :keep_with_next, :widows, :orphans, :parent
+                  :keep_with_next, :widows, :orphans, :parent,
+                  :underline, :text_transform
 
       DEFAULTS = {
         font_name: 'Helvetica', font_size: 12.0,
@@ -20,7 +21,8 @@ module Arrolio
         character_spacing: 0.0, word_spacing: 0.0,
         line_break: :greedy,
         keep_together: false, page_break_before: false, page_break_after: false,
-        keep_with_next: false, widows: 2, orphans: 2, parent: nil
+        keep_with_next: false, widows: 1, orphans: 1, parent: nil,
+        underline: false, text_transform: nil
       }.freeze
 
       def initialize(**opts)
@@ -50,6 +52,8 @@ module Arrolio
         @widows = merged.fetch(:widows).to_i
         @orphans = merged.fetch(:orphans).to_i
         @parent = merged.fetch(:parent)
+        @underline = truthy?(merged.fetch(:underline))
+        @text_transform = merged.fetch(:text_transform)
         freeze
       end
 
@@ -80,7 +84,7 @@ module Arrolio
           line_break: @line_break, keep_together: @keep_together,
           page_break_before: @page_break_before, page_break_after: @page_break_after,
           keep_with_next: @keep_with_next, widows: @widows, orphans: @orphans,
-          parent: @parent
+          parent: @parent, underline: @underline, text_transform: @text_transform
         }
       end
 

data/lib/arrolio/style/registry.rb

@@ -9,18 +9,21 @@ module Arrolio
 
       def initialize(overrides = {})
         @overrides = {}
+        @resolution_cache = {}
         overrides.each { |name, attrs| register(name, **attrs) }
         freeze
       end
 
       def register(name, **opts)
         @overrides[name.to_sym] = opts.transform_keys(&:to_sym)
+        @resolution_cache.clear
         name.to_sym
       end
 
       def resolve(name, fallback: Definition.new)
         key = name.to_sym
         return fallback unless @overrides.key?(key)
+        return @resolution_cache[key] if @resolution_cache.key?(key)
 
         chain = []
         cursor = key
@@ -32,7 +35,9 @@ module Arrolio
         end
         merged = chain.reverse_each.reduce({}) { |acc, h| acc.merge(h) }
         merged.delete(:parent)
-        Definition.new(**merged)
+        result = Definition.new(**merged)
+        @resolution_cache[key] = result
+        result
       end
 
       def names = @overrides.keys

data/lib/arrolio/table/auto_layout.rb

@@ -15,12 +15,13 @@ module Arrolio
       MIN_COLUMN_WIDTH = 20.0 # points — prevents columns from collapsing
       CELL_PADDING = 8.0      # points — left + right padding per cell
 
-      attr_reader :table, :available_width, :measurer
+      attr_reader :table, :available_width, :measurer, :grid
 
-      def initialize(table, available_width:, measurer: nil)
+      def initialize(table, available_width:, measurer: nil, grid: nil)
         @table = table
         @available_width = available_width.to_f
         @measurer = measurer || default_measurer
+        @grid = grid || Grid.build(table)
       end
 
       # Returns an Array of Float widths (one per column), summing
@@ -35,18 +36,26 @@ module Arrolio
       private
 
       def column_count
-        @table.column_count
+        [@table.column_count, @grid.column_count].max
       end
 
-      # Natural width of each column = max cell natural width across rows.
+      # Natural width of each column = max cell natural width across
+      # rows. Placements come from the occupancy grid, so cells land
+      # in the columns they actually occupy (rowspan cells in later
+      # rows no longer shift into the wrong slot). Cells with colspan
+      # distribute their natural width equally across the spanned
+      # slots so a wide header doesn't accidentally collapse.
       def natural_widths
         widths = Array.new(column_count, MIN_COLUMN_WIDTH)
-        @table.rows.each do |row|
-          row.cells.each_with_index do |cell, ci|
-            next if ci >= widths.length
+        @grid.placements.each do |placement|
+          span = [placement.colspan, 1].max
+          span = [span, column_count - placement.column_index].min
+          share = cell_natural_width(placement.cell) / span.to_f
+          span.times do |offset|
+            idx = placement.column_index + offset
+            break if idx >= widths.length
 
-            w = cell_natural_width(cell)
-            widths[ci] = w if w > widths[ci]
+            widths[idx] = [widths[idx], share].max
           end
         end
         widths
@@ -84,7 +93,7 @@ module Arrolio
       end
 
       def default_measurer
-        GlyphMeasurer.new(font_name: 'Times New Roman')
+        GlyphMeasurer.new(font_name: 'Times-Roman')
       end
     end
   end

data/lib/arrolio/table/grid.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Table
+    # Occupancy grid over a Content::Table, honoring colspan and
+    # rowspan. Answers the two questions every table consumer asks:
+    # which column does each cell actually occupy, and which rows are
+    # welded together by a vertical span (and therefore cannot be
+    # split apart across pages).
+    #
+    # Built once per layout pass and shared by AutoLayout (natural
+    # widths), TableFlowable (row heights, cell placement), and
+    # splitting (atomic row groups).
+    class Grid
+      # One cell's position in the grid. +row_index+ is the row the
+      # cell STARTS in — a rowspan cell is placed and drawn only
+      # there, with a height covering every spanned row.
+      Placement = Struct.new(:cell, :row_index, :column_index,
+                             :colspan, :rowspan, keyword_init: true) do
+        def spans_multiple_rows?
+          rowspan > 1
+        end
+
+        def spans_multiple_columns?
+          colspan > 1
+        end
+      end
+
+      attr_reader :placements, :row_count, :column_count
+
+      def self.build(table)
+        rows = table.rows
+        occupied = {}
+        placements = []
+        rows.each_with_index do |row, row_index|
+          column_index = 0
+          row.cells.each do |cell|
+            column_index += 1 while occupied[[row_index, column_index]]
+            colspan = cell.colspan.to_i
+            rowspan = cell.rowspan.to_i
+            placements << Placement.new(
+              cell: cell, row_index: row_index, column_index: column_index,
+              colspan: colspan, rowspan: rowspan
+            )
+            rowspan.times do |r|
+              colspan.times do |c|
+                occupied[[row_index + r, column_index + c]] = true
+              end
+            end
+            column_index += colspan
+          end
+        end
+        new(placements: placements, row_count: rows.length,
+            column_count: occupied.keys.map(&:last).max.to_i + 1)
+      end
+
+      def initialize(placements:, row_count:, column_count:)
+        @placements = placements.freeze
+        @row_count = row_count
+        @column_count = column_count
+        @by_row = Array.new(row_count) { [] }
+        @placements.each { |p| @by_row[p.row_index] << p }
+        @by_row.each(&:freeze)
+        freeze
+      end
+
+      def placements_starting_in(row_index)
+        @by_row[row_index] || []
+      end
+
+      # Rows welded together by rowspan cells, as arrays of row
+      # indexes in ascending order. Rows not covered by any span come
+      # back as single-element groups. Splitting the table across
+      # pages must happen between groups, never inside one.
+      def atomic_row_groups
+        groups = []
+        group = []
+        welded = welded_rows
+        (0...@row_count).each do |row_index|
+          group << row_index
+          next if welded.include?(row_index + 1)
+
+          groups << group.freeze
+          group = []
+        end
+        groups << group.freeze unless group.empty?
+        groups.freeze
+      end
+
+      private
+
+      # Row indexes > 0 whose content starts in the row above (i.e.
+      # a rowspan from above covers their first column slot).
+      def welded_rows
+        covered = {}
+        @placements.each do |p|
+          next unless p.spans_multiple_rows?
+
+          (1...p.rowspan).each { |r| covered[p.row_index + r] = true }
+        end
+        covered
+      end
+    end
+  end
+end

data/lib/arrolio/table.rb

@@ -5,5 +5,6 @@ module Arrolio
   # - AutoLayout — content-based column width computation.
   module Table
     autoload :AutoLayout, 'arrolio/table/auto_layout'
+    autoload :Grid, 'arrolio/table/grid'
   end
 end