arrolio 0.1.0

data/lib/arrolio/output/page.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Output
+    class Page
+      attr_reader :number, :template_name, :template_role, :page_size,
+                  :regions, :static_regions, :header_text, :footer_text,
+                  :header_align, :footer_align, :footnotes
+
+      def initialize(number:, template_name:, page_size:,
+                     regions:, static_regions: {}, template_role: :body,
+                     header_text: nil, footer_text: nil,
+                     header_align: :right, footer_align: :center,
+                     footnotes: [])
+        @number = number.to_i
+        @template_name = template_name.to_sym
+        @template_role = template_role.to_sym
+        @page_size = [page_size[0].to_f, page_size[1].to_f].freeze
+        @regions = regions.transform_keys(&:to_sym).freeze
+        @static_regions = static_regions.transform_keys(&:to_sym).freeze
+        @header_text = header_text
+        @footer_text = footer_text
+        @header_align = header_align.to_sym
+        @footer_align = footer_align.to_sym
+        @footnotes = Array(footnotes).freeze
+        freeze
+      end
+
+      def body_region
+        @regions[:body]
+      end
+
+      def width
+        @page_size[0]
+      end
+
+      def height
+        @page_size[1]
+      end
+
+      def each_box(&block)
+        return enum_for(:each_box) unless block_given?
+
+        @static_regions.each_value { |r| r.placed_boxes.each(&block) }
+        @regions.each_value { |r| r.placed_boxes.each(&block) }
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          number == other.number &&
+          template_name == other.template_name &&
+          template_role == other.template_role &&
+          page_size == other.page_size &&
+          regions == other.regions &&
+          static_regions == other.static_regions &&
+          header_text == other.header_text &&
+          footer_text == other.footer_text &&
+          footnotes == other.footnotes
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, number, template_name, template_role, page_size,
+         regions, static_regions, header_text, footer_text, footnotes].hash
+      end
+    end
+  end
+end

data/lib/arrolio/output/placed_box.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Output
+    class PlacedBox
+      attr_reader :x, :y, :width, :height, :kind, :data, :link_dest
+
+      def initialize(x:, y:, width:, height:, kind:, data: {}, link_dest: nil)
+        @x = x.to_f
+        @y = y.to_f
+        @width = width.to_f
+        @height = height.to_f
+        @kind = kind
+        @data = data.to_h.freeze
+        @link_dest = link_dest
+        freeze
+      end
+
+      class << self
+        def text(x:, y:, width:, height:, lines:, line_height:, style:, link_dest: nil)
+          new(x: x, y: y, width: width, height: height, kind: :text,
+              data: { lines: Array(lines).freeze,
+                      line_height: line_height.to_f,
+                      style: style },
+              link_dest: link_dest)
+        end
+
+        def rect(x:, y:, width:, height:, stroke_width: 0.5,
+                 stroke_color: nil, fill_color: nil)
+          new(x: x, y: y, width: width, height: height, kind: :rect,
+              data: { stroke_width: stroke_width.to_f,
+                      stroke_color: stroke_color,
+                      fill_color: fill_color })
+        end
+
+        def line(x1:, y1:, x2:, y2:, stroke_width: 0.5, stroke_color: nil)
+          new(x: [x1, x2].min, y: [y1, y2].min,
+              width: (x2 - x1).abs, height: (y2 - y1).abs,
+              kind: :line,
+              data: { x1: x1.to_f, y1: y1.to_f,
+                      x2: x2.to_f, y2: y2.to_f,
+                      stroke_width: stroke_width.to_f,
+                      stroke_color: stroke_color })
+        end
+
+        def image(x:, y:, width:, height:, image_ref:, link_dest: nil)
+          new(x: x, y: y, width: width, height: height, kind: :image,
+              data: { image_ref: image_ref },
+              link_dest: link_dest)
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          x == other.x && y == other.y &&
+          width == other.width && height == other.height &&
+          kind == other.kind && data == other.data &&
+          link_dest == other.link_dest
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, x, y, width, height, kind, data, link_dest].hash
+      end
+    end
+  end
+end

data/lib/arrolio/output/region.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Output
+    class Region
+      attr_reader :name, :x, :y, :width, :height, :placed_boxes
+
+      def initialize(name:, x:, y:, width:, height:, placed_boxes: [])
+        @name = name.to_sym
+        @x = x.to_f
+        @y = y.to_f
+        @width = width.to_f
+        @height = height.to_f
+        @placed_boxes = Array(placed_boxes).freeze
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          name == other.name && x == other.x && y == other.y &&
+          width == other.width && height == other.height &&
+          placed_boxes == other.placed_boxes
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, name, x, y, width, height, placed_boxes].hash
+      end
+    end
+  end
+end

data/lib/arrolio/output.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Arrolio::Output — the medium-neutral laid-out page tree.
+module Arrolio
+  module Output
+    autoload :Page, 'arrolio/output/page'
+    autoload :Region, 'arrolio/output/region'
+    autoload :PlacedBox, 'arrolio/output/placed_box'
+  end
+end

data/lib/arrolio/renderer/accessibility_tagger.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    # Builds marked-content property lists for PDF/UA accessibility.
+    # Wraps non-text content (images, formulas) with /Alt and
+    # /ActualText entries so screen readers can access the semantic
+    # meaning even when the visual rendering is a rasterized image
+    # or a flattened formula.
+    #
+    # In the PDF content stream, marked content looks like:
+    #   /MP << /Alt (alternative text) >> BDC
+    #   ... drawing operators ...
+    #   EMC
+    #
+    # This class builds the property list dictionaries; the renderer
+    # wraps them in BDC/EMC operators when drawing.
+    class AccessibilityTagger
+      attr_reader :document
+
+      def initialize(document)
+        @document = document
+        @sequence = 0
+      end
+
+      # Builds a property list dictionary for an image's alt text.
+      # Returns a Pdfrb reference to the dictionary, or nil if no
+      # alt text is provided.
+      def alt_property(alt_text)
+        return nil if alt_text.nil? || alt_text.to_s.empty?
+
+        @document.add(
+          { Alt: alt_text.to_s },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+      end
+
+      # Builds a property list for actual text (the visible text
+      # representation of non-text content, e.g. a formula's
+      # flattened text).
+      def actual_text_property(text)
+        return nil if text.nil? || text.to_s.empty?
+
+        @document.add(
+          { ActualText: text.to_s },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+      end
+
+      # Combines alt + actual text into a single property list.
+      # When both are present, the dictionary carries both entries.
+      def combined_property(alt_text: nil, actual_text: nil)
+        props = {}
+        props[:Alt] = alt_text.to_s if alt_text && !alt_text.to_s.empty?
+        props[:ActualText] = actual_text.to_s if actual_text && !actual_text.to_s.empty?
+        return nil if props.empty?
+
+        @document.add(props, type: Pdfrb::Model::Cos::Dictionary)
+      end
+
+      # Next unique marked-content sequence number. Used by the
+      # renderer to tag BDC/EMC pairs so structure-tree entries can
+      # reference them.
+      def next_tag
+        @sequence += 1
+        :"MC#{@sequence}"
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/font_registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    # Maps font family names to Pdfrb resource Symbols.
+    class FontRegistry
+      attr_reader :document
+
+      def initialize(document)
+        @document = document
+        @refs = {}
+      end
+
+      def resolve(font_name)
+        key = font_name.to_s
+        return @refs[key] if @refs.key?(key)
+
+        @refs[key] = begin
+          ref = @document.fonts.add(key)
+          ref || key.to_sym
+        rescue StandardError
+          fallback = @refs['Helvetica'] ||= @document.fonts.add('Helvetica')
+          fallback
+        end
+      end
+
+      def known_fonts
+        @refs.keys
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/link_annotator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    # Collects hyperlink annotations during rendering and emits them
+    # as /Annot entries on each PDF page. The renderer calls
+    # +record_link+ for each text run that has an href; after the
+    # page is fully rendered, +flush+ emits the /Annots array.
+    class LinkAnnotator
+      Link = Struct.new(:x, :y, :width, :height, :uri, keyword_init: true)
+
+      attr_reader :document, :pending_links
+
+      def initialize(document)
+        @document = document
+        @pending_links = []
+      end
+
+      def record_link(x:, y:, width:, height:, uri:)
+        @pending_links << Link.new(x: x, y: y, width: width, height: height, uri: uri)
+      end
+
+      # Emits collected links as /Annot entries on the given pdfrb
+      # page. Clears the pending list after emitting.
+      def flush(pdfrb_page)
+        return if @pending_links.empty?
+
+        annots = @pending_links.map { |link| build_link_annot(link) }
+        existing = pdfrb_page.value[:Annots]
+        if existing.is_a?(Array)
+          existing.concat(annots)
+        else
+          pdfrb_page.value[:Annots] = annots
+        end
+        @pending_links.clear
+      end
+
+      private
+
+      def build_link_annot(link)
+        rect = [
+          link.x,
+          link.y,
+          link.x + link.width,
+          link.y + link.height
+        ]
+        action = @document.add(
+          { S: :URI, URI: link.uri },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+        annot = @document.add(
+          { Type: :Annot, Subtype: :Link,
+            Rect: rect,
+            Border: [0, 0, 0],
+            A: Pdfrb::Model::Reference.new(action.oid, action.gen) },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+        Pdfrb::Model::Reference.new(annot.oid, annot.gen)
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/outline_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    # Builds the PDF /Outlines tree from FlowContext#heading_entries.
+    # Each entry becomes an /Outlines item with /Title and /Dest
+    # pointing at its source page's top. Called by Renderer::Pdf
+    # AFTER all pages have been emitted (so page refs exist).
+    class OutlineBuilder
+      attr_reader :document, :entries, :pdfrb_pages
+
+      def initialize(document:, entries:, pdfrb_pages:)
+        @document = document
+        @entries = entries
+        @pdfrb_pages = pdfrb_pages
+      end
+
+      def build
+        return nil if entries.empty?
+
+        items = build_items
+        return nil if items.empty?
+
+        root = document.add(
+          {
+            Type: :Outlines,
+            First: ref(items.first),
+            Last: ref(items.last),
+            Count: items.length
+          },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+        catalog = document.catalog
+        catalog.value[:Outlines] = ref(root)
+        root
+      end
+
+      private
+
+      def build_items
+        items = []
+        prev = nil
+        entries.each do |entry|
+          outline_entry = build_one(entry)
+          next unless outline_entry
+
+          if prev
+            prev.value[:Next] = ref(outline_entry)
+            outline_entry.value[:Prev] = ref(prev)
+          end
+          items << outline_entry
+          prev = outline_entry
+        end
+        items
+      end
+
+      def build_one(entry)
+        page_ref = page_ref_at(entry[:page_number])
+        return nil unless page_ref
+
+        title = [entry[:number], entry[:title]].compact.join(' ').to_s
+        document.add(
+          {
+            Type: :Outlines,
+            Title: title.encode('UTF-8', invalid: :replace, undef: :replace),
+            Parent: parent_ref,
+            Dest: [page_ref, :XYZ, 0, page_height(entry[:page_number]), nil]
+          },
+          type: Pdfrb::Model::Cos::Dictionary
+        )
+      end
+
+      def page_ref_at(page_number)
+        page = pdfrb_pages[page_number - 1]
+        return nil unless page
+
+        Pdfrb::Model::Reference.new(page.oid, page.gen)
+      end
+
+      def page_height(page_number)
+        page = pdfrb_pages[page_number - 1]
+        return 800.0 unless page
+
+        box = page.value[:MediaBox]
+        return 800.0 unless box
+
+        box.is_a?(Array) ? box[3].to_f : 800.0
+      end
+
+      def parent_ref
+        return @parent_ref if @parent_ref
+
+        root = document.catalog.value[:Outlines]
+        @parent_ref = root
+      end
+
+      def ref(obj)
+        Pdfrb::Model::Reference.new(obj.oid, obj.gen)
+      end
+    end
+  end
+end