idml 0.3.0 → 0.4.0

data/lib/idml/render/hyperlink_resolver.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Resolves IDML hyperlink definitions to URL destinations. Looks
+    # up `Hyperlink#source` → `Hyperlink#destination` →
+    # `HyperlinkURLDestination#destination_url` from the designmap.
+    #
+    # The renderer is responsible for mapping source Self IDs to
+    # page-item rectangles; this resolver only handles the
+    # destination lookup.
+    class HyperlinkResolver
+      def initialize(package)
+        @package = package
+      end
+
+      # Returns the URL for the given hyperlink-source Self, or nil.
+      def url_for_source(source_self)
+        return nil unless source_self
+
+        hyperlink = hyperlink_by_source(source_self)
+        return nil unless hyperlink
+
+        url_destination_by_self(hyperlink.destination)&.destination_url
+      end
+
+      # Yields [source_self, url] for every visible hyperlink whose
+      # destination chain resolves to a URL.
+      def each_visible
+        return enum_for(:each_visible) unless block_given?
+
+        hyperlinks.each do |hyperlink|
+          entry = visible_entry(hyperlink)
+          yield(*entry) if entry
+        end
+      end
+
+      private
+
+      def visible_entry(hyperlink)
+        return nil if hyperlink.visible == false || hyperlink.hidden == true
+
+        url = url_destination_by_self(hyperlink.destination)&.destination_url
+        return nil unless url
+
+        [hyperlink.source, url]
+      end
+
+      def hyperlinks
+        @package&.designmap&.hyperlink || []
+      end
+
+      def hyperlink_by_source(source_self)
+        hyperlinks.find { |h| h.source == source_self }
+      end
+
+      def url_destination_by_self(self_attr)
+        return nil unless self_attr
+
+        url_destinations.find { |d| d.self_attr == self_attr }
+      end
+
+      def url_destinations
+        @package&.designmap&.hyperlink_url_destination || []
+      end
+    end
+  end
+end

data/lib/idml/render/icc_profile.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Locates an sRGB ICC profile for PDF/A output intent embedding.
+    # The idml gem does not bundle a binary ICC asset; instead, this
+    # helper probes a small set of well-known locations in priority
+    # order and returns the first match as raw bytes.
+    #
+    # Priority:
+    #   1. `ENV["IDML_SRGB_ICC"]` — explicit user override.
+    #   2. `data/idml/srgb.icc` inside the gem tree (user-vendored).
+    #   3. macOS system profile at
+    #      `/System/Library/ColorSync/Profiles/sRGB Profile.icc`.
+    #
+    # Returns `nil` when no profile is available — callers (Pipeline)
+    # should skip ICC embedding in that case rather than raising.
+    module IccProfile
+      GEM_DATA_PATH = File.expand_path("../../../data/idml/srgb.icc", __dir__)
+      MACOS_SYSTEM_PATH = "/System/Library/ColorSync/Profiles/sRGB Profile.icc"
+
+      def self.srgb_bytes
+        candidate_paths.each do |path|
+          bytes = read_if_present(path)
+          return bytes if bytes
+        end
+        nil
+      end
+
+      def self.candidate_paths
+        [
+          ENV.fetch("IDML_SRGB_ICC", nil),
+          GEM_DATA_PATH,
+          MACOS_SYSTEM_PATH,
+        ].compact
+      end
+      private_class_method :candidate_paths
+
+      def self.read_if_present(path)
+        return nil unless path && !path.empty?
+        return nil unless File.exist?(path)
+
+        File.binread(path)
+      rescue StandardError
+        nil
+      end
+      private_class_method :read_if_present
+    end
+  end
+end

data/lib/idml/render/pdfrb_writer.rb

@@ -83,6 +83,16 @@ module Idml
                                               page: page, mcid: mcid)
       end
 
+      def add_uri_link_annotation(page_index:, rect:, url:)
+        page = @document.pages[page_index]
+        action = @document.add({ S: :URI, URI: url },
+                               type: Pdfrb::Model::Cos::Dictionary)
+        action_ref = Pdfrb::Model::Reference.new(action.oid, action.gen)
+        annot = @document.annotations.add(page, subtype: :Link, rect: rect)
+        annot.value[:A] = action_ref
+        annot
+      end
+
       def build_structure
         @document.structure.build!
       end

data/lib/idml/render/pipeline.rb

@@ -13,7 +13,7 @@ module Idml
                      compliance: nil, tagged: false, subset_fonts: true)
         @package = package
         @output_path = output_path
-        @font_resolver = build_font_resolver(font_search_paths)
+        @font_search_paths = font_search_paths
         @compliance = compliance
         @tagged = tagged
         @subset_fonts = subset_fonts
@@ -24,22 +24,28 @@ module Idml
         metadata = combined_metadata
         writer.set_info(metadata)
         writer.enable_tagged if @tagged
-        PdfaPacket.attach(writer.document, metadata) if pdfa_requested?
+        if pdfa_requested?
+          PdfaPacket.attach(writer.document, metadata)
+          embed_pdfa_output_intent(writer)
+        end
         structure = StructureTracker.new(enabled: @tagged)
         layer_filter = LayerFilter.from_designmap(@package.designmap)
         font_ref_resolver = FontReferenceResolver.build(@package)
         base_dir = File.dirname(@package.path)
-        font_name = register_font(writer)
+        font_resource = register_font(writer)
+        font_metrics = build_font_metrics(writer, font_resource)
         page_index = -1
 
         @package.spreads.each do |spread|
           page_index = render_spread_pages(writer, spread, base_dir,
                                            layer_filter, font_ref_resolver,
-                                           font_name, structure, page_index)
+                                           font_resource, font_metrics,
+                                           structure, page_index)
         end
 
         structure.flush(writer)
         writer.build_structure if @tagged
+        emit_bookmarks(writer)
         writer.subset_fonts! if @subset_fonts
         writer.write(@output_path)
         @output_path
@@ -47,18 +53,38 @@ module Idml
 
       private
 
+      def embed_pdfa_output_intent(writer)
+        bytes = IccProfile.srgb_bytes
+        return unless bytes
+
+        writer.document.output_intents.embed_icc(
+          bytes,
+          identifier: "sRGB",
+          condition: "sRGB IEC61966-2.1",
+          subtype: :GTS_PDFA1,
+        )
+      rescue StandardError
+        nil
+      end
+
+      def emit_bookmarks(writer)
+        BookmarkResolver.new(@package).each do |title, page_index|
+          writer.add_bookmark(title, page_index)
+        end
+      end
+
       def pdfa_requested?
         @compliance&.to_s&.start_with?("pdfa")
       end
 
       def render_spread_pages(writer, spread, base_dir, layer_filter,
-                              font_ref_resolver, font_name, structure,
-                              page_offset)
+                              font_ref_resolver, font_resource, font_metrics,
+                              structure, page_offset)
         pages = spread.spread.flat_map(&:page)
         image_refs = ImageCollector.new(writer: writer, base_dir: base_dir,
                                         page_height: DEFAULT_HEIGHT).collect(spread)
-        renderer = build_renderer(layer_filter, font_ref_resolver, font_name,
-                                  structure: structure)
+        renderer = build_renderer(layer_filter, font_ref_resolver,
+                                  font_resource, font_metrics, structure: structure)
         current = page_offset
 
         pages.each do |page|
@@ -69,14 +95,23 @@ module Idml
                                           page_height: dims[:height],
                                           image_refs: image_refs,
                                           page_index: current)
+          emit_hyperlinks(writer, spread, current)
         end
         current
       end
 
-      def build_renderer(layer_filter, font_ref_resolver, font_name, structure:)
+      def emit_hyperlinks(writer, spread, page_index)
+        HyperlinkEmitter.new(writer: writer, package: @package,
+                             page_height: DEFAULT_HEIGHT).emit_for(spread, page_index)
+      rescue StandardError
+        nil
+      end
+
+      def build_renderer(layer_filter, font_ref_resolver, font_resource,
+                         font_metrics, structure:)
         SpreadRenderer.new(
-          font_resolver: @font_resolver,
-          font_ps_name: font_name,
+          font_metrics: font_metrics,
+          font_ps_name: font_resource,
           package: @package,
           layer_filter: layer_filter,
           font_ref_resolver: font_ref_resolver,
@@ -89,14 +124,15 @@ module Idml
           height: page.height || DEFAULT_HEIGHT }
       end
 
-      def build_font_resolver(paths)
-        search = paths || TextEngine::FontResolver::DEFAULT_SEARCH_PATHS
-        TextEngine::FontResolver.new(search_paths: search)
+      def build_font_metrics(writer, font_resource)
+        return nil if font_resource == Render::DEFAULT_FONT
+
+        TextEngine::PdfrbFontMetrics.new(writer.document.fonts, font_resource)
+      rescue StandardError
+        nil
       end
 
       def register_font(writer)
-        return Render::DEFAULT_FONT unless @font_resolver
-
         path = resolve_document_font_path
         return Render::DEFAULT_FONT unless path
 
@@ -105,6 +141,12 @@ module Idml
         Render::DEFAULT_FONT
       end
 
+      def font_resolver
+        @font_resolver ||= Pdfrb::FontResolver.new(
+          search_paths: @font_search_paths || Pdfrb::FontResolver::DEFAULT_SEARCH_PATHS,
+        )
+      end
+
       def resolve_document_font_path
         return nil unless @package&.fonts
 
@@ -120,8 +162,8 @@ module Idml
           next unless font.post_script_name
           next if font.status == "Missing"
 
-          metrics = @font_resolver.resolve_by_ps_name(font.post_script_name)
-          return metrics.path if metrics
+          path = font_resolver.find_by_ps_name(font.post_script_name)
+          return path if path
         end
         nil
       end

data/lib/idml/render/render_context.rb

@@ -9,7 +9,7 @@ module Idml
     RenderContext = Struct.new(
       :item,
       :package,
-      :font_resolver,
+      :font_metrics,
       :font_ref_resolver,
       :color_resolver,
       :font_ps_name,

data/lib/idml/render/renderers/group_renderer.rb

@@ -14,13 +14,15 @@ module Idml
               child_context = Render::RenderContext.new(
                 item: child,
                 package: context.package,
-                font_resolver: context.font_resolver,
+                font_metrics: context.font_metrics,
                 font_ref_resolver: context.font_ref_resolver,
                 color_resolver: context.color_resolver,
                 font_ps_name: context.font_ps_name,
                 page_width: context.page_width,
                 page_height: context.page_height,
                 layer_filter: context.layer_filter,
+                structure: context.structure,
+                page_index: context.page_index,
               )
               PageItemRenderer.render(canvas, child_context)
             end

data/lib/idml/render/renderers/table_renderer.rb

@@ -3,7 +3,14 @@
 module Idml
   module Render
     module Renderers
+      # Renders an IDML Table. Draws the cell grid via rectangle ops,
+      # then renders inline `<CharacterStyleRange>` text in each cell
+      # via `canvas.text_rich`. Cells with no text render as empty
+      # rectangles.
       class TableRenderer
+        DEFAULT_SIZE = 10.0
+        INSET = 4.0
+
         def self.render(canvas, context)
           table = context.item
           return if table.visible == false
@@ -17,24 +24,41 @@ module Idml
 
           canvas.save_graphics_state do
             table.table_row.each_with_index do |row, row_index|
-              render_row(canvas, row, row_index, row_count, box, row_height)
+              render_row(canvas, row, row_index, row_count, box, row_height,
+                         context)
             end
           end
         end
 
-        def self.render_row(canvas, row, row_index, row_count, box, row_height)
+        def self.render_row(canvas, row, row_index, row_count, box, row_height,
+                            context)
           row_y = box[:y] + ((row_count - 1 - row_index) * row_height)
           cell_count = row.table_cell.length
           return unless cell_count.positive?
 
           cell_width = box[:width] / cell_count
-          row.table_cell.each_with_index do |_cell, cell_index|
+          row.table_cell.each_with_index do |cell, cell_index|
             cell_x = box[:x] + (cell_index * cell_width)
             canvas.rectangle(cell_x, row_y, cell_width, row_height)
             canvas.stroke
+            render_cell_text(canvas, cell, cell_x, row_y, row_height, context)
           end
         end
         private_class_method :render_row
+
+        def self.render_cell_text(canvas, cell, x, y, height, context)
+          text = cell.text_content
+          return if text.nil? || text.empty?
+
+          runs = [{
+            text: text,
+            font: context.font_ps_name,
+            size: DEFAULT_SIZE,
+          }]
+          baseline = y + (height / 2)
+          canvas.text_rich(runs, at: [x + INSET, baseline])
+        end
+        private_class_method :render_cell_text
       end
     end
   end

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -4,10 +4,10 @@ module Idml
   module Render
     module Renderers
       # Renders an IDML TextFrame on a Pdfrb::Content::Canvas. Extracts
-      # styled runs via StyleResolver. When a FontMetrics is available,
-      # runs the full text engine pipeline (Shaper → LineBreaker →
-      # VerticalLayout) for proper word-wrap; otherwise falls back to
-      # simple one-text-per-run positioning.
+      # styled runs via StyleResolver. When a FontMetrics is available
+      # (pdfrb-backed), runs the full text engine pipeline (Shaper →
+      # LineBreaker) for proper word-wrap; otherwise falls back to a
+      # single text_rich call per frame.
       class TextFrameRenderer
         DEFAULT_SIZE = 12.0
         LEADING_FACTOR = 1.2
@@ -28,7 +28,7 @@ module Idml
         end
 
         def self.render_text(canvas, runs, context, box)
-          font = resolve_font_metrics(context)
+          font = context.font_metrics
           if font
             engine_render(canvas, runs, context, box, font)
           else
@@ -47,26 +47,6 @@ module Idml
         end
         private_class_method :frame_box
 
-        def self.resolve_font_metrics(context)
-          return nil unless context.font_resolver
-
-          context.font_resolver.resolve(
-            family_name: Render::DEFAULT_FONT, style_name: "Regular",
-          )
-        end
-        private_class_method :resolve_font_metrics
-
-        def self.simple_render(canvas, runs, context, box)
-          runs.each_with_index do |run, index|
-            y = box[:y] + box[:height] -
-              ((index + 1) * run.point_size * LEADING_FACTOR)
-            canvas.text(run.text, at: [box[:x], y],
-                                  font: context.font_ps_name,
-                                  size: run.point_size)
-          end
-        end
-        private_class_method :simple_render
-
         def self.engine_render(canvas, runs, context, box, font)
           baseline_y = box[:y] + box[:height] - runs.first.point_size
 
@@ -78,6 +58,11 @@ module Idml
         end
         private_class_method :engine_render
 
+        # Emits one `canvas.text` call per line, after shaping and
+        # line-breaking with real font metrics. Applies paragraph
+        # alignment via `Justifier` so each line is offset within
+        # the frame box per IDML `Justification`. Lines that fall
+        # below the frame's bottom edge are clipped.
         def self.render_run_lines(canvas, run, context, box, font, baseline_y)
           size = run.point_size
           glyphs = TextEngine::Shaper.shape(
@@ -86,25 +71,55 @@ module Idml
           lines = TextEngine::LineBreaker.break(
             glyphs: glyphs, frame_width: box[:width],
           )
+          alignment = run.alignment || :left
+          start_y = box[:y] + box[:height] - size
+
+          lines.each_with_index do |line, idx|
+            line_y = start_y - (idx * size * LEADING_FACTOR)
+            break if line_y < box[:y]
+
+            TextEngine::Justifier.justify(line: line,
+                                          frame_width: box[:width],
+                                          alignment: alignment)
+            canvas.text(line_text(line),
+                        at: [box[:x] + line.x_offset, line_y],
+                        font: context.font_ps_name,
+                        size: size)
+          end
+          baseline_y
+        end
+        private_class_method :render_run_lines
 
-          line_texts = []
-          lines.each do |line|
-            break if baseline_y < box[:y]
+        def self.line_text(line)
+          line.glyphs.map { |g| [g.codepoint].pack("U") }.join
+        end
+        private_class_method :line_text
 
-            line_texts << line.glyphs.map { |g| [g.codepoint].pack("U") }.join
-            baseline_y -= size * LEADING_FACTOR
-          end
+        # Fallback when no metrics are available: emit all runs as
+        # one `text_rich` block, letting pdfrb measure advance widths.
+        # Uses pdfrb's measurement API directly (no Fontisan).
+        def self.simple_render(canvas, runs, context, box)
+          runs_for = build_rich_runs(runs, context)
+          return if runs_for.empty?
 
-          if line_texts.any?
-            canvas.text_lines(line_texts,
-                              font: context.font_ps_name,
-                              size: size,
-                              at: [box[:x], box[:y] + box[:height] - size],
-                              leading: size * LEADING_FACTOR)
+          first_size = runs.first.point_size
+          canvas.text_rich(
+            runs_for,
+            at: [box[:x], box[:y] + box[:height] - first_size],
+          )
+        end
+        private_class_method :simple_render
+
+        def self.build_rich_runs(runs, context)
+          runs.map do |run|
+            {
+              text: run.text,
+              font: context.font_ps_name,
+              size: run.point_size,
+            }
           end
-          baseline_y
         end
-        private_class_method :render_run_lines
+        private_class_method :build_rich_runs
       end
     end
   end

data/lib/idml/render/spread_renderer.rb

@@ -4,10 +4,10 @@ module Idml
   module Render
     # Renders a typed `Parts::Spread` onto a Pdfrb::Content::Canvas.
     class SpreadRenderer
-      def initialize(font_resolver: nil, font_ps_name: Render::DEFAULT_FONT,
+      def initialize(font_metrics: nil, font_ps_name: Render::DEFAULT_FONT,
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil)
-        @font_resolver = font_resolver
+        @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
         @layer_filter = layer_filter
@@ -19,7 +19,7 @@ module Idml
                  page_index: 0)
         context_base = {
           package: @package,
-          font_resolver: @font_resolver,
+          font_metrics: @font_metrics,
           font_ref_resolver: @font_ref_resolver,
           color_resolver: build_color_resolver,
           font_ps_name: @font_ps_name,

data/lib/idml/render/style_resolver.rb

@@ -4,15 +4,30 @@ module Idml
   module Render
     # Extracts styled text runs from an IDML Story. Each run carries the
     # text content plus the CharacterStyleRange attributes that affect
-    # rendering (font style, size, fill color, applied font reference).
+    # rendering (font style, size, fill color, applied font reference,
+    # paragraph alignment).
     class StyleResolver
       StyledRun = Struct.new(
         :text, :font_style, :point_size,
-        :fill_color, :fill_tint, :applied_font, keyword_init: true
+        :fill_color, :fill_tint, :applied_font, :alignment,
+        keyword_init: true
       )
 
       DEFAULT_POINT_SIZE = 12.0
 
+      # IDML `Justification` enum → Justifier symbol. Full justify
+      # and binding-side variants defer to :left for now (TODO 80).
+      ALIGNMENT_MAP = {
+        "Left" => :left,
+        "Center" => :center,
+        "Right" => :right,
+        "LeftJustified" => :left,
+        "RightJustified" => :right,
+        "CenterJustified" => :center,
+        "FullyJustified" => :justified,
+        "ToBinding" => :left,
+      }.freeze
+
       def self.extract_runs(story)
         return [] unless story&.inner
 
@@ -33,11 +48,17 @@ module Idml
             fill_color: csr.fill_color,
             fill_tint: csr.fill_tint,
             applied_font: csr.applied_font,
+            alignment: alignment_for(csr),
           )
         end
       end
       private_class_method :csr_runs
 
+      def self.alignment_for(csr)
+        ALIGNMENT_MAP[csr.justification] || :left
+      end
+      private_class_method :alignment_for
+
       # Concatenate runs into a single block. Used when the renderer
       # can't handle per-run styling (e.g., no font metrics available).
       def self.concatenate(runs)

data/lib/idml/render.rb

@@ -19,6 +19,10 @@ module Idml
     autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"
     autoload :StructureMapper,     "#{__dir__}/render/structure_mapper"
     autoload :PdfaPacket,          "#{__dir__}/render/pdfa_packet"
+    autoload :IccProfile,          "#{__dir__}/render/icc_profile"
+    autoload :BookmarkResolver,    "#{__dir__}/render/bookmark_resolver"
+    autoload :HyperlinkResolver,   "#{__dir__}/render/hyperlink_resolver"
+    autoload :HyperlinkEmitter,    "#{__dir__}/render/hyperlink_emitter"
     autoload :StoryThreader,       "#{__dir__}/render/story_threader"
     autoload :PdfrbWriter, "#{__dir__}/render/pdfrb_writer"
     autoload :SpreadRenderer,      "#{__dir__}/render/spread_renderer"

data/lib/idml/text_engine/pdfrb_font_metrics.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Idml
+  module TextEngine
+    # Adapter that exposes the same measurement surface as
+    # `FontMetrics` (the Fontisan-based parser) but delegates to
+    # pdfrb's `Fonts` collection + a registered font resource Symbol.
+    #
+    # Once a font is registered with the pdfrb document via
+    # `document.fonts.add(path)`, pdfrb parses the TTF tables (cmap,
+    # hmtx, head, hhea) and exposes real per-glyph advance widths
+    # through `Fonts#glyph_width(resource, codepoint)` and
+    # `Fonts#metrics_for(resource)`. This adapter wraps that pair so
+    # the text engine (Shaper, LineBreaker) can use real metrics
+    # without any Fontisan dependency.
+    class PdfrbFontMetrics
+      attr_reader :resource, :fonts
+
+      def initialize(fonts_collection, resource)
+        @fonts = fonts_collection
+        @resource = resource
+      end
+
+      def units_per_em
+        metrics_data[:units_per_em] || 1000
+      end
+
+      def ascent
+        metrics_data[:ascent] || 800
+      end
+
+      def descent
+        metrics_data[:descent] || -200
+      end
+
+      def line_gap
+        0
+      end
+
+      # Returns raw advance width in font units (not scaled by size).
+      def glyph_width(codepoint)
+        cp = codepoint.is_a?(String) ? codepoint.each_codepoint.first : codepoint
+        @fonts.glyph_width(@resource, cp).to_i
+      end
+
+      def measure_text(text, size:)
+        return 0.0 if text.nil? || text.empty?
+
+        text.each_codepoint.sum do |cp|
+          glyph_width(cp) * size.to_f / units_per_em
+        end
+      end
+
+      def kerning_pair(_left_cp, _right_cp)
+        0
+      end
+
+      def postscript_name
+        @resource.to_s
+      end
+
+      def family_name
+        postscript_name
+      end
+
+      def style_name
+        "Regular"
+      end
+
+      def path
+        nil
+      end
+
+      private
+
+      def metrics_data
+        @fonts.metrics_for(@resource) || {}
+      end
+    end
+  end
+end