arrolio 0.1.0 → 0.1.2

data/lib/arrolio/config_driven_pipeline.rb

@@ -55,7 +55,7 @@ module Arrolio
         io: io,
         logo_path: @logo_path,
         metadata: document_metadata,
-        font_paths: @layout_spec.font_paths,
+        font_paths: resolved_font_paths_for_renderer,
         context: engine.context,
         layout_spec: @layout_spec
       )
@@ -90,6 +90,50 @@ module Arrolio
 
     def register_fonts
       FontMetrics::Registry.register_ttf_all(@layout_spec.font_paths, strict: @strict)
+      resolve_fonts_via_fontist
+    end
+
+    def resolved_font_paths_for_renderer
+      merged = @layout_spec.font_paths.dup
+      scanner = ::Arrolio::FontScanner.new
+      collect_referenced_font_names.each do |name|
+        next if merged.key?(name)
+
+        path = scanner.resolve(name)
+        merged[name] = path if path
+      end
+      merged
+    end
+
+    def resolve_fonts_via_fontist
+      scanner = ::Arrolio::FontScanner.new
+      referenced = collect_referenced_font_names
+      referenced.each do |name|
+        next if FontMetrics::Registry.ttf_paths.key?(name)
+
+        path = scanner.resolve(name)
+        FontMetrics::Registry.register_ttf(name, path) if path
+      end
+    end
+
+    def collect_referenced_font_names
+      names = []
+      @layout_spec.styles.names.each do |style_name|
+        style = @layout_spec.resolve_style(style_name)
+        names << style.font_name if style.font_name && !style.font_name.empty?
+      end
+      names.uniq
+    end
+
+    def find_font_path(font_name)
+      result = Fontist::Font.find(font_name)
+      return nil unless result
+
+      font = result.is_a?(Array) ? result.first : result
+      path = font.is_a?(String) ? font : font.path
+      path && File.exist?(path) ? path : nil
+    rescue StandardError
+      nil
     end
 
     def populate_toc(pages, context)

data/lib/arrolio/content/document.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'arrolio/error'
 
 module Arrolio
   module Content
     class Document
       attr_reader :metadata, :sections, :preface, :bibliography, :cover,
-                  :style_id, :footnotes
+                  :style_id, :footnotes, :title_block
 
       def self.build(metadata: {}, **opts, &block)
         Builder.build(metadata: metadata, **opts, &block)
       end
 
       def initialize(metadata: {}, sections: [], preface: [], bibliography: [],
-                     cover: nil, style_id: :document, footnotes: [])
+                     cover: nil, style_id: :document, footnotes: [],
+                     title_block: nil)
         @metadata = metadata.to_h.freeze
         @sections = validate_sections(Array(sections), field: :sections).freeze
         @preface = validate_sections(Array(preface), field: :preface).freeze
@@ -21,6 +21,7 @@ module Arrolio
         @cover = cover
         @style_id = style_id.to_sym
         @footnotes = Array(footnotes).freeze
+        @title_block = title_block
         freeze
       end
 

data/lib/arrolio/content/section.rb

@@ -17,6 +17,9 @@ module Arrolio
         freeze
       end
 
+      # A title-less numbered clause is an inline-header clause
+      # (standoc inline-header): the number prefixes the first
+      # paragraph, it never gets its own heading line.
       def heading? = !@title.nil?
 
       def ==(other)

data/lib/arrolio/content/table.rb

@@ -3,15 +3,18 @@
 module Arrolio
   module Content
     class Table
-      attr_reader :header, :body, :column_widths, :style_id, :id
+      attr_reader :header, :body, :column_widths, :style_id, :id, :caption,
+                  :footnotes
 
       def initialize(header: [], body: [], column_widths: nil,
-                     style_id: :table, id: nil)
+                     style_id: :table, id: nil, caption: nil, footnotes: [])
         @header = header.map { |row| coerce_row(row) }.freeze
         @body = body.map { |row| coerce_row(row) }.freeze
         @column_widths = column_widths&.map(&:to_f)&.freeze
         @style_id = style_id.to_sym
         @id = id
+        @caption = caption
+        @footnotes = Array(footnotes).freeze
         freeze
       end
 
@@ -19,8 +22,11 @@ module Arrolio
         @header + @body
       end
 
+      # Colspan-aware column count. Rowspan can still hide columns
+      # (a row covered from above has fewer cells); Table::Grid is
+      # the authoritative count for layout.
       def column_count
-        rows.map { |r| r.cells.length }.max || 0
+        rows.map { |r| r.cells.sum(&:colspan) }.max || 0
       end
 
       def ==(other)
@@ -29,13 +35,14 @@ module Arrolio
           body == other.body &&
           column_widths == other.column_widths &&
           style_id == other.style_id &&
-          id == other.id
+          id == other.id &&
+          footnotes == other.footnotes
       end
 
       alias eql? ==
 
       def hash
-        [self.class, header, body, column_widths, style_id, id].hash
+        [self.class, header, body, column_widths, style_id, id, footnotes].hash
       end
 
       private
@@ -53,10 +60,11 @@ module Arrolio
     class Table::Row
       include Enumerable
 
-      attr_reader :cells
+      attr_reader :cells, :min_height
 
-      def initialize(cells)
+      def initialize(cells, min_height: 0.0)
         @cells = Array(cells).freeze
+        @min_height = min_height.to_f.freeze
         freeze
       end
 
@@ -69,26 +77,28 @@ module Arrolio
       end
 
       def ==(other)
-        other.is_a?(self.class) && cells == other.cells
+        other.is_a?(self.class) && cells == other.cells &&
+          min_height == other.min_height
       end
 
       alias eql? ==
 
       def hash
-        [self.class, cells].hash
+        [self.class, cells, min_height].hash
       end
     end
 
     class Table::Cell
-      attr_reader :content, :colspan, :rowspan, :style_id, :align
+      attr_reader :content, :colspan, :rowspan, :style_id, :align, :valign
 
       def initialize(content = [], colspan: 1, rowspan: 1,
-                     style_id: :table_cell, align: nil)
+                     style_id: :table_cell, align: nil, valign: nil)
         @content = Array(content).freeze
         @colspan = colspan.to_i
         @rowspan = rowspan.to_i
         @style_id = style_id.to_sym
-        @align = align
+        @align = align&.to_sym
+        @valign = valign&.to_sym
         freeze
       end
 
@@ -104,13 +114,14 @@ module Arrolio
           colspan == other.colspan &&
           rowspan == other.rowspan &&
           style_id == other.style_id &&
-          align == other.align
+          align == other.align &&
+          valign == other.valign
       end
 
       alias eql? ==
 
       def hash
-        [self.class, content, colspan, rowspan, style_id, align].hash
+        [self.class, content, colspan, rowspan, style_id, align, valign].hash
       end
     end
   end

data/lib/arrolio/embedded_block_extractor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Arrolio
+  # Extracts block-level elements (notes, examples) that are nested
+  # inside paragraph elements. In standoc presentation XML, notes can
+  # appear as children of <p>, not just as direct children of <clause>.
+  # Without extraction, these embedded blocks are silently dropped
+  # during inline run collection.
+  class EmbeddedBlockExtractor
+    SECTION_NAMES = ['clause', 'terms', 'definitions', 'annex', 'annex2'].freeze
+
+    def initialize(rules, converter_registry)
+      @rules = rules
+      @converter_registry = converter_registry
+    end
+
+    def extract(elem)
+      blocks = []
+      block_names = embedded_block_names
+      return blocks if block_names.empty?
+
+      elem.each_recursive do |descendant|
+        next unless block_names.include?(descendant.name)
+        next if inside_section?(descendant, elem)
+
+        mapping_entry = @rules['element_mapping'][descendant.name]
+        converter = @converter_registry[mapping_entry['content_type']]
+        next unless converter
+
+        result = yield(converter, descendant, mapping_entry)
+        blocks.concat(result)
+      end
+      blocks
+    end
+
+    private
+
+    def embedded_block_names
+      block_level = @rules['block_level_elements'] || []
+      mapping = @rules['element_mapping'] || {}
+      block_level.select { |name| mapping.key?(name) }
+    end
+
+    def inside_section?(descendant, root)
+      ancestor = descendant.parent
+      while ancestor && ancestor != root
+        return true if SECTION_NAMES.include?(ancestor.name)
+
+        ancestor = ancestor.parent
+      end
+      false
+    end
+  end
+end

data/lib/arrolio/engine/paged.rb

@@ -15,7 +15,8 @@ module Arrolio
       def layout
         @pages = []
         @page_count_opened = 0
-        @footnote_page_map = {} # footnote.id / marker -> first page_number
+        @footnote_page_map = {}
+        @prev_space_after = 0.0
         context = FlowContext.new(layout_spec: @layout_spec, page_number: 1)
         pending = @flowables.dup
         page_state = open_page(context)
@@ -37,16 +38,18 @@ module Arrolio
             page_state.footer = @current_footer
             page_state.header_align = @current_header_align
             page_state.footer_align = @current_footer_align
+            page_state.title_template = flowable.title_template
+            @title_template = nil
+            @prev_space_after = 0.0
             next
           end
 
           if flowable.is_a?(Flowables::PageBreak)
             page_state = open_page(context)
+            @prev_space_after = 0.0
             next
           end
 
-          # Footnote anchors: record on the current page without
-          # consuming frame space (the flowable has zero height).
           if flowable.is_a?(Flowables::FootnoteMarkerFlowable)
             key = flowable.footnote.id || flowable.footnote.marker
             @footnote_page_map[key] ||= page_state.page_number
@@ -55,16 +58,16 @@ module Arrolio
           end
 
           page_state = open_page(context) if flowable.page_break_before? && @pages.any? && !page_state.fresh
-          page_state = open_page(context) if page_state.frame.full?
-
-          width = page_state.frame.width
-          if flowable.keep_together? &&
-             flowable.height(width, context) > page_state.frame.remaining_height &&
-             flowable.height(width, context) <= page_state.frame.height
+          if page_state.frame.full?
             page_state = open_page(context)
+            @prev_space_after = 0.0
           end
 
-          # Record heading entries for ToC + outline building.
+          page_state.frame.width
+          page_state = whole_move_page(flowable, page_state, context)
+
+          page_state = keep_with_next_page(flowable, pending, page_state, context)
+
           if flowable.is_a?(Flowables::HeadingFlowable)
             context.record_heading(number: flowable.number,
                                    title: flowable.title,
@@ -85,37 +88,61 @@ module Arrolio
 
       private
 
-      def place(page_state, flowable, context, pending)
+      # Returns the page state that content was last placed on — a
+      # whole-flowable move to a fresh page must propagate, or the
+      # caller keeps filling the old page and content falls out of
+      # document order.
+      def place(page_state, flowable, context, pending, moved_page: false)
         frame = page_state.frame
         width = frame.width
         natural = flowable.height(width, context)
 
         if natural <= frame.remaining_height
           emit(page_state, flowable, context)
-        elsif flowable.splittable?
-          head, tail = flowable.split(width, frame.remaining_height, context)
-          if head
-            emit(page_state, head, context)
-            pending.unshift(tail) if tail
-          else
-            return page_state unless frame.full?
-
-            new_state = open_page(context)
-            place(new_state, flowable, context, pending)
-          end
-        else
+          @prev_space_after = flowable.space_after.to_f
+          return page_state
+        end
+
+        unless flowable.splittable?
           emit(page_state, flowable, context)
+          @prev_space_after = flowable.space_after.to_f
+          return page_state
         end
-        page_state
+
+        head, tail = flowable.split(width, frame.remaining_height, context)
+        if head
+          emit(page_state, head, context)
+          @prev_space_after = head.space_after.to_f
+          pending.unshift(tail) if tail
+          return page_state
+        end
+        if moved_page
+          # Already on a fresh page and still no fitting head — the
+          # first unsplittable chunk exceeds a full page. Draw it
+          # (overflowing) rather than dropping content or looping.
+          emit(page_state, flowable, context)
+          @prev_space_after = flowable.space_after.to_f
+          return page_state
+        end
+
+        # The flowable's first chunk does not fit the remainder;
+        # retry on a fresh page where it can split properly.
+        @prev_space_after = 0.0
+        place(open_page(context), flowable, context, pending, moved_page: true)
       end
 
       def emit(page_state, flowable, context)
         frame = page_state.frame
         x = frame.x
         y_top = frame.cursor_y
-        boxes, consumed = flowable.emit(x, y_top, frame.width, context)
+
+        curr_before = flowable.space_before.to_f
+        overlap = [@prev_space_after, curr_before].min
+        adjusted_y = y_top + overlap
+
+        boxes, consumed = flowable.emit(x, adjusted_y, frame.width, context)
         page_state.body_boxes.concat(boxes)
-        frame.consume!(consumed)
+        frame.consume!(consumed - overlap)
       end
 
       def open_page(context)
@@ -137,7 +164,7 @@ module Arrolio
           role: @current_role || :body,
           header: @current_header,
           footer: @current_footer,
-          header_align: @current_header_align || :right,
+          header_align: header_align_for(page_number),
           footer_align: @current_footer_align || :center,
           footnotes: []
         )
@@ -145,6 +172,58 @@ module Arrolio
         state
       end
 
+      # keep-together: an atomic flowable taller than the page
+      # remainder (but not the whole page) moves intact.
+      def whole_move_page(flowable, page_state, context)
+        width = page_state.frame.width
+        natural = flowable.height(width, context)
+        return page_state if !flowable.keep_together? ||
+                             natural <= page_state.frame.remaining_height ||
+                             natural > page_state.frame.height
+
+        @prev_space_after = 0.0
+        open_page(context)
+      end
+
+      # XSL-FO keep-with-next: the keep CHAIN — consecutive
+      # keep-with-next flowables plus the next flowable's minimum
+      # height — moves to a fresh page when it would not fit (an
+      # orphaned heading above a moved figure; a term number
+      # without its definition's first paragraph).
+      def keep_with_next_page(flowable, pending, page_state, context)
+        return page_state unless flowable.keep_with_next? && pending.first
+
+        width = page_state.frame.width
+        chain_h = flowable.height(width, context)
+        return page_state if chain_h > page_state.frame.remaining_height
+
+        pending.each do |next_flowable|
+          chain_h += if next_flowable.keep_with_next?
+                       next_flowable.height(width, context)
+                     else
+                       next_flowable.min_keep_height(width, context)
+                     end
+          if chain_h > page_state.frame.remaining_height
+            @prev_space_after = 0.0
+            return open_page(context)
+          end
+          break unless next_flowable.keep_with_next?
+        end
+        page_state
+      end
+
+      # Pick header alignment based on page parity. Even pages
+      # have left-aligned headers; odd pages have right-aligned
+      # headers (matches the XSL-FO convention used by every
+      # flavor: insertHeaderEven left, insertHeaderOdd right).
+      def header_align_for(page_number)
+        explicit = @current_header_align
+        return explicit if explicit
+        return :left if page_number.even?
+
+        :right
+      end
+
       def finalize_pages
         total = @pages.length
         built = @pages.map do |state|
@@ -165,7 +244,8 @@ module Arrolio
             footer_text: format_text(state.footer, state.page_number, total),
             header_align: state.header_align,
             footer_align: state.footer_align,
-            footnotes: state.footnotes
+            footnotes: state.footnotes,
+            title_text: state.title_template
           )
         end
         @pages.replace(built)
@@ -181,6 +261,7 @@ module Arrolio
     OpenPage = Struct.new(:template, :page_number, :frame, :body_boxes,
                           :fresh, :role, :header, :footer,
                           :header_align, :footer_align, :footnotes,
+                          :title_template,
                           keyword_init: true)
   end
 end

data/lib/arrolio/flavor/manifest.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'arrolio/error'
 
 module Arrolio
   module Flavor

data/lib/arrolio/flavor/registry.rb

@@ -11,7 +11,7 @@ module Arrolio
     #   .render(xml, io:, **opts) — render XML to PDF bytes
     #
     # Example:
-    #   Arrolio::Flavor::Registry.register(:my_flavor, Arrolio::Oiml::Pipeline)
+    #   Arrolio::Flavor::Registry.register(:my_flavor, Arrolio::MyFlavorPipeline)
     #   Arrolio::Flavor::Registry.for(:my_flavor).render(xml, io: io)
     class Registry
       @flavors = {}

data/lib/arrolio/flowable.rb

@@ -2,6 +2,20 @@
 
 # Arrolio::Flowable — abstract base for everything the page-flow
 # engine places into Frames.
+#
+# Margin contract: +space_before+/+space_after+ expose the style's
+# margins. The ENGINE collapses min(prev.space_after,
+# curr.space_before) into the gap and adds it above the flowable's
+# emit origin. Two conventions coexist and must not be mixed:
+#
+# - TextFlowable counts its margins INSIDE height/emit (consumed
+#   includes before+after; the engine subtracts the overlap).
+# - ListFlowable and its subclasses (lists, notes) do NOT count
+#   margins in height — spacing around them comes from explicit
+#   Spacers (see GenericFlowBuilder's term notes).
+#
+# A flowable's height() and emit() must agree on whether margins
+# are included, or fit checks and drawing diverge.
 module Arrolio
   class Flowable
     attr_reader :style
@@ -30,6 +44,13 @@ module Arrolio
       @style.keep_with_next
     end
 
+    # Height that must stay on the same page as a preceding
+    # keep-with-next flowable: the whole flowable when atomic, the
+    # first line (plus space-before) when splittable.
+    def min_keep_height(width, context = nil)
+      height(width, context)
+    end
+
     def page_break_before?
       @style.page_break_before
     end

data/lib/arrolio/flowables/figure_flowable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Flowables
+    # A figure is atomic: the image and its caption never split
+    # across a page boundary (FOP keep-together on figure blocks —
+    # an orphaned caption at a page top is a rendering defect).
+    class FigureFlowable < GroupFlowable
+      def initialize(image, caption)
+        super([image, caption])
+      end
+
+      def image = @parts.first
+      def caption = @parts.last
+    end
+  end
+end

data/lib/arrolio/flowables/footnote_marker_flowable.rb

@@ -2,27 +2,46 @@
 
 module Arrolio
   module Flowables
-    # Zero-height placeholder that signals "the footnote with this id
-    # appears on the current page". The engine detects these during
-    # layout and records the footnote on the current Output::Page so
-    # the renderer can draw it at the bottom of the page.
+    # Anchors a footnote to the page it is referenced on and reserves
+    # the vertical space its body needs at the page bottom.
     #
-    # Carries a reference to the full Content::Footnote (marker +
-    # body). The marker is also rendered inline (as a superscript
-    # indicator) by the flow builder when it constructs the run
-    # sequence; this flowable's sole job is to anchor the footnote
-    # to a page.
+    # The footnote's layout policy lives here so the engine's height
+    # accounting and the renderer's drawing agree by construction:
+    # both ask `.body_flowable` for the same laid-out block. The
+    # marker itself renders inline (superscript) from the paragraph's
+    # run sequence; this flowable's job is space + page attribution.
     class FootnoteMarkerFlowable < Flowable
       attr_reader :footnote
 
-      def initialize(footnote)
-        super(style: Style::Definition.new)
+      def initialize(footnote, style: Style::Definition.new(font_size: 9.0))
+        super(style: style)
         @footnote = footnote
       end
 
-      def height(_width, _context = nil) = 0.0
+      # The footnote as it renders at the page bottom: marker + ")"
+      # prefix, body paragraphs joined, footnote style, 2pt gap after.
+      def self.body_flowable(footnote, style)
+        footnote_style = style.with(margin_top: 0.0, margin_bottom: 2.0)
+        runs = [InlineRun.new("#{footnote.marker}) ", style: footnote_style)]
+        footnote.body.each do |node|
+          next unless node.is_a?(Content::Paragraph)
 
-      def emit(_x, _y, _width, _context = nil) = [[], 0.0]
+          node.inline_runs.each do |run|
+            runs << InlineRun.new(run.text, style: footnote_style)
+          end
+        end
+        TextFlowable.new(runs, style: footnote_style)
+      end
+
+      def height(width, _context = nil)
+        self.class.body_flowable(@footnote, @style).height(width)
+      end
+
+      # Emits nothing into the body area - the consumed height frees
+      # the bottom zone where the renderer draws the footnote body.
+      def emit(_x, _y, width, _context = nil)
+        [[], height(width)]
+      end
     end
   end
 end

data/lib/arrolio/flowables/group_flowable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Flowables
+    # A keep-together composite: the whole group moves to the next
+    # page when it does not fit the remainder (XSL-FO
+    # keep-together). Groups taller than a full page split at child
+    # boundaries instead of overflowing.
+    class GroupFlowable < Flowable
+      attr_reader :parts
+
+      def initialize(parts, style: Style::Definition.new(keep_together: true))
+        super(style: style)
+        @parts = Array(parts)
+      end
+
+      def height(width, context = nil)
+        @parts.sum { |p| p.height(width, context) }
+      end
+
+      def emit(x, y, width, context = nil)
+        boxes = []
+        consumed = 0.0
+        cursor = y
+        @parts.each do |part|
+          part_h = part.height(width, context)
+          part_boxes, = part.emit(x, cursor, width, context)
+          boxes.concat(part_boxes)
+          cursor -= part_h
+          consumed += part_h
+        end
+        [boxes, consumed]
+      end
+
+      def splittable?
+        true
+      end
+
+      def do_split(width, remaining_height, context = nil)
+        head = []
+        tail = []
+        used = 0.0
+        @parts.each do |part|
+          part_h = part.height(width, context)
+          if used + part_h <= remaining_height || head.empty?
+            head << part
+            used += part_h
+          else
+            tail << part
+          end
+        end
+        [self.class.new(head, style: @style),
+         tail.empty? ? nil : self.class.new(tail, style: @style)]
+      end
+    end
+  end
+end