idml 0.2.8 → 0.3.0

data/lib/idml/render/pipeline.rb

@@ -21,18 +21,24 @@ module Idml
 
       def call
         writer = PdfrbWriter.new
-        writer.set_info(default_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)
+        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_name, structure, page_index)
         end
 
+        structure.flush(writer)
         writer.build_structure if @tagged
         writer.subset_fonts! if @subset_fonts
         writer.write(@output_path)
@@ -41,113 +47,43 @@ 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_name, 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_name,
+                                  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_name, structure:)
         SpreadRenderer.new(
           font_resolver: @font_resolver,
           font_ps_name: font_name,
           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 }
@@ -190,6 +126,46 @@ module Idml
         nil
       end
 
+      def combined_metadata
+        defaults = default_metadata
+        xmp_metadata.each do |key, value|
+          next if value.nil? || value.empty?
+
+          defaults[key] = value
+        end
+        defaults
+      end
+
+      def xmp_metadata
+        return {} unless @package.has_part?(XMP_PATH)
+
+        xml = @package.read_part(XMP_PATH)
+        meta = Parts::XmpMeta.from_xml(xml)
+        rdf = meta.rdf
+        return {} unless rdf
+
+        {
+          Title: rdf.title,
+          Author: rdf.author,
+          Subject: rdf.description,
+          Keywords: rdf.keywords,
+          Creator: rdf.creator_tool,
+          CreationDate: pdf_date_string(rdf.create_date),
+          ModDate: pdf_date_string(rdf.modify_date),
+        }
+      rescue StandardError
+        {}
+      end
+
+      def pdf_date_string(iso8601)
+        return nil unless iso8601
+
+        time = Time.iso8601(iso8601)
+        pdf_date(time)
+      rescue ArgumentError
+        nil
+      end
+
       def default_metadata
         {
           Producer: "idml gem v#{Idml::VERSION}",
@@ -200,6 +176,9 @@ module Idml
       def pdf_date(time)
         time.strftime("D:%Y%m%d%H%M%S+00'00'")
       end
+
+      XMP_PATH = "META-INF/metadata.xml"
+      private_constant :XMP_PATH
     end
   end
 end

data/lib/idml/render/render_context.rb

@@ -16,6 +16,8 @@ module Idml
       :page_width,
       :page_height,
       :layer_filter,
+      :structure,
+      :page_index,
       keyword_init: true,
     )
   end

data/lib/idml/render/spread_renderer.rb

@@ -6,15 +6,17 @@ module Idml
     class SpreadRenderer
       def initialize(font_resolver: nil, font_ps_name: Render::DEFAULT_FONT,
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
-                     font_ref_resolver: nil)
+                     font_ref_resolver: nil, structure: nil)
         @font_resolver = font_resolver
         @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,
@@ -24,6 +26,8 @@ module Idml
           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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose
@@ -218,6 +218,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
@@ -381,6 +383,7 @@ files:
 - lib/idml/parts/style.rb
 - lib/idml/parts/style_mapping.rb
 - lib/idml/parts/tags.rb
+- lib/idml/parts/xmp.rb
 - lib/idml/render.rb
 - lib/idml/render/blending.rb
 - lib/idml/render/color_helper.rb
@@ -388,8 +391,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
@@ -404,6 +409,8 @@ 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