arrolio 0.1.0 → 0.1.2

data/lib/arrolio/generic_flow_builder.rb

@@ -1,9 +1,27 @@
 # frozen_string_literal: true
 
+require 'tmpdir'
 require 'yaml'
 
 module Arrolio
   class GenericFlowBuilder
+    autoload :Sequences, 'arrolio/generic_flow_builder/sequences'
+    autoload :Terms, 'arrolio/generic_flow_builder/terms'
+    autoload :Notes, 'arrolio/generic_flow_builder/notes'
+    autoload :Figures, 'arrolio/generic_flow_builder/figures'
+    autoload :Lists, 'arrolio/generic_flow_builder/lists'
+    autoload :Bibliography, 'arrolio/generic_flow_builder/bibliography'
+    autoload :Tables, 'arrolio/generic_flow_builder/tables'
+
+    include Sequences
+    include Terms
+    include Notes
+    include Figures
+    include Lists
+    include Bibliography
+    include Tables
+
+
     attr_reader :layout_spec, :rules, :asset_resolver
 
     def initialize(layout_spec:, rules:, asset_resolver: nil)
@@ -19,112 +37,45 @@ module Arrolio
         source = content_for(document, sequence['role'])
         next if sequence['role'].to_s != 'cover' && sequence['role'].to_s != 'back_of_cover' && source.empty?
 
-        flowables << sequence_start(document, sequence)
+        start = sequence_start(document, sequence)
+        flowables << start
+        # The part-title overlay consumes layout space in the
+        # reference (title glyph top to the first heading: 58pt on
+        # the first body page); reserve it so following content
+        # lands where the reference puts it.
+        flowables << Flowables::Spacer.new(title_block_space) if start.title_template
         build_sequence_content(document, source, sequence, flowables)
         flowables << Flowables::PageBreak.new if sequence['page_break_after']
       end
-      append_inline_footnote_markers(document, flowables)
       append_endnotes(document, flowables)
       flowables
     end
 
-    # Emits a FootnoteMarkerFlowable for each Document#footnote when the
-    # flavor opts in via `flow_rules.page_bottom_footnotes: true`. The
-    # engine collects these onto the page where they appear (the last
-    # body page by default) and the renderer draws them at the bottom.
-    #
-    # This is a pragmatic bridge until the adapter can emit markers
-    # inline at `<fn>` reference sites (TODO 60). Opt-in keeps it
-    # disabled by default so existing flavors are unaffected.
-    def append_inline_footnote_markers(document, flowables)
-      return if document.footnotes.empty?
-      return unless @rules['page_bottom_footnotes']
-
-      document.footnotes.each do |footnote|
-        flowables << Flowables::FootnoteMarkerFlowable.new(footnote)
-      end
-    end
-
-    def append_endnotes(document, flowables)
-      return if document.footnotes.empty?
-      return unless @rules['endnotes']
-
-      flowables << Flowables::PageSequenceStart.new(
-        role: :endnotes,
-        header_template: nil,
-        footer_template: nil
-      )
-      document.footnotes.each do |footnote|
-        marker_text = footnote.marker.to_s
-        body = footnote.body.map { |paragraph| paragraph_flowable(paragraph) }
-        flowables << Flowables::NoteFlowable.new(
-          marker_text,
-          body,
-          style: resolve(footnote.style_id),
-          marker_width: 22.0
-        )
-      end
-    end
 
     private
 
-    def page_sequences
-      Array(@rules['page_sequences'])
-    end
 
-    def sequence_start(document, sequence)
-      Flowables::PageSequenceStart.new(
-        role: sequence.fetch('role'),
-        header_template: interpolate(sequence['header'], document),
-        footer_template: sequence['footer'],
-        header_align: sequence['header_align'] || :right,
-        footer_align: sequence['footer_align'] || :center,
-        initial_page_number: sequence['initial_page_number']
-      )
+    def title_block_space
+      (@rules.dig('title', 'block_space') || 0.0).to_f
     end
 
-    def build_sequence_content(document, source, sequence, out)
-      if sequence['build_content'] == 'cover_content'
-        build_cover_content(document, out)
-      elsif source.is_a?(Array)
-        build_sections(source, out)
-      end
-    end
-
-    def content_for(document, role)
-      case role.to_s
-      when 'preface' then document.preface
-      when 'body' then document.sections
-      when 'bibliography' then document.bibliography
-      else []
-      end
-    end
-
-    def build_cover_content(document, out)
-      Array(@rules['cover_content']).each do |entry|
-        next unless condition_matches?(entry['when'], document)
-
-        case entry['type'].to_s
-        when 'spacer'
-          out << Flowables::Spacer.new(entry.fetch('size').to_f)
-        when 'text'
-          style = resolve(entry.fetch('style'))
-          style = style.with(align: :center) if entry.fetch('align', 'center').to_sym == :center
-          text = interpolate(entry.fetch('source'), document)
-          out << Flowables::TextFlowable.new([InlineRun.new(text, style: style)], style: style)
-        end
-      end
-    end
-
-    def build_sections(sections, out)
+    def build_sections(sections, out, between_breaks: false)
       section_rules = @rules.fetch('section', {})
       break_between = section_rules.fetch('insert_page_break_before', false)
+      break_numbers = section_rules.fetch('page_break_before_numbers', [])
       sections.each_with_index do |section, index|
-        out << Flowables::PageBreak.new if break_between && index.positive?
+        forced = break_numbers.include?(section.number.to_s)
+        needs_break = (break_between || forced || between_breaks) &&
+                      index.positive? && !bibliography_section?(section)
+        out << Flowables::PageBreak.new if needs_break
         build_section(section, out)
       end
     end
 
+    def bibliography_section?(section)
+      section.children.any?(Content::BibliographyItem)
+    end
+
     def build_section(section, out)
       if section.heading?
         out << Flowables::HeadingFlowable.new(
@@ -138,14 +89,24 @@ module Arrolio
 
       children = section.children
       children = prefix_number(section.number, children) if !section.heading? && section.number
-      children.each { |child| append_child(child, out) }
+      children.each_with_index do |child, index|
+        append_child(child, out, followed_by_keep: keeps_with_previous?(children[index + 1]))
+      end
+    end
+
+    # Tables and lists pull their preceding paragraph with them
+    # across page boundaries (XSL-FO keep-with-next on the lead-in;
+    # the reference breaks freely between text and figures — 2.3's
+    # paragraph ends p5 with Figure 1 opening p6).
+    def keeps_with_previous?(child)
+      child.is_a?(Content::Table) || child.is_a?(Content::List)
     end
 
     def prefix_number(number, children)
       return children if children.empty? || !children.first.is_a?(Content::Paragraph)
 
       first = children.first
-      prefix = Content::InlineRun.new("#{number}  ", style_id: :caption_label)
+      prefix = Content::InlineRun.new("#{number} ", style_id: :caption_label)
       updated = Content::Paragraph.new(
         [prefix] + first.inline_runs,
         style_id: first.style_id,
@@ -157,23 +118,53 @@ module Arrolio
 
     def emit_footnote_markers_for(paragraph, out)
       return if paragraph.footnote_refs.empty?
+      return unless @rules['page_bottom_footnotes']
       return unless @document
 
       paragraph.footnote_refs.each do |ref_id|
         footnote = @document.footnotes.find { |fn| fn.id == ref_id || fn.marker == ref_id }
         next unless footnote
 
-        out << Flowables::FootnoteMarkerFlowable.new(footnote)
+        out << Flowables::FootnoteMarkerFlowable.new(
+          footnote, style: resolve(:footnote)
+        )
       end
     end
 
-    def append_child(child, out)
+    def append_child(child, out, standalone: true, followed_by_keep: false,
+                     in_term: false)
       case child
       when Content::Paragraph
-        out << paragraph_flowable(child)
+        flowable = paragraph_flowable(child, standalone: standalone)
+        # mn2pdf keeps a paragraph with the table/figure that
+        # follows it, so the caption is never orphaned at a page
+        # bottom and the reference's page-end whitespace before
+        # table sections is reproduced.
+        if followed_by_keep
+          flowable = Flowables::TextFlowable.new(
+            flowable.runs,
+            style: flowable.style.with(keep_with_next: true),
+            measurer: flowable.measurer
+          )
+        end
+        out << flowable
         emit_footnote_markers_for(child, out)
       when Content::Note
-        out << note_flowable(child)
+        note = note_flowable(child)
+        before = in_term ? term_config.fetch('note_spacing', 0.0).to_f : 0.0
+        after = in_term ? term_config.fetch('note_spacing_after', before) : 0.0
+        parts = []
+        parts << Flowables::Spacer.new(before) if before.positive?
+        parts << note
+        parts << Flowables::Spacer.new(after) if after.positive?
+        out << if parts.length == 1
+                 note
+               else
+                 Flowables::GroupFlowable.new(parts,
+                                              style: Style::Definition.new(keep_together: false))
+               end
+      when Content::Example
+        out << example_flowable(child)
       when Content::FigureGroup
         figure_group_flowable(child, out)
       when Content::TermEntry
@@ -183,7 +174,11 @@ module Arrolio
       when Content::Section
         build_section(child, out)
       when Content::Table
-        out << Flowables::TableFlowable.new(child, style: resolve(child.style_id))
+        out << Flowables::TableFlowable.new(child,
+                                            style: resolve(child.style_id),
+                                            caption_runs: caption_runs_for(child),
+                                            caption_style: resolve(:figure_caption).with(align: :left),
+                                            **table_geometry)
       when Content::List
         out << list_flowable(child)
       when Content::Image
@@ -195,52 +190,7 @@ module Arrolio
       end
     end
 
-    def note_flowable(note)
-      body = note.body.map { |paragraph| paragraph_flowable(paragraph) }
-      Flowables::NoteFlowable.new(
-        note.label,
-        body,
-        style: resolve(note.style_id)
-      )
-    end
-
-    def figure_group_flowable(group, out)
-      out << image_flowable(group.image) if group.image
-      return unless group.caption
-
-      caption_style = resolve(:figure_caption)
-      runs = group.caption.inline_runs.map do |run|
-        InlineRun.new(run.text, style: caption_style)
-      end
-      out << Flowables::TextFlowable.new(runs, style: caption_style)
-    end
-
-    def term_entry_flowable(entry, out)
-      if entry.number
-        out << Flowables::TextFlowable.new(
-          [InlineRun.new(entry.number, style: resolve(:term))],
-          style: resolve(:term)
-        )
-      end
-      out << paragraph_flowable(entry.preferred) if entry.preferred
-      entry.definition.each { |paragraph| out << paragraph_flowable(paragraph) }
-      return unless entry.source
-
-      out << paragraph_flowable(entry.source)
-    end
-
-    def bibliography_item_flowable(item, out)
-      marker_text = item.tag.to_s
-      body = item.formattedref ? [paragraph_flowable(item.formattedref)] : []
-      out << Flowables::NoteFlowable.new(
-        marker_text,
-        body,
-        style: resolve(item.style_id),
-        marker_width: 36.0
-      )
-    end
-
-    def paragraph_flowable(paragraph)
+    def paragraph_flowable(paragraph, standalone: false)
       runs = paragraph.inline_runs.map do |run|
         InlineRun.new(
           run.text,
@@ -250,7 +200,9 @@ module Arrolio
           href: run.href
         )
       end
-      Flowables::TextFlowable.new(runs, style: resolve(paragraph.style_id))
+      style = resolve(paragraph.style_id)
+      style = style.with(margin_bottom: 10.0) if standalone && paragraph.style_id == :body
+      Flowables::TextFlowable.new(runs, style: style)
     end
 
     def preformatted_flowable(preformatted)
@@ -263,53 +215,6 @@ module Arrolio
       Flowables::TextFlowable.new(runs, style: style)
     end
 
-    def list_flowable(list)
-      items = list.items.each_with_index.map do |item, index|
-        marker = item.marker.nil? ? default_marker(list, index) : item.marker
-        body = item.content.filter_map do |content|
-          paragraph_flowable(content) if content.is_a?(Content::Paragraph)
-        end
-        [marker, body]
-      end
-      Flowables::ListFlowable.new(items, kind: list.kind, style: resolve(list.style_id))
-    end
-
-    def default_marker(list, index)
-      defaults = @rules.dig('list', 'defaults') || {}
-      if list.ordered?
-        format = defaults['ordered_marker'] || '%d.'
-        format.sub('%d', (index + 1).to_s)
-      else
-        defaults['bullet_marker'] || '■ '
-      end
-    end
-
-    def image_flowable(image)
-      source = asset_resolver.resolve(image.src)
-      image_rules = @rules['image'] || {}
-      default_width = (image_rules['default_natural_width'] || 400).to_f
-      default_height = (image_rules['default_natural_height'] || 300).to_f
-      max_width = (image_rules['max_display_width'] || 106).to_f
-      natural_width = image.width || svg_dimension(source, 'width') || default_width
-      natural_height = image.height || svg_dimension(source, 'height') || default_height
-      display_width = [image.width || natural_width, max_width].min
-      Flowables::ImageFlowable.new(
-        source,
-        natural_width: natural_width,
-        natural_height: natural_height,
-        display_width: display_width,
-        alt: image.alt,
-        style: resolve(image.style_id)
-      )
-    end
-
-    def svg_dimension(source, name)
-      return nil unless source && File.exist?(source) && source.match?(/\.svg\z/i)
-
-      value = File.read(source)[/(?:#{name})=["']([\d.]+)/, 1]
-      value&.to_f
-    end
-
     def resolve(style_id)
       @layout_spec.resolve_style(style_id.to_sym)
     end

data/lib/arrolio/glyph_measurer.rb

@@ -21,17 +21,28 @@ module Arrolio
       !@metrics.nil?
     end
 
-    def width_of_string(str, font_size:)
-      return estimate(str, font_size) unless available?
+    def metrics_for(font_name)
+      return @metrics if font_name.nil? || font_name.to_s == @font_name
 
-      @metrics.width_of_string(str, font_size: font_size)
+      ::Arrolio::FontMetrics::Registry[font_name.to_s]
+    end
+
+    # +font_name+ lets a paragraph-level measurer price a run that
+    # carries a different font (e.g. a bold run inside a regular
+    # paragraph). Falls back to the instance font when nil.
+    def width_of_string(str, font_size:, font_name: nil)
+      metrics = metrics_for(font_name)
+      return estimate(str, font_size) if metrics.nil?
+
+      metrics.width_of_string(str, font_size: font_size)
     end
 
     # Width of a run including character_spacing (Tc — extra space
     # added after every glyph) and word_spacing (Tw — extra space
     # added after every space glyph). Matches PDF rendering rules.
-    def width_of_run(str, font_size:, character_spacing: 0, word_spacing: 0)
-      base = width_of_string(str, font_size: font_size)
+    def width_of_run(str, font_size:, character_spacing: 0, word_spacing: 0,
+                     font_name: nil)
+      base = width_of_string(str, font_size: font_size, font_name: font_name)
       char_count = str.length
       word_count = str.count('  ')
       extra = (character_spacing.to_f * [char_count - 1, 0].max) +

data/lib/arrolio/inline_run.rb

@@ -35,7 +35,8 @@ module Arrolio
         @text,
         font_size: font_size * @font_size_scale,
         character_spacing: style.character_spacing,
-        word_spacing: style.word_spacing
+        word_spacing: style.word_spacing,
+        font_name: style.font_name
       )
     end
 

data/lib/arrolio/layout_spec/page_template.rb

@@ -87,27 +87,33 @@ module Arrolio
         { before: 0.0, after: 0.0, start: 0.0, end: 0.0 }
       end
 
+      # XSL-FO geometry: the body region is the page content
+      # rectangle (page minus page margins). The before/after/start/
+      # end extents size the auxiliary regions that sit INSIDE the
+      # margins — they never displace the body. Shrinking the body
+      # by the extents wasted the whole header/footer strip on
+      # every page.
       def compute_regions
         pw = width
         ph = height
         m = @margins
         e = @region_extents
-        inner_w = pw - m[:left] - m[:right] - e[:start] - e[:end]
-        inner_h = ph - m[:top] - m[:bottom] - e[:before] - e[:after]
+        inner_w = pw - m[:left] - m[:right]
+        inner_h = ph - m[:top] - m[:bottom]
         {
           body: Region.new(name: :body,
-                           x: m[:left] + e[:start],
-                           y: m[:bottom] + e[:after],
+                           x: m[:left],
+                           y: m[:bottom],
                            width: inner_w,
                            height: inner_h),
           before: Region.new(name: :before,
-                             x: m[:left] + e[:start],
-                             y: ph - m[:top] - e[:before],
+                             x: m[:left],
+                             y: ph - m[:top],
                              width: inner_w,
                              height: e[:before]),
           after: Region.new(name: :after,
-                            x: m[:left] + e[:start],
-                            y: m[:bottom],
+                            x: m[:left],
+                            y: m[:bottom] - e[:after],
                             width: inner_w,
                             height: e[:after]),
           start: Region.new(name: :start,