arrolio 0.1.0

data/lib/arrolio/renderer/xmp_builder.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    # Builds an XMP metadata packet (RDF/XML wrapped in xpacket
+    # processing instructions). XMP carries Dublin Core properties
+    # (dc:title, dc:creator) alongside PDF-specific properties
+    # (pdf:Producer, xmp:CreatorTool). The packet is stored as a
+    # stream on the PDF catalog's /Metadata entry.
+    class XmpBuilder
+      XPACKET_BEGIN = '<?xpacket begin="\xEF\xBB\xBF" id="W5M0MpCehiHzreSzNTczkc9d"?>'
+      XPACKET_END = '<?xpacket end="w"?>'
+
+      attr_reader :metadata
+
+      def initialize(metadata = {})
+        @metadata = metadata
+      end
+
+      def build
+        [XPACKET_BEGIN, xmp_body, XPACKET_END].join("\n")
+      end
+
+      private
+
+      def xmp_body
+        %(<x:xmpmeta xmlns:x="adobe:ns:meta/">) +
+          %(<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">) +
+          rdf_descriptions +
+          %(</rdf:RDF>) +
+          %(</x:xmpmeta>)
+      end
+
+      def rdf_descriptions
+        [dc_description, pdf_description, xmp_description].compact.join
+      end
+
+      def dc_description
+        return '' unless @metadata[:title] || @metadata[:author]
+
+        inner = []
+        if @metadata[:title]
+          inner << (%(<dc:title><rdf:Alt><rdf:li xml:lang="x-default">) +
+                    escape(@metadata[:title].to_s) +
+                    %(</rdf:li></rdf:Alt></dc:title>))
+        end
+        if @metadata[:author]
+          inner << (%(<dc:creator><rdf:Seq><rdf:li>) +
+                    escape(@metadata[:author].to_s) +
+                    %(</rdf:li></rdf:Seq></dc:creator>))
+        end
+        %(<rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">) +
+          inner.join +
+          %(</rdf:Description>)
+      end
+
+      def pdf_description
+        producer = escape(@metadata[:producer] || 'Arrolio + Pdfrb')
+        %(<rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">) +
+          %(<pdf:Producer>) + producer + %(</pdf:Producer>) +
+          %(</rdf:Description>)
+      end
+
+      def xmp_description
+        creator_tool = escape(@metadata[:creator_tool] || 'Arrolio (Ruby)')
+        create_date = xmp_date(@metadata[:created_at])
+        modify_date = xmp_date(@metadata[:modified_at])
+        %(<rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">) +
+          %(<xmp:CreatorTool>) + creator_tool + %(</xmp:CreatorTool>) +
+          (create_date ? %(<xmp:CreateDate>) + create_date + %(</xmp:CreateDate>) : '') +
+          (modify_date ? %(<xmp:ModifyDate>) + modify_date + %(</xmp:ModifyDate>) : '') +
+          %(</rdf:Description>)
+      end
+
+      def xmp_date(time)
+        t = time || Time.now
+        t = Time.parse(t.to_s) unless t.is_a?(Time)
+        t.strftime('%Y-%m-%dT%H:%M:%S%:z')
+      rescue StandardError
+        nil
+      end
+
+      def escape(str)
+        str.to_s
+           .gsub('&', '&amp;')
+           .gsub('<', '&lt;')
+           .gsub('>', '&gt;')
+           .gsub('"', '&quot;')
+      end
+    end
+  end
+end

data/lib/arrolio/renderer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+# Arrolio::Renderer — walks Output::Page[] and emits bytes.
+module Arrolio
+  module Renderer
+    autoload :Pdf, 'arrolio/renderer/pdf'
+    autoload :FontRegistry, 'arrolio/renderer/font_registry'
+    autoload :OutlineBuilder, 'arrolio/renderer/outline_builder'
+    autoload :XmpBuilder, 'arrolio/renderer/xmp_builder'
+    autoload :AccessibilityTagger, 'arrolio/renderer/accessibility_tagger'
+    autoload :LinkAnnotator, 'arrolio/renderer/link_annotator'
+    autoload :StructureTreeBuilder, 'arrolio/renderer/structure_tree_builder'
+    autoload :SignatureConfig, 'arrolio/renderer/signature_config'
+  end
+end

data/lib/arrolio/style/definition.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Style
+    class Definition
+      attr_reader :font_name, :font_size, :fill_color, :stroke_color,
+                  :line_spacing, :align, :valign,
+                  :margin_top, :margin_right, :margin_bottom, :margin_left,
+                  :padding_top, :padding_right, :padding_bottom, :padding_left,
+                  :character_spacing, :word_spacing, :line_break,
+                  :keep_together, :page_break_before, :page_break_after,
+                  :keep_with_next, :widows, :orphans, :parent
+
+      DEFAULTS = {
+        font_name: 'Helvetica', font_size: 12.0,
+        fill_color: nil, stroke_color: nil,
+        line_spacing: 1.2, align: :left, valign: :top,
+        margin_top: 0.0, margin_right: 0.0, margin_bottom: 0.0, margin_left: 0.0,
+        padding_top: 0.0, padding_right: 0.0, padding_bottom: 0.0, padding_left: 0.0,
+        character_spacing: 0.0, word_spacing: 0.0,
+        line_break: :greedy,
+        keep_together: false, page_break_before: false, page_break_after: false,
+        keep_with_next: false, widows: 2, orphans: 2, parent: nil
+      }.freeze
+
+      def initialize(**opts)
+        merged = DEFAULTS.merge(opts.transform_keys(&:to_sym))
+        @font_name = merged.fetch(:font_name).to_s
+        @font_size = (merged.fetch(:font_size) || 0).to_f
+        @fill_color = merged.fetch(:fill_color)
+        @stroke_color = merged.fetch(:stroke_color)
+        @line_spacing = (merged.fetch(:line_spacing) || 0).to_f
+        @align = merged.fetch(:align).to_sym
+        @valign = merged.fetch(:valign).to_sym
+        @margin_top = (merged.fetch(:margin_top) || 0).to_f
+        @margin_right = (merged.fetch(:margin_right) || 0).to_f
+        @margin_bottom = (merged.fetch(:margin_bottom) || 0).to_f
+        @margin_left = (merged.fetch(:margin_left) || 0).to_f
+        @padding_top = (merged.fetch(:padding_top) || 0).to_f
+        @padding_right = (merged.fetch(:padding_right) || 0).to_f
+        @padding_bottom = (merged.fetch(:padding_bottom) || 0).to_f
+        @padding_left = (merged.fetch(:padding_left) || 0).to_f
+        @character_spacing = (merged.fetch(:character_spacing) || 0).to_f
+        @word_spacing = (merged.fetch(:word_spacing) || 0).to_f
+        @line_break = merged.fetch(:line_break).to_sym
+        @keep_together = truthy?(merged.fetch(:keep_together))
+        @page_break_before = truthy?(merged.fetch(:page_break_before))
+        @page_break_after = truthy?(merged.fetch(:page_break_after))
+        @keep_with_next = truthy?(merged.fetch(:keep_with_next))
+        @widows = merged.fetch(:widows).to_i
+        @orphans = merged.fetch(:orphans).to_i
+        @parent = merged.fetch(:parent)
+        freeze
+      end
+
+      def with(**opts)
+        self.class.new(**to_h, **opts.transform_keys(&:to_sym))
+      end
+
+      def space_before = @margin_top
+      def space_after = @margin_bottom
+
+      def ==(other)
+        other.is_a?(self.class) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash = to_h.hash
+
+      def to_h
+        {
+          font_name: @font_name, font_size: @font_size,
+          fill_color: @fill_color, stroke_color: @stroke_color,
+          line_spacing: @line_spacing, align: @align, valign: @valign,
+          margin_top: @margin_top, margin_right: @margin_right,
+          margin_bottom: @margin_bottom, margin_left: @margin_left,
+          padding_top: @padding_top, padding_right: @padding_right,
+          padding_bottom: @padding_bottom, padding_left: @padding_left,
+          character_spacing: @character_spacing, word_spacing: @word_spacing,
+          line_break: @line_break, keep_together: @keep_together,
+          page_break_before: @page_break_before, page_break_after: @page_break_after,
+          keep_with_next: @keep_with_next, widows: @widows, orphans: @orphans,
+          parent: @parent
+        }
+      end
+
+      private
+
+      def truthy?(v)
+        case v
+        when true, 'true', 'always' then true
+        when Integer then v.positive?
+        else false
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/style/loader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Arrolio
+  module Style
+    module Loader
+      module_function
+
+      def load(source)
+        Registry.new(load_hash(source) || {})
+      end
+
+      def load_hash(source)
+        case source
+        when Hash then source
+        when String then ::YAML.safe_load(source, aliases: true) || {}
+        when IO, StringIO then ::YAML.safe_load(source.read, aliases: true) || {}
+        else
+          raise ArgumentError, 'Loader.load needs a Hash, String, or IO'
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/style/registry.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Arrolio
+  module Style
+    class Registry
+      attr_reader :overrides
+
+      def initialize(overrides = {})
+        @overrides = {}
+        overrides.each { |name, attrs| register(name, **attrs) }
+        freeze
+      end
+
+      def register(name, **opts)
+        @overrides[name.to_sym] = opts.transform_keys(&:to_sym)
+        name.to_sym
+      end
+
+      def resolve(name, fallback: Definition.new)
+        key = name.to_sym
+        return fallback unless @overrides.key?(key)
+
+        chain = []
+        cursor = key
+        seen = Set.new
+        while cursor && @overrides.key?(cursor) && seen.add?(cursor)
+          chain << @overrides[cursor]
+          parent = @overrides[cursor][:parent]
+          cursor = parent&.to_sym
+        end
+        merged = chain.reverse_each.reduce({}) { |acc, h| acc.merge(h) }
+        merged.delete(:parent)
+        Definition.new(**merged)
+      end
+
+      def names = @overrides.keys
+      def key?(name) = @overrides.key?(name.to_sym)
+      def [](name) = @overrides.[](name.to_sym)
+
+      def ==(other)
+        other.is_a?(self.class) && overrides == other.overrides
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, overrides].hash
+      end
+    end
+  end
+end

data/lib/arrolio/style.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Style
+    autoload :Definition, 'arrolio/style/definition'
+    autoload :Registry, 'arrolio/style/registry'
+    autoload :Loader, 'arrolio/style/loader'
+  end
+end

data/lib/arrolio/table/auto_layout.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Table
+    # Computes column widths for a Content::Table based on natural
+    # content widths. Each column gets at least its natural width
+    # (longest unbreakable token + padding). Remaining space is
+    # distributed proportionally to the column's natural width, so
+    # wider columns get more extra space.
+    #
+    # If the total natural width exceeds the available width, columns
+    # are scaled down proportionally (each gets a share proportional
+    # to its natural width, but never below a minimum).
+    class AutoLayout
+      MIN_COLUMN_WIDTH = 20.0 # points — prevents columns from collapsing
+      CELL_PADDING = 8.0      # points — left + right padding per cell
+
+      attr_reader :table, :available_width, :measurer
+
+      def initialize(table, available_width:, measurer: nil)
+        @table = table
+        @available_width = available_width.to_f
+        @measurer = measurer || default_measurer
+      end
+
+      # Returns an Array of Float widths (one per column), summing
+      # to +available_width+.
+      def compute
+        return Array.new(column_count, @available_width / column_count) if column_count.zero?
+
+        natural = natural_widths
+        distribute(natural)
+      end
+
+      private
+
+      def column_count
+        @table.column_count
+      end
+
+      # Natural width of each column = max cell natural width across rows.
+      def natural_widths
+        widths = Array.new(column_count, MIN_COLUMN_WIDTH)
+        @table.rows.each do |row|
+          row.cells.each_with_index do |cell, ci|
+            next if ci >= widths.length
+
+            w = cell_natural_width(cell)
+            widths[ci] = w if w > widths[ci]
+          end
+        end
+        widths
+      end
+
+      def cell_natural_width(cell)
+        longest = cell.text.split(/\s+/).max_by(&:length) || ''
+        @measurer.width_of_string(longest, font_size: 10.0) + CELL_PADDING
+      end
+
+      # Distribute +available_width+ across columns based on their
+      # natural widths. If naturals fit, distribute extra space
+      # proportionally. If they overflow, scale down proportionally
+      # (but never below MIN_COLUMN_WIDTH).
+      def distribute(natural)
+        total_natural = natural.sum
+        if total_natural >= @available_width
+          scale_down(natural, total_natural)
+        else
+          distribute_extra(natural, total_natural)
+        end
+      end
+
+      def scale_down(natural, total_natural)
+        ratio = @available_width / total_natural
+        natural.map { |w| [w * ratio, MIN_COLUMN_WIDTH].max }
+      end
+
+      def distribute_extra(natural, total_natural)
+        extra = @available_width - total_natural
+        natural.map.with_index do |w, _i|
+          share = total_natural.positive? ? (w / total_natural) : 0.0
+          w + (extra * share)
+        end
+      end
+
+      def default_measurer
+        GlyphMeasurer.new(font_name: 'Times New Roman')
+      end
+    end
+  end
+end

data/lib/arrolio/table.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arrolio
+  # Table layout algorithms. Currently:
+  # - AutoLayout — content-based column width computation.
+  module Table
+    autoload :AutoLayout, 'arrolio/table/auto_layout'
+  end
+end

data/lib/arrolio/text_direction.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Arrolio
+  # Unicode text direction detection for BIDI-aware layout. Detects
+  # whether a string is predominantly left-to-right (Latin, CJK),
+  # right-to-left (Arabic, Hebrew), or mixed. Used by the text
+  # layout engine to apply correct character ordering within lines.
+  #
+  # This module implements the "paragraph level" detection from
+  # Unicode UAX #9 (BIDI Algorithm) — a simplified version that
+  # suffices for most standards documents. Full BIDI reordering
+  # (handling embedded runs, override controls) is future work.
+  module TextDirection
+    LTR = :ltr
+    RTL = :rtl
+    MIXED = :mixed
+
+    # Unicode blocks containing RTL characters.
+    RTL_RANGES = [
+      0x0590..0x05FF,   # Hebrew
+      0x0600..0x06FF,   # Arabic
+      0x0700..0x074F,   # Syriac
+      0x0750..0x077F,   # Arabic Supplement
+      0x08A0..0x08FF,   # Arabic Extended-A
+      0xFB1D..0xFB4F,   # Hebrew Presentation Forms
+      0xFB50..0xFDFF,   # Arabic Presentation Forms-A
+      0xFE70..0xFEFF    # Arabic Presentation Forms-B
+    ].freeze
+
+    module_function
+
+    # Returns the dominant direction of a string.
+    # +:ltr+ — all or predominantly LTR characters.
+    # +:rtl+ — predominantly RTL characters.
+    # +:mixed+ — significant presence of both LTR and RTL.
+    def detect(string)
+      return LTR if string.nil? || string.empty?
+
+      chars = string.each_char.to_a
+      rtl_count = chars.count { |c| rtl?(c) }
+      ltr_count = chars.count { |c| ltr?(c) }
+
+      return LTR if rtl_count.zero?
+      return RTL if ltr_count.zero?
+
+      ratio = rtl_count.to_f / (rtl_count + ltr_count)
+      ratio > 0.6 ? RTL : (ratio < 0.3 ? LTR : MIXED)
+    end
+
+    # Is this character an RTL character?
+    def rtl?(char)
+      cp = char.ord
+      RTL_RANGES.any? { |range| range.cover?(cp) }
+    end
+
+    # Is this character an LTR character (Latin, Cyrillic, Greek,
+    # CJK, etc.)? Excludes whitespace, punctuation, and digits
+    # (which are neutral in BIDI).
+    def ltr?(char)
+      cp = char.ord
+      return false if cp < 0x0041  # below 'A'
+      return false if rtl?(char)
+      return false if neutral?(char)
+
+      # Latin, Latin Extended, Cyrillic, Greek, CJK, etc.
+      true
+    end
+
+    # BIDI-neutral characters (whitespace, punctuation, digits).
+    def neutral?(char)
+      char.match?(/\s/) || char.match?(/[0-9]/) || char.match?(/[^\p{L}]/)
+    end
+
+    # Reverses a string character-by-character for RTL rendering.
+    # Does NOT do full BIDI reordering — only flips the base
+    # direction. Adequate for simple RTL text without embedded LTR.
+    def reverse_for_rtl(string)
+      string.reverse
+    end
+  end
+end

data/lib/arrolio/text_layout/break_opportunity.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module TextLayout
+    # A candidate line-break position within a list of InlineRuns.
+    class BreakOpportunity
+      attr_reader :run_index, :char_offset, :width_before, :type
+
+      def initialize(run_index:, char_offset:, width_before:, type:)
+        @run_index = run_index
+        @char_offset = char_offset
+        @width_before = width_before.to_f
+        @type = type
+        freeze
+      end
+
+      def forced?
+        @type == :forced
+      end
+
+      def soft?
+        @type == :soft
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          run_index == other.run_index &&
+          char_offset == other.char_offset &&
+          width_before == other.width_before &&
+          type == other.type
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, run_index, char_offset, width_before, type].hash
+      end
+
+      class << self
+        def each_in(runs, measurer:, font_size:)
+          return enum_for(:each_in, runs, measurer: measurer, font_size: font_size) unless block_given?
+
+          yield new(run_index: 0, char_offset: 0, width_before: 0.0, type: :start)
+
+          cumulative = 0.0
+          runs.each_with_index do |run, run_index|
+            text = run.text
+            i = 0
+            while i < text.length
+              ch = text[i]
+              if ch == "\n"
+                yield new(run_index: run_index, char_offset: i,
+                          width_before: cumulative, type: :forced)
+                i += 1
+                next
+              end
+
+              if ch == ' '
+                cumulative += char_width(run, ' ', measurer, font_size)
+                yield new(run_index: run_index, char_offset: i + 1,
+                          width_before: cumulative, type: :soft)
+                i += 1
+                next
+              end
+
+              if ch == '-' || ch == '—' || ch == '­'
+                cumulative += char_width(run, ch, measurer, font_size)
+                yield new(run_index: run_index, char_offset: i + 1,
+                          width_before: cumulative, type: :soft)
+                i += 1
+                next
+              end
+
+              if ch == '​'
+                yield new(run_index: run_index, char_offset: i,
+                          width_before: cumulative, type: :soft)
+                i += 1
+                next
+              end
+
+              cumulative += char_width(run, ch, measurer, font_size)
+              i += 1
+            end
+          end
+
+          yield new(run_index: runs.length, char_offset: 0,
+                    width_before: cumulative, type: :end)
+        end
+
+        private
+
+        def char_width(run, char, measurer, font_size)
+          measurer.width_of_run(
+            char,
+            font_size: font_size,
+            character_spacing: run.style.character_spacing,
+            word_spacing: 0
+          )
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/text_layout/greedy.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module TextLayout
+    # First-fit greedy line breaker. FOP's default. Linear time.
+    class Greedy
+      attr_reader :runs, :measurer, :width, :align
+
+      def initialize(runs, measurer:, width:, align: :left)
+        @runs = runs
+        @measurer = measurer
+        @width = width.to_f
+        @align = align
+      end
+
+      def layout
+        opps = opportunities
+        return [] if opps.empty? || opps.length == 1
+
+        lines = []
+        line_start = 0
+        i = 1
+        while i < opps.length
+          opp = opps[i]
+          prev = opps[i - 1]
+
+          if opp.forced?
+            emit_line(lines, opps, line_start, i, prev.width_before)
+            line_start = i + 1
+            i += 2
+            next
+          end
+
+          if overflows?(opps, line_start, opp) && (i - line_start > 1)
+            emit_line(lines, opps, line_start, i - 1, prev.width_before)
+            line_start = i - 1
+          end
+          i += 1
+        end
+
+        emit_final_line(lines, opps, line_start) unless lines_built_complete?(opps, line_start)
+        lines
+      end
+
+      private
+
+      def opportunities
+        BreakOpportunity.each_in(@runs, measurer: @measurer,
+                                        font_size: font_size).to_a
+      end
+
+      def font_size
+        @runs.first&.style&.font_size || 12
+      end
+
+      def overflows?(opps, line_start, opp)
+        opp.width_before - opps[line_start].width_before > @width
+      end
+
+      def emit_line(lines, opps, start_idx, end_idx, _line_width)
+        placed = build_placed_runs(opps, start_idx, end_idx)
+        width_used = opps[end_idx].width_before - opps[start_idx].width_before
+        lines << Line.new(placed, width: width_used,
+                                  max_width: @width, align: @align)
+      end
+
+      def emit_final_line(lines, opps, line_start)
+        last = opps.last
+        prev_w = line_start.positive? ? opps[line_start - 1].width_before : 0.0
+        return if last.width_before <= prev_w && !lines.empty?
+
+        emit_line(lines, opps, line_start, opps.length - 1, last.width_before)
+      end
+
+      def lines_built_complete?(opps, line_start)
+        line_start >= opps.length - 1
+      end
+
+      def build_placed_runs(opps, start_idx, end_idx)
+        return [] if start_idx >= end_idx
+
+        start_opp = opps[start_idx]
+        end_opp = opps[end_idx] || opps.last
+        start_run = start_opp.run_index
+        start_off = start_opp.char_offset
+        end_run = end_opp.run_index
+        end_off = end_opp.char_offset
+
+        placed = []
+        x_offset = 0.0
+        (start_run..end_run).each do |run_idx|
+          next unless run_idx < @runs.length
+
+          run = @runs[run_idx]
+          s_off = run_idx == start_run ? start_off : 0
+          e_off = run_idx == end_run ? end_off : run.text.length
+          next if s_off >= e_off
+
+          slice = run.text[s_off, e_off - s_off]
+          next if slice.nil? || slice.empty?
+
+          sub_run = InlineRun.new(slice, style: run.style)
+          placed << Line::PlacedRun.new(run: sub_run, x_offset: x_offset)
+          x_offset += sub_run.width(@measurer)
+        end
+        placed
+      end
+    end
+  end
+end