arrolio 0.1.0

data/lib/arrolio/content/footnote.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A footnote reference in the content tree. Carries the marker
+    # (e.g. "1", "a", "*") and the footnote body (paragraphs).
+    # The adapter emits these from <fn> elements; the FlowBuilder
+    # places the marker inline and defers the body to the page's
+    # footnote zone (rendered at the bottom of the page).
+    class Footnote
+      attr_reader :marker, :body, :id, :style_id
+
+      def initialize(marker:, body:, id: nil, style_id: :footnote)
+        @marker = marker.to_s
+        @body = Array(body).freeze
+        @id = id&.to_s
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def body_text
+        @body.map do |node|
+          node.is_a?(Paragraph) ? node.text : node.to_s
+        end.join(' ')
+      end
+
+      def empty?
+        @marker.empty? && @body.empty?
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          marker == other.marker &&
+          body == other.body &&
+          id == other.id &&
+          style_id == other.style_id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, marker, body, id, style_id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/form_field.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A form field for interactive PDF AcroForm. Carries the field
+    # type, name, value, and geometry. The renderer emits it as a
+    # PDAcroForm widget (text field, checkbox, radio button) during
+    # post-processing. This model captures the semantic intent;
+    # the actual PDF widget creation is a renderer post-pass.
+    class FormField
+      TYPES = %i[text checkbox radio signature].freeze
+
+      attr_reader :type, :name, :value, :page_number,
+                  :x, :y, :width, :height, :style_id
+
+      def initialize(type:, name:, page_number:, x:, y:, width:, height:, value: nil, style_id: :form_field)
+        @type = type.to_sym
+        @name = name.to_s
+        @value = value
+        @page_number = page_number.to_i
+        @x = x.to_f
+        @y = y.to_f
+        @width = width.to_f
+        @height = height.to_f
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def text? = @type == :text
+      def checkbox? = @type == :checkbox
+      def radio? = @type == :radio
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          type == other.type && name == other.name &&
+          value == other.value && page_number == other.page_number &&
+          x == other.x && y == other.y &&
+          width == other.width && height == other.height
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, type, name, value, page_number, x, y, width, height].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/formula.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A formula — MathML root + rendered text fallback. Carries the
+    # math structure separately from how it's rendered (text fallback
+    # today, proper math typesetting in the future). The renderer can
+    # later use the MathML for accessible representation while the
+    # fallback provides visual rendering.
+    class Formula
+      attr_reader :mathml, :text_fallback, :style_id
+
+      def initialize(mathml:, text_fallback:, style_id: :body)
+        @mathml = mathml.to_s
+        @text_fallback = text_fallback.to_s
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          mathml == other.mathml &&
+          text_fallback == other.text_fallback &&
+          style_id == other.style_id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, mathml, text_fallback, style_id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/heading.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A semantic heading. Distinct from +Paragraph+ so the renderer
+    # can emit PDF structure tags (for accessibility/ToC), the engine
+    # can record heading → page mappings for cross-references, and the
+    # FlowBuilder can apply distinct rendering rules (keep_together,
+    # page-break-before, outline level).
+    class Heading
+      attr_reader :level, :number, :title, :id, :style_id
+
+      def initialize(level:, title:, number: nil, id: nil, style_id: :heading_1)
+        @level = level.to_i
+        @number = number&.to_s
+        @title = title.to_s
+        @id = id&.to_s
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          level == other.level &&
+          number == other.number &&
+          title == other.title &&
+          id == other.id &&
+          style_id == other.style_id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, level, number, title, id, style_id].hash
+      end
+
+      def inline_header?
+        !number.nil? && title.empty?
+      end
+    end
+  end
+end

data/lib/arrolio/content/hyperlink.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # Inline runs wrapped with a hyperlink target. The renderer
+    # emits a PDF /Annot of subtype /Link with the URI (external)
+    # or /Dest reference (internal cross-reference).
+    class Hyperlink
+      attr_reader :runs, :target, :id
+
+      def initialize(runs, target:, internal: false, id: nil)
+        @runs = Array(runs).freeze
+        @target = target.to_s
+        @internal_link = internal ? true : false
+        @id = id&.to_s
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          runs == other.runs &&
+          target == other.target &&
+          internal? == other.internal? &&
+          id == other.id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, runs, target, internal?, id].hash
+      end
+
+      def internal?
+        @internal_link
+      end
+
+      def external?
+        !internal?
+      end
+    end
+  end
+end

data/lib/arrolio/content/image.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    class Image
+      attr_reader :src, :width, :height, :alt, :style_id, :id
+
+      def initialize(src, width: nil, height: nil, alt: nil,
+                     style_id: :figure_image, id: nil)
+        @src = src.to_s
+        @width = width&.to_f
+        @height = height&.to_f
+        @alt = alt
+        @style_id = style_id.to_sym
+        @id = id
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          src == other.src &&
+          width == other.width &&
+          height == other.height &&
+          alt == other.alt &&
+          style_id == other.style_id &&
+          id == other.id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, src, width, height, alt, style_id, id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/index_entry.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A single index entry — a term and the page(s) where it appears.
+    # Part of a back-of-book index section. The adapter extracts
+    # these from <index>/<primary> elements; the FlowBuilder renders
+    # them alphabetically with page numbers.
+    class IndexEntry
+      attr_reader :term, :page_numbers, :see_also, :style_id
+
+      def initialize(term:, page_numbers:, see_also: [], style_id: :index_entry)
+        @term = term.to_s
+        @page_numbers = Array(page_numbers).map(&:to_i).sort.uniq.freeze
+        @see_also = Array(see_also).map(&:to_s).freeze
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def add_page(number)
+        return self if @page_numbers.include?(number.to_i)
+
+        self.class.new(
+          term: @term,
+          page_numbers: @page_numbers + [number.to_i],
+          see_also: @see_also,
+          style_id: @style_id
+        )
+      end
+
+      def first_letter
+        @term[0]&.upcase || ''
+      end
+
+      def page_numbers_str
+        @page_numbers.join(', ')
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          term == other.term &&
+          page_numbers == other.page_numbers &&
+          see_also == other.see_also
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, term, page_numbers, see_also].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/inline_run.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A single inline run of text within a paragraph. Carries the
+    # +text+ to render, the +style_id+ for visual styling (bold,
+    # italic, etc.), optional +href+ for hyperlinks, and optional
+    # +baseline_shift+ / +font_size_scale+ for subscript/superscript
+    # positioning (used by MathML msub/msup rendering).
+    class InlineRun
+      BASELINE_NORMAL = nil
+      BASELINE_SUB = :sub
+      BASELINE_SUP = :sup
+
+      attr_reader :text, :style_id, :href, :baseline_shift, :font_size_scale
+
+      def initialize(text, style_id: :inline, href: nil,
+                     baseline_shift: BASELINE_NORMAL, font_size_scale: 1.0)
+        @text = text.to_s
+        @style_id = style_id.to_sym
+        @href = href
+        @baseline_shift = baseline_shift
+        @font_size_scale = font_size_scale.to_f
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          text == other.text &&
+          style_id == other.style_id &&
+          href == other.href &&
+          baseline_shift == other.baseline_shift &&
+          font_size_scale == other.font_size_scale
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, text, style_id, href, baseline_shift, font_size_scale].hash
+      end
+
+      def subscript?
+        @baseline_shift == BASELINE_SUB
+      end
+
+      def superscript?
+        @baseline_shift == BASELINE_SUP
+      end
+    end
+  end
+end

data/lib/arrolio/content/list.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    class List
+      attr_reader :items, :kind, :style_id, :id
+
+      def initialize(items = [], kind: :bullet, style_id: :list, id: nil)
+        @items = items.map { |i| i.is_a?(Item) ? i : Item.new(i) }.freeze
+        @kind = kind.to_sym
+        @style_id = style_id.to_sym
+        @id = id
+        freeze
+      end
+
+      def ordered? = @kind == :ordered
+      def bullet? = @kind == :bullet
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          items == other.items &&
+          kind == other.kind &&
+          style_id == other.style_id &&
+          id == other.id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, items, kind, style_id, id].hash
+      end
+
+      class Item
+        attr_reader :content, :marker
+
+        def initialize(content, marker: nil)
+          @content = Array(content).freeze
+          @marker = marker
+          freeze
+        end
+
+        def text
+          @content.map do |node|
+            node.is_a?(Paragraph) ? node.text : node.to_s
+          end.join(' ')
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && content == other.content && marker == other.marker
+        end
+
+        alias eql? ==
+
+        def hash
+          [self.class, content, marker].hash
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/content/note.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A semantic note group: optional label ("NOTE 1", "WARNING") plus
+    # one or more body Paragraphs. Distinct from a bare Paragraph
+    # because the flow builder renders it with a hanging indent and
+    # the label in a marker column (matching the XSL's fo:list-block
+    # rendering for notes/examples).
+    #
+    # Wraps the legacy Paragraph-with-`:note`-style emission so flavors
+    # see richer structure without breaking older flow builders.
+    class Note
+      attr_reader :label, :body, :id, :style_id
+
+      def initialize(body:, label: '', id: nil, style_id: :note)
+        @label = label.to_s
+        @body = Array(body).freeze
+        @id = id&.to_s
+        @style_id = style_id.to_sym
+        freeze
+      end
+
+      def body_text
+        @body.map do |node|
+          node.is_a?(Paragraph) ? node.text : node.to_s
+        end.join(' ')
+      end
+
+      def empty?
+        @body.empty? || @body.all? { |node| node.is_a?(Paragraph) && node.empty? }
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          label == other.label &&
+          body == other.body &&
+          id == other.id &&
+          style_id == other.style_id
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, label, body, id, style_id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/page_break.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # An explicit page break in the content tree. Emitted by the
+    # adapter when it encounters a <pagebreak/> element or a clause
+    # with a page-break-before hint. The FlowBuilder converts this
+    # to a Flowables::PageBreak.
+    class PageBreak
+      attr_reader :id
+
+      def initialize(id: nil)
+        @id = id&.to_s
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/paragraph.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    class Paragraph
+      attr_reader :inline_runs, :style_id, :id, :footnote_refs
+
+      def initialize(inline_runs = [], style_id: :body, id: nil, footnote_refs: [])
+        @inline_runs = Array(inline_runs).freeze
+        @style_id = style_id.to_sym
+        @id = id
+        @footnote_refs = Array(footnote_refs).freeze
+        freeze
+      end
+
+      def text
+        @inline_runs.map(&:text).join
+      end
+
+      def empty?
+        @inline_runs.empty? || text.strip.empty?
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          inline_runs == other.inline_runs &&
+          style_id == other.style_id &&
+          id == other.id &&
+          footnote_refs == other.footnote_refs
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, inline_runs, style_id, id, footnote_refs].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/preformatted.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    # A preformatted text block. Preserves whitespace (spaces, tabs,
+    # newlines) and renders in monospace font without justification.
+    # Used for code blocks, ASCII art, and any content where the
+    # visual layout of whitespace matters.
+    #
+    # Each line becomes a separate inline run in the paragraph so
+    # the renderer can apply line-by-line font metrics without the
+    # greedy line breaker collapsing internal whitespace.
+    class Preformatted
+      attr_reader :lines, :language, :style_id, :id
+
+      def initialize(lines, language: nil, style_id: :preformatted, id: nil)
+        @lines = Array(lines).map(&:to_s).freeze
+        @language = language&.to_s
+        @style_id = style_id.to_sym
+        @id = id&.to_s
+        freeze
+      end
+
+      def text
+        @lines.join("\n")
+      end
+
+      def empty?
+        @lines.empty? || @lines.all?(&:empty?)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          lines == other.lines &&
+          language == other.language &&
+          style_id == other.style_id &&
+          id == other.id
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, lines, language, style_id, id].hash
+      end
+    end
+  end
+end

data/lib/arrolio/content/section.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Content
+    class Section
+      attr_reader :title, :level, :number, :id, :children, :style_id, :title_style_id
+
+      def initialize(title: nil, level: 1, number: nil, id: nil,
+                     children: [], style_id: :section_body, title_style_id: nil)
+        @title = title
+        @level = level.to_i
+        @number = number
+        @id = id
+        @children = Array(children).freeze
+        @style_id = style_id.to_sym
+        @title_style_id = (title_style_id || default_title_style).to_sym
+        freeze
+      end
+
+      def heading? = !@title.nil?
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          title == other.title && level == other.level && number == other.number &&
+          id == other.id && children == other.children &&
+          style_id == other.style_id && title_style_id == other.title_style_id
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, title, level, number, id, children, style_id, title_style_id].hash
+      end
+
+      private
+
+      def default_title_style = "heading_#{@level}"
+    end
+  end
+end