arrolio 0.1.0 → 0.1.2

data/lib/arrolio/flowables/table_flowable.rb

@@ -2,43 +2,84 @@
 
 module Arrolio
   module Flowables
-    # Real table layout: equal-width columns by default (TODO 04
-    # adds auto/fixed), borders per cell, header row repeat.
+    # Real table layout driven by Table::Grid: colspan and rowspan
+    # aware cell placement, per-flavor row minimum height, vertical
+    # alignment inside cells, borders per cell, header row repeat,
+    # continuation caption on split, and table footnotes rendered
+    # below the last row.
     class TableFlowable < Flowable
-      attr_reader :table, :column_widths
+      attr_reader :table, :continued, :caption_text, :caption_runs, :grid,
+                  :min_row_height, :cell_padding, :footnote_font_size
 
-      def initialize(table, style: Style::Definition.new)
+      CAPTION_DASH = Regexp.new("[\u00A0\u2009\u0020]\u2014").freeze
+      FOOTNOTE_SPACING = 10.0
+
+      def initialize(table, style: Style::Definition.new,
+                     continued: false, caption_text: nil, caption_runs: nil,
+                     caption_style: nil, min_row_height: 0.0,
+                     cell_padding: 2.0, footnote_font_size: nil)
         super(style: style)
         @table = table
+        @continued = continued
+        @caption_runs = caption_runs
+        @caption_text = caption_text || caption_runs&.map(&:text)&.join
+        @caption_style = caption_style
+        @min_row_height = min_row_height.to_f
+        @cell_padding = cell_padding.to_f
+        @footnote_font_size = footnote_font_size ||
+                              (@style.font_size * 0.9).round(1)
+        @grid = Table::Grid.build(table)
       end
 
       def height(width, _context = nil)
         cols = column_widths_for(width)
-        total = 0.0
-        rows.each do |row|
-          total += row_height(row, cols)
-        end
-        total
+        caption_height(width) + row_heights(cols).sum +
+          footnote_block_height(width, cols)
+      end
+
+      # What must stay on the same page as a preceding
+      # keep-with-next flowable: the caption, the (repeated) header
+      # rows, and the first welded body group — a caption or header
+      # alone at a page bottom is an orphan.
+      def min_keep_height(width, _context = nil)
+        cols = column_widths_for(width)
+        heights = row_heights(cols)
+        header_rows = @table.header.length
+        first_body_group = grid.atomic_row_groups.find { |g| g.first >= header_rows }
+        keep_rows = first_body_group ? first_body_group.last + 1 : header_rows
+        caption_height(width) + heights[0...[keep_rows, heights.length].min].sum
       end
 
-      def emit(x, y, width, context = nil)
+      def emit(x, y, width, _context = nil)
         cols = column_widths_for(width)
+        heights = row_heights(cols)
         boxes = []
         consumed = 0.0
         cursor = y
-        header_rows, body_rows = partition_rows
-
-        (header_rows + body_rows).each do |row|
-          rh = row_height(row, cols)
-          cursor -= rh
-          consumed += rh
-          cell_x = x.to_f
-          row.cells.each_with_index do |cell, ci|
-            cw = cols[ci] || (width / [row.cells.length, 1].max)
-            render_cell(cell, cell_x, cursor, cw, rh, boxes, context)
-            cell_x += cw
-          end
+
+        # The caption travels with the table: the head part draws the
+        # full caption, continuations draw the short form. This keeps
+        # the caption from being orphaned at the bottom of a page.
+        if @caption_text
+          caption_h = emit_caption(x, cursor, width, boxes)
+          cursor -= caption_h
+          consumed += caption_h
+        end
+
+        row_bottoms = row_bottom_positions(cursor, heights)
+        grid.placements.each do |placement|
+          cell_y = row_bottoms[placement.row_index + placement.rowspan - 1]
+          cell_h = heights[placement.row_index, placement.rowspan].sum
+          cell_w = column_span_width(cols, placement)
+          cell_x = x + cols[0, placement.column_index].sum
+          render_cell(placement.cell, cell_x, cell_y, cell_w, cell_h, boxes,
+                      header: header_row?(placement.row_index))
         end
+        consumed += heights.sum
+        cursor = row_bottoms[-1] || cursor
+
+        fn_h = emit_footnotes(x, cursor, width, cols, boxes)
+        consumed += fn_h
 
         [boxes, consumed]
       end
@@ -47,33 +88,48 @@ module Arrolio
         true
       end
 
+      # Splits at welded-group boundaries only — a rowspan cell is
+      # never cut by a page break. When the first group already
+      # exceeds the remaining space, no head is returned and the
+      # engine moves the whole table to the next page. Footnotes
+      # travel with the part carrying the last body row.
       def do_split(width, remaining_height, _context = nil)
         cols = column_widths_for(width)
-        head_rows = []
-        tail_rows = []
-        used = 0.0
+        heights = row_heights(cols)
         header, body = partition_rows
+        header_count = header.length
 
-        body.each do |row|
-          rh = row_height(row, cols)
-          if used + rh <= remaining_height || head_rows.empty?
-            head_rows << row
-            used += rh
+        head_groups = []
+        tail_groups = []
+        # The head part also carries the caption and the repeated
+        # header rows — they consume the same budget as body rows.
+        used = caption_height(width) + heights[0, header_count].sum
+        body_row_groups.each do |group|
+          group_h = heights[group.first, group.length].sum
+          if used + group_h <= remaining_height
+            head_groups << group
+            used += group_h
           else
-            tail_rows << row
+            tail_groups << group
           end
         end
 
-        if head_rows.any?
-          head_table = rebuild_table(header, head_rows)
-          head = self.class.new(head_table, style: @style)
-        else
-          head = nil
+        head_rows = head_groups.flat_map { |g| body[g.first - header_count, g.length] }
+        tail_rows = tail_groups.flat_map { |g| body[g.first - header_count, g.length] }
+
+        return [nil, whole_table_copy] if head_rows.empty?
+        if tail_rows.empty?
+          return [build_split(header, head_rows, @continued,
+                              footnotes: @table.footnotes), nil]
         end
 
-        tail_table = rebuild_table(header, tail_rows)
-        tail = self.class.new(tail_table, style: @style)
-        [head, tail]
+        [build_split(header, head_rows, @continued, footnotes: []),
+         build_split(header, tail_rows, true, footnotes: @table.footnotes)]
+      end
+
+      def whole_table_copy
+        build_split(@table.header, @table.body, @continued,
+                    footnotes: @table.footnotes)
       end
 
       private
@@ -86,61 +142,237 @@ module Arrolio
         [@table.header, @table.body]
       end
 
+      def header_row?(row_index)
+        row_index < @table.header.length
+      end
+
+      # Body row groups in ABSOLUTE row indexes, welded together by
+      # rowspan spans so a split never cuts through a vertical span.
+      # Groups that reach into the header are clipped to the body
+      # range — the span still welds the body rows it covers, and the
+      # header repeats on every continuation part anyway.
+      def body_row_groups
+        header_count = @table.header.length
+        total = rows.length
+        return [] if header_count >= total
+
+        grid.atomic_row_groups
+            .map { |group| group.select { |r| r >= header_count } }
+            .reject(&:empty?)
+            .map(&:freeze)
+      end
+
+      def build_split(header, body_rows, continued, footnotes:)
+        table = Content::Table.new(
+          header: header, body: body_rows,
+          column_widths: @table.column_widths,
+          style_id: @table.style_id, id: @table.id,
+          caption: @table.caption,
+          footnotes: footnotes || []
+        )
+        self.class.new(table, style: @style, continued: continued,
+                              caption_text: @caption_text,
+                              caption_style: @caption_style,
+                              min_row_height: @min_row_height,
+                              cell_padding: @cell_padding,
+                              footnote_font_size: @footnote_font_size)
+      end
+
       def column_widths_for(width)
-        return Array.new(@table.column_count, width.to_f / [@table.column_count, 1].max) if @table.column_count.zero?
+        return Array.new(grid.column_count, width.to_f / [grid.column_count, 1].max) if grid.column_count.zero?
+
+        @cached_widths ||= Table::AutoLayout.new(@table,
+                                                 available_width: width,
+                                                 grid: grid).compute
+      end
+
+      def column_span_width(cols, placement)
+        cols[placement.column_index, placement.colspan].sum ||
+          (50.0 * placement.colspan)
+      end
 
-        @cached_widths ||= Table::AutoLayout.new(@table, available_width: width).compute
+      def inner_width(cols, placement)
+        column_span_width(cols, placement) - (@cell_padding * 2)
       end
 
-      def row_height(row, cols)
-        max_h = 0.0
-        row.cells.each_with_index do |cell, ci|
-          cw = cols[ci] || 50.0
-          content_h = cell.content.sum do |node|
-            paragraph_height(node, cw)
+      # Row heights: single-row cells drive their row's height; a
+      # multi-row cell that does not fit in the spanned rows pushes
+      # the deficit into every spanned row equally. Every row obeys
+      # the flavor's minimum height and its own min-height attribute.
+      def row_heights(cols)
+        heights = Array.new(rows.length, 0.0)
+        grid.placements.each do |placement|
+          next if placement.spans_multiple_rows?
+
+          content = cell_content_height(placement.cell,
+                                        inner_width(cols, placement),
+                                        header: header_row?(placement.row_index))
+          heights[placement.row_index] = [heights[placement.row_index], content].max
+        end
+
+        heights.each_with_index do |h, row_index|
+          floors = [@min_row_height, rows[row_index].min_height]
+          heights[row_index] = [h + (@cell_padding * 2), *floors].max
+        end
+
+        grid.placements.each do |placement|
+          next unless placement.spans_multiple_rows?
+
+          spanned = heights[placement.row_index, placement.rowspan]
+          content = cell_content_height(placement.cell,
+                                        inner_width(cols, placement),
+                                        header: header_row?(placement.row_index)) +
+                    (@cell_padding * 2)
+          deficit = content - spanned.sum
+          next unless deficit.positive?
+
+          share = deficit / placement.rowspan
+          placement.rowspan.times do |r|
+            heights[placement.row_index + r] += share
           end
-          max_h = [max_h, content_h].max
         end
-        max_h + 4.0
+        heights
       end
 
-      def paragraph_height(paragraph, width)
-        return 0.0 unless paragraph.is_a?(Content::Paragraph)
+      def row_bottom_positions(top, heights)
+        bottoms = []
+        cursor = top
+        heights.each do |h|
+          cursor -= h
+          bottoms << cursor
+        end
+        bottoms
+      end
+
+      def cell_content_height(cell, width, header: false)
+        style = cell_style(header: header)
+        runs = cell_paragraph_runs(cell, style)
+        return 0.0 if runs.empty?
 
-        style = cell_style(paragraph)
-        runs = paragraph.inline_runs.map { |r| InlineRun.new(r.text, style: style) }
         TextFlowable.new(runs, style: style).height(width)
       end
 
-      def render_cell(cell, x, y, w, h, boxes, _context)
-        style = cell_style(cell)
+      def cell_paragraph_runs(cell, style)
         runs = []
         cell.content.each do |node|
-          if node.is_a?(Content::Paragraph)
-            runs.concat(node.inline_runs.map { |r| InlineRun.new(r.text, style: style) })
-          end
+          next unless node.is_a?(Content::Paragraph)
+
+          runs.concat(node.inline_runs.map { |r| InlineRun.new(r.text, style: style) })
         end
-        if runs.any?
+        runs
+      end
+
+      def render_cell(cell, x, y, w, h, boxes, header: false)
+        style = cell_style(header: header)
+        style = style.with(align: cell.align) if cell.align
+        runs = cell_paragraph_runs(cell, style)
+        unless runs.empty?
           tf = TextFlowable.new(runs, style: style)
-          tboxes, = tf.emit(x + 2, y + h - 2, w - 4, nil)
+          inner_w = w - (@cell_padding * 2)
+          content_h = tf.height(inner_w)
+          text_top = text_top_for(cell, y, h, content_h)
+          tboxes, = tf.emit(x + @cell_padding, text_top, inner_w, nil)
           boxes.concat(tboxes)
         end
-        # Cell border: rectangle around the full cell.
+        stroke = header ? 0.7 : 0.5
         boxes << Output::PlacedBox.rect(x: x, y: y, width: w, height: h,
-                                        stroke_width: 0.5, stroke_color: 'black')
+                                        stroke_width: stroke, stroke_color: 'black')
+      end
+
+      # Vertical placement of cell content. Default (and :top) hugs
+      # the cell's top padding; :middle and :bottom center or sink
+      # the content block within the cell.
+      def text_top_for(cell, cell_y, cell_h, content_h)
+        slack = [cell_h - content_h - (@cell_padding * 2), 0.0].max
+        lift = case cell.valign
+               when :middle then slack / 2.0
+               when :bottom then slack
+               else 0.0
+               end
+        cell_y + cell_h - @cell_padding - lift
       end
 
-      def rebuild_table(header, body)
-        Content::Table.new(header: header.map { |r| r.cells.map(&:text) },
-                           body: body.map { |r| r.cells.map(&:text) })
+      def footnote_block_height(width, _cols)
+        return 0.0 if @table.footnotes.empty?
+
+        FOOTNOTE_SPACING +
+          @table.footnotes.sum { |fn| footnote_flowable(fn).height(width) }
+      end
+
+      def emit_footnotes(x, y, width, _cols, boxes)
+        return 0.0 if @table.footnotes.empty?
+
+        cursor = y - FOOTNOTE_SPACING
+        consumed = FOOTNOTE_SPACING
+        @table.footnotes.each do |fn|
+          tf = footnote_flowable(fn)
+          tboxes, = tf.emit(x, cursor, width, nil)
+          boxes.concat(tboxes)
+          h = tf.height(width)
+          cursor -= h
+          consumed += h
+        end
+        consumed
       end
 
-      # Use the parent table's style (which inherits from body →
-      # Times New Roman) rather than hard-coding Times-Roman.
-      # Falls back to Times-Roman only if the table style has no
-      # font_name (shouldn't happen in practice).
-      def cell_style(_cell_or_para)
-        @style.font_name ? @style : Style::Definition.new(font_name: 'Times-Roman', font_size: 10)
+      def footnote_flowable(fn)
+        style = @style.with(font_size: @footnote_font_size, align: :left,
+                            margin_top: 0.0, margin_bottom: 2.0)
+        runs = [InlineRun.new("#{fn.marker} ", style: style)]
+        fn.body.each do |node|
+          next unless node.is_a?(Content::Paragraph)
+
+          runs.concat(node.inline_runs.map { |r| InlineRun.new(r.text, style: style) })
+        end
+        TextFlowable.new(runs, style: style)
+      end
+
+      def emit_caption(x, y, width, boxes)
+        runs = if @continued
+                 text = "#{short_caption_text} (continued)"
+                 [InlineRun.new(text, style: caption_style)]
+               elsif @caption_runs
+                 @caption_runs
+               else
+                 [InlineRun.new(@caption_text, style: caption_style)]
+               end
+        tf = TextFlowable.new(runs, style: caption_style)
+        line_h = tf.height(width)
+        tboxes, = tf.emit(x, y, width, nil)
+        boxes.concat(tboxes)
+        line_h
+      end
+
+      def caption_style
+        @caption_style || @style.with(align: :left)
+      end
+
+      def caption_height(width)
+        return 0.0 if @caption_text.nil?
+
+        caption_flowable(width).height(width)
+      end
+
+      def caption_flowable(_width)
+        runs = @caption_runs || [InlineRun.new(@caption_text, style: caption_style)]
+        TextFlowable.new(runs, style: caption_style)
+      end
+
+      def short_caption_text
+        parts = @caption_text.split(CAPTION_DASH)
+        return @caption_text if parts.length < 2
+
+        parts.first.to_s
+      end
+
+      # Resolve a cell's effective style. Header cells get the bold
+      # variant of the table style. Body cells fall back to the
+      # table style unless the cell declares its own style_id.
+      def cell_style(header: false)
+        base = @style.font_name ? @style : Style::Definition.new(font_name: 'Times-Roman', font_size: 10)
+        return base unless header
+
+        base.with(font_name: "#{base.font_name} Bold")
       end
     end
   end

data/lib/arrolio/flowables/text_flowable.rb

@@ -7,38 +7,72 @@ module Arrolio
     # :knuth_plass). Both strategies produce TextLayout::Line[]
     # with the same shape, so the rest of the pipeline is agnostic.
     class TextFlowable < Flowable
-      attr_reader :runs, :measurer
+      attr_reader :runs, :measurer, :hanging_indent
 
-      def initialize(runs, style: Style::Definition.new, measurer: nil)
+      def initialize(runs, style: Style::Definition.new, measurer: nil,
+                     hanging_indent: 0.0)
         super(style: style)
         @runs = Array(runs)
         @measurer = measurer || GlyphMeasurer.new(font_name: style.font_name)
+        @hanging_indent = hanging_indent.to_f
       end
 
+      # Inline math with relational operators lays out stacked in
+      # the reference (JEuclid gives the formula box roughly two
+      # text lines of vertical extent); simple sub/superscripts stay
+      # compact. The operators only ever come from math content.
+      MATH_OPERATOR = /[\u2264\u2265\u00d7\u00f7\u00b1\u2212\u2260]|\+\d/
+      MATH_LINE_FACTOR = 1.9
+
       def height(width, _context = nil)
-        laid_out(width).length * line_height
+        effective_width = width - @hanging_indent
+        laid = laid_out(effective_width)
+        text_height = (laid.length * line_height) +
+                      (math_line_count(laid) * line_height * (MATH_LINE_FACTOR - 1.0))
+        text_height + space_before + space_after
       end
 
       def emit(x, y, width, _context = nil)
-        lines = laid_out(width)
-        return [[], 0.0] if lines.empty?
-
+        effective_width = width - @hanging_indent
+        lines = laid_out(effective_width)
+        text_height = (lines.length * line_height) +
+                      (math_line_count(lines) * line_height * (MATH_LINE_FACTOR - 1.0))
+        total = text_height + space_before + space_after
+        return [[], total] if lines.empty?
+
+        text_y = y - space_before
+        heights = lines.map do |line|
+          math = line.placed_runs.any? { |pr| pr.run.text.match?(MATH_OPERATOR) }
+          line_height * (math ? MATH_LINE_FACTOR : 1.0)
+        end
         box = Output::PlacedBox.text(
-          x: x, y: y - (line_height * lines.length),
-          width: width, height: line_height * lines.length,
-          lines: lines, line_height: line_height, style: @style
+          x: x, y: text_y - text_height,
+          width: width, height: text_height,
+          lines: lines, line_height: line_height, style: @style,
+          hanging_indent: @hanging_indent, line_heights: heights
         )
-        [[box], box.height]
+        [[box], total]
       end
 
       def splittable?
         true
       end
 
+      # Widows for keep-with-next predecessors: how many lines must
+      # follow when the paragraph starts after a kept block.
+      def min_keep_height(_width, _context = nil)
+        space_before + ([widows_count, 1].max * line_height)
+      end
+
+      def widows_count
+        @style.widows ? @style.widows.to_i : 1
+      end
+
       def do_split(width, remaining_height, _context = nil)
         lines = laid_out(width)
         line_h = line_height
-        head_count = (remaining_height.to_f / line_h).floor
+        available = remaining_height - space_before
+        head_count = (available.to_f / line_h).floor
         head_count = [head_count, lines.length].min
         head_count = 1 if head_count < 1 && lines.any?
 
@@ -83,13 +117,35 @@ module Arrolio
                               line_spacing: @style.line_spacing)
       end
 
+      def math_line_count(lines)
+        lines.count do |line|
+          line.placed_runs.any? { |pr| pr.run.text.match?(MATH_OPERATOR) }
+        end
+      end
+
+      # Rebuilds a run list from laid-out lines. A line break
+      # consumes the inter-word glue, and placed runs don't carry it,
+      # so a separator is re-inserted at each line boundary —
+      # otherwise re-layout glues the boundary words together
+      # ("…increasing and" + "decreasing loads."). Hyphen breaks
+      # already join their words; they must not gain a space.
       def collect_runs(lines)
         runs = []
         lines.each do |line|
+          first = line.placed_runs.first&.run
+          runs << InlineRun.new(' ', style: first.style) if separator_needed?(runs.last, first)
           line.placed_runs.each { |pr| runs << pr.run }
         end
         runs
       end
+
+      def separator_needed?(last_run, first_run)
+        return false if last_run.nil? || first_run.nil?
+        return false if last_run.text.end_with?('-')
+        return false if last_run.text.match?(/\s\z/) || first_run.text.match?(/\A\s/)
+
+        true
+      end
     end
   end
 end

data/lib/arrolio/flowables/toc_line_flowable.rb

@@ -2,8 +2,18 @@
 
 module Arrolio
   module Flowables
-    # One ToC line: title + dot-leader + page number. One line tall.
+    # One ToC line: title + dot leader + page number, all on one
+    # line. The title is left-aligned, the page number is
+    # right-aligned, and the gap between is filled with dot leaders.
+    #
+    # Emits three PlacedBox values:
+    #   1. text box for the title at x=0
+    #   2. text box for the page number, right-aligned at x=width
+    #   3. (optional) line box for the dot leader between them
     class TocLineFlowable < Flowable
+      LEADER_CHAR = '.'
+      LEADER_GAP = 4.0 # pt between title/page and the leader run
+
       attr_reader :title, :page_number, :level
 
       def initialize(title, page_number, level: 1, style: Style::Definition.new)
@@ -20,15 +30,68 @@ module Arrolio
       end
 
       def emit(x, y, width, context = nil)
-        page_str = @page_number.to_s
         measurer = GlyphMeasurer.new(font_name: @style.font_name)
+        line_h = height(width, context)
+        # Apply the style's margin_left as an indent (ToC sub-entries
+        # use this to nest visually under their parent entry).
+        indent = @style.margin_left.to_f
+        x += indent
+        width -= indent
+        page_str = @page_number.to_s
         title_w = measurer.width_of_string(@title, font_size: @style.font_size)
         page_w = measurer.width_of_string(page_str, font_size: @style.font_size)
-        gap = width - title_w - page_w - 10
-        dots = gap.positive? ? ('.' * (gap / measurer.space_width(font_size: @style.font_size)).floor) : ' '
-        text = "#{@title} #{dots} #{page_str}"
-        tf = TextFlowable.new([InlineRun.new(text, style: @style)], style: @style)
-        tf.emit(x, y, width, context)
+        page_x = x + width - page_w
+        leader_w = page_x - (x + title_w + LEADER_GAP)
+
+        boxes = []
+        boxes.concat(emit_title(x, y, width, line_h, context))
+        boxes.concat(emit_page_number(page_x, y, page_w, line_h, context))
+        boxes.concat(emit_leader(x + title_w + LEADER_GAP, y, leader_w, line_h, measurer)) if leader_w.positive?
+        [boxes, line_h]
+      end
+
+      private
+
+      def emit_title(x, y, _width, line_h, context)
+        tf = TextFlowable.new([InlineRun.new(@title, style: @style)],
+                              style: @style.with(align: :left))
+        boxes, _consumed = tf.emit(x, y, x_origin_width(@title, @style), context)
+        position_boxes_at(boxes, x, y, line_h)
+      end
+
+      def emit_page_number(page_x, y, page_w, _line_h, context)
+        tf = TextFlowable.new([InlineRun.new(@page_number.to_s, style: @style)],
+                              style: @style.with(align: :left))
+        boxes, _consumed = tf.emit(page_x, y, page_w, context)
+        boxes
+      end
+
+      def emit_leader(start_x, y, leader_w, _line_h, measurer)
+        dot_w = measurer.width_of_string(LEADER_CHAR, font_size: @style.font_size)
+        count = (leader_w / dot_w).floor
+        return [] if count <= 0
+
+        leader_text = LEADER_CHAR * count
+        tf = TextFlowable.new([InlineRun.new(leader_text, style: @style)],
+                              style: @style.with(align: :left))
+        boxes, _consumed = tf.emit(start_x, y, leader_w, nil)
+        boxes
+      end
+
+      # TextFlowable.width is the natural width of the text; for the
+      # title box we want exactly the title width so the leader
+      # starts right after.
+      def x_origin_width(text, style)
+        GlyphMeasurer.new(font_name: style.font_name)
+                     .width_of_string(text, font_size: style.font_size)
+      end
+
+      # The TextFlowable emits a single box for a single-line
+      # paragraph; trust that and return as-is. (No-op retained for
+      # symmetry with future flowables that may need offset
+      # adjustment.)
+      def position_boxes_at(boxes, _x, _y, _line_h)
+        boxes
       end
     end
   end

data/lib/arrolio/flowables.rb

@@ -10,10 +10,14 @@ module Arrolio
     autoload :PageSequenceStart, 'arrolio/flowables/page_sequence_start'
     autoload :ListFlowable, 'arrolio/flowables/list_flowable'
     autoload :NoteFlowable, 'arrolio/flowables/note_flowable'
+    autoload :FigureFlowable, 'arrolio/flowables/figure_flowable'
+    autoload :GroupFlowable, 'arrolio/flowables/group_flowable'
     autoload :ImageFlowable, 'arrolio/flowables/image_flowable'
     autoload :TocLineFlowable, 'arrolio/flowables/toc_line_flowable'
     autoload :TwoColumnBlock, 'arrolio/flowables/two_column_block'
     autoload :TableFlowable, 'arrolio/flowables/table_flowable'
     autoload :FootnoteMarkerFlowable, 'arrolio/flowables/footnote_marker_flowable'
+    autoload :PositionedBlock, 'arrolio/flowables/positioned_block'
+    autoload :RotatedText, 'arrolio/flowables/rotated_text'
   end
 end