idml 0.2.9 → 0.3.1

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
@@ -21,18 +21,26 @@ module Idml
 
       def call
         writer = PdfrbWriter.new
-        writer.set_info(combined_metadata)
+        metadata = combined_metadata
+        writer.set_info(metadata)
         writer.enable_tagged if @tagged
+        PdfaPacket.attach(writer.document, metadata) if pdfa_requested?
+        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|
-          render_spread_pages(writer, spread, base_dir, layer_filter,
-                              font_ref_resolver, font_name)
+          page_index = render_spread_pages(writer, spread, base_dir,
+                                           layer_filter, font_ref_resolver,
+                                           font_resource, font_metrics,
+                                           structure, page_index)
         end
 
+        structure.flush(writer)
         writer.build_structure if @tagged
         writer.subset_fonts! if @subset_fonts
         writer.write(@output_path)
@@ -41,126 +49,58 @@ module Idml
 
       private
 
+      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)
+                              font_ref_resolver, font_resource, font_metrics,
+                              structure, page_offset)
         pages = spread.spread.flat_map(&:page)
-        image_refs = collect_images(writer, spread, base_dir, layer_filter)
-        renderer = build_renderer(layer_filter, font_ref_resolver, font_name)
+        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_resource, font_metrics, structure: structure)
+        current = page_offset
 
         pages.each do |page|
+          current += 1
           dims = page_dimensions_for(page)
           canvas = writer.add_page(width: dims[:width], height: dims[:height])
           renderer.render(canvas, spread, page_width: dims[:width],
                                           page_height: dims[:height],
-                                          image_refs: image_refs)
+                                          image_refs: image_refs,
+                                          page_index: current)
         end
+        current
       end
 
-      def build_renderer(layer_filter, font_ref_resolver, font_name)
+      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,
+          structure: structure,
         )
       end
 
-      def collect_images(writer, spread, base_dir, layer_filter)
-        refs = []
-        spread.each_page_item do |item|
-          next unless layer_filter.visible?(item)
-
-          images_for_item(item).each do |img|
-            ref = register_image(writer, img, item, base_dir)
-            refs << ref if ref
-          end
-        end
-        refs
-      end
-
-      def images_for_item(item)
-        case item
-        when Idml::Elements::Rectangle, Idml::Elements::Polygon
-          item.image
-        else
-          []
-        end
-      end
-
-      def register_image(writer, image, parent, base_dir)
-        uri = image.resource_uri
-        return nil unless uri
-
-        existing = writer.image_name_for(uri)
-        return reuse_image(writer, existing, image, parent) if existing
-
-        load_new_image(writer, image, parent, base_dir, uri)
-      end
-
-      def reuse_image(_writer, name, image, parent)
-        { name: name, placement: compute_placement(image, parent),
-          clip_box: parent_clip_box(parent) }
-      end
-
-      def load_new_image(writer, image, parent, base_dir, uri)
-        path = Image.resolve_path(uri, base_dir: base_dir)
-        return nil unless File.exist?(path)
-
-        data = File.binread(path)
-        dims = image_dimensions(data)
-        return nil unless dims
-
-        name = writer.add_image(data: data)
-        writer.register_image_name(uri, name)
-        { name: name, placement: compute_placement(image, parent, dims[1]),
-          clip_box: parent_clip_box(parent) }
-      end
-
-      def parent_clip_box(parent)
-        return nil unless parent.geometric_bounds
-
-        Geometry.placement_rect(parent.geometric_bounds,
-                                parent.item_transform, DEFAULT_HEIGHT)
-      end
-
-      def image_dimensions(data)
-        format = Image.detect_format(data)
-        return nil unless format
-
-        if format == :png
-          Image.png_dimensions(data)
-        else
-          Image.jpeg_dimensions(data)
-        end
-      end
-
-      def compute_placement(image, parent, pixel_height = 100)
-        Image.compute_placement(
-          image_transform: parse_transform_safe(image.item_transform),
-          parent_transform: parse_transform_safe(parent.item_transform),
-          pixel_height: pixel_height,
-          page_height: DEFAULT_HEIGHT,
-        )
-      end
-
-      def parse_transform_safe(str)
-        Image.parse_transform(str) || Image.identity
-      end
-
       def page_dimensions_for(page)
         { width: page.width || DEFAULT_WIDTH,
           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
 
@@ -169,6 +109,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
 
@@ -184,8 +130,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,13 +9,15 @@ module Idml
     RenderContext = Struct.new(
       :item,
       :package,
-      :font_resolver,
+      :font_metrics,
       :font_ref_resolver,
       :color_resolver,
       :font_ps_name,
       :page_width,
       :page_height,
       :layer_filter,
+      :structure,
+      :page_index,
       keyword_init: true,
     )
   end

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/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,9 @@ module Idml
         end
         private_class_method :engine_render
 
+        # Emits one `canvas.text_lines` call per run, after shaping
+        # and line-breaking with real font metrics. 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(
@@ -105,6 +88,32 @@ module Idml
           baseline_y
         end
         private_class_method :render_run_lines
+
+        # 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?
+
+          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
+        end
+        private_class_method :build_rich_runs
       end
     end
   end

data/lib/idml/render/spread_renderer.rb

@@ -4,26 +4,30 @@ 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)
-        @font_resolver = font_resolver
+                     font_ref_resolver: nil, structure: nil)
+        @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
         @layer_filter = layer_filter
         @font_ref_resolver = font_ref_resolver
+        @structure = structure
       end
 
-      def render(canvas, spread, page_width:, page_height:, image_refs: [])
+      def render(canvas, spread, page_width:, page_height:, image_refs: [],
+                 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,
           page_width: page_width,
           page_height: page_height,
           layer_filter: @layer_filter,
+          structure: @structure,
+          page_index: page_index,
         }
 
         canvas.save_graphics_state do

data/lib/idml/render/structure_mapper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Maps IDML page-item classes to PDF structure types (PDF 1.7
+    # §14.8.4). Each visible page item becomes one structure element
+    # when tagged output is enabled.
+    #
+    # Mapping rationale:
+    #   TextFrame → P (paragraph)
+    #   Group     → Sect (section, contains children)
+    #   Table     → Table
+    #   Rectangle/Polygon with image → Figure
+    #   Rectangle/Polygon without image → Path (decorative shape)
+    #   GraphicLine → Path
+    #
+    # The PDF spec reserves lowercase for standard types; pdfrb's
+    # `add_element(type:)` accepts a Symbol which is serialised as
+    # `/Type`. We use Title-case Symbols to match the spec's typical
+    # spelling (P, Sect, Table, Figure, Path).
+    module StructureMapper
+      def self.type_for(item)
+        case item
+        when Idml::Elements::TextFrame then :P
+        when Idml::Elements::Group then :Sect
+        when Idml::Elements::Table then :Table
+        when Idml::Elements::GraphicLine then :Path
+        when Idml::Elements::Rectangle, Idml::Elements::Polygon
+          shape_type(item)
+        end
+      end
+
+      def self.shape_type(item)
+        image?(item) ? :Figure : :Path
+      end
+      private_class_method :shape_type
+
+      # Optional `Alt` text for Figure elements. IDML doesn't have a
+      # dedicated alt-text attribute on `<Image>`, but the parent
+      # page item's `Name` (if present) is a useful fallback.
+      def self.alt_for(item)
+        case item
+        when Idml::Elements::Rectangle, Idml::Elements::Polygon
+          image?(item) ? item.name : nil
+        end
+      end
+
+      def self.image?(item)
+        Array(item.image).any?
+      end
+      private_class_method :image?
+    end
+  end
+end

data/lib/idml/render/structure_tracker.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Allocates MCID integers per page and buffers structure-element
+    # registrations until `Pipeline` is ready to flush them. Created
+    # once per pipeline run; `enabled?` is false when `tagged:` was
+    # not requested, in which case every method is a no-op.
+    class StructureTracker
+      def initialize(enabled: false)
+        @enabled = enabled
+        @entries = []
+        @page_mcids = Hash.new(0)
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      # Returns the next MCID for the given page index. MCIDs are
+      # per-page in PDF (reset to 0 on each new page).
+      def next_mcid(page_index)
+        current = @page_mcids[page_index]
+        @page_mcids[page_index] = current + 1
+        current
+      end
+
+      def add(type, page_index:, mcid:, text: nil, alt: nil)
+        return unless @enabled
+
+        @entries << Entry.new(type, page_index, mcid, text, alt)
+      end
+
+      # Push buffered entries into the writer in registration order.
+      def flush(writer)
+        return unless @enabled
+
+        @entries.each do |entry|
+          writer.add_structure_element(entry.type, page_index: entry.page_index,
+                                                   mcid: entry.mcid,
+                                                   text: entry.text,
+                                                   alt: entry.alt)
+        end
+      end
+
+      Entry = Struct.new(:type, :page_index, :mcid, :text, :alt, keyword_init: true) do
+        def initialize(type, page_index, mcid, text, alt)
+          super(type: type, page_index: page_index, mcid: mcid,
+                text: text, alt: alt)
+        end
+      end
+      private_constant :Entry
+    end
+  end
+end

data/lib/idml/render.rb

@@ -15,6 +15,10 @@ module Idml
     autoload :StrokeStyle,         "#{__dir__}/render/stroke_style"
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
     autoload :Placement,           "#{__dir__}/render/placement"
+    autoload :ImageCollector,      "#{__dir__}/render/image_collector"
+    autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"
+    autoload :StructureMapper,     "#{__dir__}/render/structure_mapper"
+    autoload :PdfaPacket,          "#{__dir__}/render/pdfa_packet"
     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

data/lib/idml/text_engine.rb

@@ -5,8 +5,7 @@ module Idml
   # geometry and produces positioned glyphs using font metrics from
   # .ttf/.otf files. IDML-agnostic — works on any styled text.
   module TextEngine
-    autoload :FontMetrics,     "#{__dir__}/text_engine/font_metrics"
-    autoload :FontResolver,    "#{__dir__}/text_engine/font_resolver"
+    autoload :PdfrbFontMetrics, "#{__dir__}/text_engine/pdfrb_font_metrics"
     autoload :Shaper,          "#{__dir__}/text_engine/shaper"
     autoload :ShapedGlyph,     "#{__dir__}/text_engine/shaper"
     autoload :LineBreaker,     "#{__dir__}/text_engine/line_breaker"

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.2.9"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: fontisan
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
@@ -218,6 +204,8 @@ files:
 - TODO.pdf/75-pdf-metadata-from-xmp.md
 - TODO.pdf/76-tagged-pdf-structure.md
 - TODO.pdf/77-pdfa-xmp-output-intent.md
+- TODO.pdf/78-hyperlinks.md
+- TODO.pdf/79-bookmarks-outline.md
 - TODO.pdf/README.md
 - exe/idml
 - idml.gemspec
@@ -389,8 +377,10 @@ files:
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/gradient_resolver.rb
 - lib/idml/render/image.rb
+- lib/idml/render/image_collector.rb
 - lib/idml/render/layer_filter.rb
 - lib/idml/render/page_item_renderer.rb
+- lib/idml/render/pdfa_packet.rb
 - lib/idml/render/pdfrb_writer.rb
 - lib/idml/render/pipeline.rb
 - lib/idml/render/placement.rb
@@ -405,13 +395,14 @@ files:
 - lib/idml/render/spread_renderer.rb
 - lib/idml/render/story_threader.rb
 - lib/idml/render/stroke_style.rb
+- lib/idml/render/structure_mapper.rb
+- lib/idml/render/structure_tracker.rb
 - lib/idml/render/style_resolver.rb
 - lib/idml/text_engine.rb
 - lib/idml/text_engine/cjk_layout.rb
-- lib/idml/text_engine/font_metrics.rb
-- lib/idml/text_engine/font_resolver.rb
 - lib/idml/text_engine/justifier.rb
 - lib/idml/text_engine/line_breaker.rb
+- lib/idml/text_engine/pdfrb_font_metrics.rb
 - lib/idml/text_engine/shaper.rb
 - lib/idml/text_engine/vertical_layout.rb
 - lib/idml/validation.rb