arrolio 0.1.0 → 0.1.2

data/lib/arrolio/flowables/list_flowable.rb

@@ -5,57 +5,77 @@ module Arrolio
     # Hanging-indent list. Each item has a marker column (fixed
     # width) and a body column (wraps under body, not marker).
     class ListFlowable < Flowable
-      attr_reader :items, :kind, :marker_width, :body_indent
+      attr_reader :items, :kind, :marker_width, :body_indent,
+                  :marker_indent, :item_spacing
 
       def initialize(items, kind: :bullet, style: Style::Definition.new,
-                     marker_width: 18.0, body_indent: 6.0)
+                     marker_width: 18.0, body_indent: 6.0,
+                     marker_indent: 0.0, item_spacing: 0.0)
         super(style: style)
         @kind = kind.to_sym
         @marker_width = marker_width.to_f
         @body_indent = body_indent.to_f
+        @marker_indent = marker_indent.to_f
+        @item_spacing = item_spacing.to_f
         @items = items
         freeze
       end
 
       def height(width, context = nil)
-        @items.sum do |item|
+        body_h = @items.sum do |item|
           _, body_flowables = item
-          body_width = width - @marker_width - @body_indent
-          body_flowables.sum { |f| f.height(body_width, context) }
+          body_flowables.sum { |f| f.height(body_width(width), context) }
         end
+        body_h + ([@items.length - 1, 0].max * @item_spacing)
+      end
+
+      # What must stay with a preceding keep-with-next flowable:
+      # the first item — the lead-in paragraph keeps with the
+      # list's first line, not the whole list.
+      def min_keep_height(width, context = nil)
+        _, body_flowables = @items.first
+        return 0.0 unless body_flowables&.any?
+
+        body_flowables.sum { |f| f.height(body_width(width), context) }
       end
 
       def emit(x, y, width, context = nil)
         boxes = []
         consumed = 0.0
         cursor = y
-        body_x = x + @marker_width + @body_indent
-        body_width = width - @marker_width - @body_indent
+        marker_x = x + @marker_indent
+        body_x = x + @marker_indent + @marker_width + @body_indent
 
         @items.each_with_index do |item, idx|
           marker_text, body_flowables = item
           marker = marker_text || default_marker(idx)
 
           if marker.is_a?(String)
-            if marker.empty?
-              # no marker to draw
-            else
-              mboxes, = marker_flowable(marker, x, cursor, width, context).emit(x, cursor, width, context)
+            unless marker.empty?
+              mboxes, = marker_flowable(marker, marker_x, cursor, width, context)
+                                 .emit(marker_x, cursor, width, context)
               boxes.concat(mboxes)
             end
           elsif marker
             # marker is a Flowable (e.g. NoteFlowable passes a TextFlowable)
-            mboxes, = marker.emit(x, cursor, width, context)
+            mboxes, = marker.emit(marker_x, cursor, width, context)
             boxes.concat(mboxes)
           end
 
+          item_h = 0.0
           body_flowables.each do |f|
-            fh = f.height(body_width, context)
-            fboxes, = f.emit(body_x, cursor, body_width, context)
+            fh = f.height(body_width(width), context)
+            fboxes, = f.emit(body_x, cursor, body_width(width), context)
             boxes.concat(fboxes)
             cursor -= fh
-            consumed += fh
+            item_h += fh
           end
+
+          if idx < @items.length - 1 && @item_spacing.positive?
+            cursor -= @item_spacing
+            item_h += @item_spacing
+          end
+          consumed += item_h
         end
 
         [boxes, consumed]
@@ -72,7 +92,7 @@ module Arrolio
 
         @items.each do |item|
           _, body_flowables = item
-          item_h = body_flowables.sum { |f| f.height(width - @marker_width - @body_indent, context) }
+          item_h = body_flowables.sum { |f| f.height(body_width(width), context) }
           if used + item_h <= remaining_height || head_items.empty?
             head_items << item
             used += item_h
@@ -86,20 +106,28 @@ module Arrolio
 else
   self.class.new(head_items, kind: @kind, style: @style,
                              marker_width: @marker_width,
-                             body_indent: @body_indent)
+                             body_indent: @body_indent,
+                             marker_indent: @marker_indent,
+                             item_spacing: @item_spacing)
 end
         tail = if tail_items.empty?
   nil
 else
   self.class.new(tail_items, kind: @kind, style: @style,
                              marker_width: @marker_width,
-                             body_indent: @body_indent)
+                             body_indent: @body_indent,
+                             marker_indent: @marker_indent,
+                             item_spacing: @item_spacing)
 end
         [head, tail]
       end
 
       private
 
+      def body_width(width)
+        width - @marker_indent - @marker_width - @body_indent
+      end
+
       def default_marker(idx)
         case @kind
         when :ordered then "#{idx + 1}."

data/lib/arrolio/flowables/note_flowable.rb

@@ -2,17 +2,92 @@
 
 module Arrolio
   module Flowables
-    # Note / example callout: italic label in marker column, body
-    # indented. Reuses ListFlowable's hanging-indent infrastructure.
+    # Note / example callout. Two label layouts:
+    #
+    # - :hanging (notes) — italic label in the marker column, body
+    #   wraps on the same first line (hanging indent). Implemented on
+    #   ListFlowable's hanging-indent infrastructure.
+    # - :block (examples) — the label is a heading on its own line
+    #   at the column edge ("Example:"), body flows below it indented
+    #   by +body_indent+. Emitted sequentially: the label line's
+    #   height is part of the flow, so page breaking sees the whole
+    #   block.
     class NoteFlowable < ListFlowable
+      BLOCK_LABEL_GAP = 6.0
+
+      attr_reader :label_mode
+
       def initialize(label_text, body_flowables, style: Style::Definition.new,
-                     marker_width: 22.0, body_indent: 6.0)
-        label_style = style.with(font_size: style.font_size)
-        marker_run = InlineRun.new("#{label_text} ", style: label_style)
-        marker_flow = TextFlowable.new([marker_run], style: label_style)
-        super([[marker_flow, body_flowables]],
-              kind: :note, style: style,
-              marker_width: marker_width, body_indent: body_indent)
+                     marker_width: 22.0, body_indent: 6.0, label_style: nil,
+                     label_mode: :hanging)
+        @label_mode = label_mode.to_sym
+        effective_label_style = label_style || style.with(font_size: style.font_size)
+        if @label_mode == :block
+          @block_label = TextFlowable.new(
+            [InlineRun.new("#{label_text}:", style: effective_label_style)],
+            style: effective_label_style
+          )
+          @block_body = Array(body_flowables)
+          @block_indent = body_indent.to_f
+          super([[nil, []]], kind: :note, style: style)
+        else
+          marker_run = InlineRun.new("#{label_text} ", style: effective_label_style)
+          marker_flow = TextFlowable.new([marker_run], style: effective_label_style)
+          super([[marker_flow, Array(body_flowables)]],
+                kind: :note, style: style,
+                marker_width: marker_width, body_indent: body_indent)
+        end
+      end
+
+      def height(width, context = nil)
+        return block_height(width, context) if @label_mode == :block
+
+        super
+      end
+
+      def emit(x, y, width, context = nil)
+        return block_emit(x, y, width, context) if @label_mode == :block
+
+        super
+      end
+
+      # Notes stay intact across page breaks: if the whole note does
+      # not fit, it moves to the next page. ListFlowable#do_split is
+      # not usable here — it rebuilds via self.class.new(items, ...)
+      # which does not match this constructor's signature.
+      def do_split(width, remaining_height, context = nil)
+        total = height(width, context)
+        if total <= remaining_height
+          [self, nil]
+        else
+          [nil, self]
+        end
+      end
+
+      private
+
+      def block_height(width, context = nil)
+        @block_label.height(width, context) + BLOCK_LABEL_GAP +
+          @block_body.sum { |f| f.height(width - @block_indent, context) }
+      end
+
+      def block_emit(x, y, width, context = nil)
+        boxes = []
+        consumed = 0.0
+        cursor = y
+
+        label_boxes, label_h = @block_label.emit(x, cursor, width, context)
+        boxes.concat(label_boxes)
+        cursor -= label_h + BLOCK_LABEL_GAP
+        consumed += label_h + BLOCK_LABEL_GAP
+
+        @block_body.each do |flow|
+          fboxes, fh = flow.emit(x + @block_indent, cursor, width - @block_indent, context)
+          boxes.concat(fboxes)
+          cursor -= fh
+          consumed += fh
+        end
+        [boxes, consumed]
       end
     end
   end

data/lib/arrolio/flowables/page_sequence_start.rb

@@ -7,17 +7,21 @@ module Arrolio
     # until the next PageSequenceStart.
     class PageSequenceStart < Flowable
       attr_reader :role, :header_template, :footer_template,
-                  :header_align, :footer_align, :initial_page_number
+                  :header_align, :footer_align, :initial_page_number,
+                  :title_template
 
+      # +header_align+ nil means "no flavor opinion" — the engine
+      # picks left/right from page parity (XSL-FO odd/even headers).
       def initialize(role:, header_template: nil, footer_template: nil,
-                     header_align: :right, footer_align: :center,
-                     initial_page_number: nil)
+                     header_align: nil, footer_align: :center,
+                     initial_page_number: nil, title_template: nil)
         @role = role.to_sym
         @header_template = header_template
         @footer_template = footer_template
-        @header_align = header_align.to_sym
+        @header_align = header_align&.to_sym
         @footer_align = footer_align.to_sym
         @initial_page_number = initial_page_number
+        @title_template = title_template
       end
 
       def height(_width, _context = nil) = 0.0

data/lib/arrolio/flowables/positioned_block.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Flowables
+    # Absolute-positioned container for cover-page layouts. Renders
+    # its children at a fixed (top, left) offset within the page,
+    # regardless of the normal top-down flow.
+    #
+    # The engine treats PositionedBlock as zero-height in the flow
+    # (consumed = 0), so the next flowable continues at the same
+    # y-coordinate. The block's children are placed at page-relative
+    # coordinates computed from +top+ and +left+.
+    #
+    # Used by cover layouts to place the title border-box, the
+    # organisation footer block, and similar non-flow regions.
+    class PositionedBlock < Flowable
+      attr_reader :children, :top, :left, :width, :height_value
+
+      # +children:+ Array of Flowable to render at the fixed position.
+      # +top:+ Distance from the page's top edge (points).
+      # +left:+ Distance from the page's left edge (points).
+      # +width:+ Width of the block (points).
+      # +height:+ Height of the block (points); content overflowing
+      #   is clipped at render time.
+      def initialize(children:, top:, left:, width:, height:,
+                     style: Style::Definition.new)
+        super(style: style)
+        @children = Array(children)
+        @top = top.to_f
+        @left = left.to_f
+        @width = width.to_f
+        @height_value = height.to_f
+      end
+
+      def height(_width, _context = nil)
+        0.0
+      end
+
+      def emit(x, y, _region_width, context = nil)
+        page_top = y + (y).abs # approximate page-top from current y
+        block_y = page_top - @top - @height_value
+        block_x = x + @left
+        boxes = []
+        cursor = block_y + @height_value
+        @children.each do |child|
+          child_boxes, consumed = child.emit(block_x, cursor, @width, context)
+          boxes.concat(child_boxes)
+          cursor -= consumed
+        end
+        # The block consumes zero flow height — siblings continue at y.
+        [boxes, 0.0]
+      end
+    end
+  end
+end

data/lib/arrolio/flowables/rotated_text.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Flowables
+    # Text rendered at a fixed rotation around its baseline. Used
+    # for cover layouts where vertical text runs along the page
+    # edge (some flavors put the docidentifier + edition rotated
+    # 90° on the left margin).
+    #
+    # +angle+ is in degrees, clockwise from horizontal. Common
+    # values: 90 (text reads top-to-bottom), 270 (bottom-to-top).
+    #
+    # The flowable consumes zero vertical flow space (it's
+    # absolutely positioned via PositionedBlock or similar) so
+    # siblings continue normally.
+    class RotatedText < Flowable
+      attr_reader :text, :angle
+
+      def initialize(text, style: Style::Definition.new, angle: 90)
+        super(style: style)
+        @text = text.to_s
+        @angle = angle.to_f
+      end
+
+      def height(_width, _context = nil)
+        GlyphMeasurer.new(font_name: @style.font_name)
+                     .line_height(font_size: @style.font_size,
+                                  line_spacing: @style.line_spacing)
+      end
+
+      def emit(x, y, width, _context = nil)
+        line_h = height(width)
+        measurer = GlyphMeasurer.new(font_name: @style.font_name)
+        text_w = measurer.width_of_string(@text, font_size: @style.font_size)
+
+        box = Output::PlacedBox.new(
+          x: x, y: y - line_h,
+          width: text_w, height: line_h,
+          kind: :rotated_text,
+          data: {
+            text: @text,
+            angle: @angle,
+            line_height: line_h,
+            style: @style
+          }
+        )
+        [[box], 0.0]
+      end
+    end
+  end
+end