idml 0.1.0

data/lib/idml/render/pipeline.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Top-level pipeline: IDML Package → PDF file using pdfrb.
+    # All PDF assembly is delegated to Pdfrb::Document. Renderers
+    # receive a Pdfrb::Content::Canvas and call drawing methods.
+    class Pipeline
+      DEFAULT_WIDTH = 612
+      DEFAULT_HEIGHT = 792
+
+      def initialize(package, output_path, font_search_paths = nil,
+                     compliance: nil)
+        @package = package
+        @output_path = output_path
+        @font_resolver = build_font_resolver(font_search_paths)
+        @compliance = compliance
+      end
+
+      def call
+        writer = PdfrbWriter.new
+        writer.set_info(default_metadata)
+        layer_filter = LayerFilter.from_designmap(@package.designmap)
+        font_ref_resolver = FontReferenceResolver.build(@package)
+        base_dir = File.dirname(@package.path)
+        font_name = register_font(writer)
+
+        @package.spreads.each do |spread|
+          render_spread_pages(writer, spread, base_dir, layer_filter,
+                              font_ref_resolver, font_name)
+        end
+
+        writer.write(@output_path)
+        @output_path
+      end
+
+      private
+
+      def render_spread_pages(writer, spread, base_dir, layer_filter,
+                              font_ref_resolver, font_name)
+        pages = spread.spread.flat_map(&:page)
+        image_refs = collect_images(writer, spread, base_dir, layer_filter)
+
+        pages.each do |page|
+          dims = page_dimensions_for(page)
+          canvas = writer.add_page(width: dims[:width], height: dims[:height])
+          renderer = SpreadRenderer.new(
+            font_resolver: @font_resolver,
+            font_ps_name: font_name,
+            package: @package,
+            layer_filter: layer_filter,
+            font_ref_resolver: font_ref_resolver,
+          )
+          renderer.render(canvas, spread, page_width: dims[:width],
+                                          page_height: dims[:height],
+                                          image_refs: image_refs)
+        end
+      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)
+      end
+
+      def register_font(writer)
+        return Render::DEFAULT_FONT unless @font_resolver
+
+        path = resolve_document_font_path
+        return Render::DEFAULT_FONT unless path
+
+        writer.register_font(path)
+      rescue StandardError
+        Render::DEFAULT_FONT
+      end
+
+      def resolve_document_font_path
+        return nil unless @package&.fonts
+
+        @package.fonts.font_family.each do |family|
+          path = find_font_file(family)
+          return path if path
+        end
+        nil
+      end
+
+      def find_font_file(family)
+        family.font.each do |font|
+          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
+        end
+        nil
+      end
+
+      def default_metadata
+        {
+          Producer: "idml gem v#{Idml::VERSION}",
+          CreationDate: pdf_date(Time.now.utc),
+        }
+      end
+
+      def pdf_date(time)
+        time.strftime("D:%Y%m%d%H%M%S+00'00'")
+      end
+    end
+  end
+end

data/lib/idml/render/render_context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Shared state passed to every page-item renderer. Carries the
+    # package (for story/color lookups), font/color resolvers, the
+    # current font's PostScript name, and page dimensions. Renderers
+    # are pure functions of this context + the page item.
+    RenderContext = Struct.new(
+      :item,
+      :package,
+      :font_resolver,
+      :font_ref_resolver,
+      :color_resolver,
+      :font_ps_name,
+      :page_width,
+      :page_height,
+      :layer_filter,
+      keyword_init: true,
+    )
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      class GraphicLineRenderer
+        def self.render(canvas, context)
+          line = context.item
+          return unless RectangleRenderer.strokeable?(line)
+
+          color = context.color_resolver&.resolve(line.stroke_color)
+          return unless color
+
+          box = RectangleRenderer.placement_box(line, context.page_height)
+          return unless box
+
+          canvas.save_graphics_state do
+            canvas.stroke_color(ColorHelper.to_canvas(color))
+            canvas.line_width = line.stroke_weight
+            canvas.move_to(box[:x], box[:y] + box[:height])
+            canvas.line_to(box[:x] + box[:width], box[:y])
+            canvas.stroke
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      class GroupRenderer
+        def self.render(canvas, context)
+          group = context.item
+          canvas.save_graphics_state do
+            apply_transform(canvas, group.item_transform)
+            group.each_page_item do |child|
+              next unless context.layer_filter&.visible?(child)
+
+              child_context = Render::RenderContext.new(
+                item: child,
+                package: context.package,
+                font_resolver: context.font_resolver,
+                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,
+              )
+              PageItemRenderer.render(canvas, child_context)
+            end
+          end
+        end
+
+        def self.apply_transform(canvas, item_transform)
+          return unless item_transform
+
+          t = Geometry.parse_transform(item_transform)
+          return unless t
+
+          canvas.concat(t.a, t.b, t.c, t.d, t.e, t.f)
+        end
+        private_class_method :apply_transform
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      class PolygonRenderer
+        def self.render(canvas, context)
+          poly = context.item
+          return if poly.visible == false
+
+          box = RectangleRenderer.placement_box(poly, context.page_height)
+          return unless box
+
+          canvas.save_graphics_state do
+            render_fill(canvas, poly, context, box)
+            render_stroke(canvas, poly, context, box)
+          end
+        end
+
+        def self.render_fill(canvas, poly, context, box)
+          return unless poly.fill_color && poly.fill_color != "Color/None"
+
+          color = context.color_resolver&.resolve(poly.fill_color)
+          return unless color
+
+          canvas.fill_color(ColorHelper.to_canvas(color))
+          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+          canvas.fill
+        end
+        private_class_method :render_fill
+
+        def self.render_stroke(canvas, poly, context, box)
+          return unless RectangleRenderer.strokeable?(poly)
+
+          color = context.color_resolver&.resolve(poly.stroke_color)
+          return unless color
+
+          canvas.stroke_color(ColorHelper.to_canvas(color))
+          canvas.line_width = poly.stroke_weight
+          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+          canvas.stroke
+        end
+        private_class_method :render_stroke
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      # Renders an IDML Rectangle on a Pdfrb::Content::Canvas.
+      class RectangleRenderer
+        def self.render(canvas, context)
+          rect = context.item
+          return if rect.visible == false
+
+          box = placement_box(rect, context.page_height)
+          return unless box
+
+          canvas.save_graphics_state do
+            render_fill(canvas, rect, context, box)
+            render_stroke(canvas, rect, context, box)
+          end
+        end
+
+        def self.placement_box(rect, page_height)
+          bounds = rect.geometric_bounds
+          return nil unless bounds
+
+          Geometry.placement_rect(bounds, rect.item_transform, page_height)
+        end
+
+        def self.render_fill(canvas, rect, context, box)
+          return unless rect.fill_color
+          return if rect.fill_color == "Color/None"
+
+          color = context.color_resolver&.resolve(rect.fill_color)
+          return unless color
+
+          canvas.fill_color(ColorHelper.to_canvas(color))
+          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+          canvas.fill
+        end
+        private_class_method :render_fill
+
+        def self.render_stroke(canvas, rect, context, box)
+          return unless strokeable?(rect)
+
+          color = context.color_resolver&.resolve(rect.stroke_color)
+          return unless color
+
+          canvas.stroke_color(ColorHelper.to_canvas(color))
+          canvas.line_width = rect.stroke_weight
+          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+          canvas.stroke
+        end
+        private_class_method :render_stroke
+
+        def self.strokeable?(rect)
+          rect.stroke_color &&
+            rect.stroke_color != "Color/None" &&
+            rect.stroke_weight&.positive?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      class TableRenderer
+        def self.render(canvas, context)
+          table = context.item
+          return if table.visible == false
+          return if table.table_row.empty?
+
+          box = RectangleRenderer.placement_box(table, context.page_height)
+          return unless box
+
+          row_count = table.table_row.length
+          row_height = box[:height] / row_count
+
+          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)
+            end
+          end
+        end
+
+        def self.render_row(canvas, row, row_index, row_count, box, row_height)
+          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|
+            cell_x = box[:x] + (cell_index * cell_width)
+            canvas.rectangle(cell_x, row_y, cell_width, row_height)
+            canvas.stroke
+          end
+        end
+        private_class_method :render_row
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+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.
+      class TextFrameRenderer
+        DEFAULT_SIZE = 12.0
+        LEADING_FACTOR = 1.2
+
+        def self.render(canvas, context)
+          frame = context.item
+          return unless frame.parent_story
+          return unless chain_head?(frame)
+
+          story = context.package&.story_by_id(frame.parent_story)
+          return unless story
+
+          runs = StyleResolver.extract_runs(story)
+          return if runs.empty?
+
+          box = frame_box(frame, context.page_height)
+          render_text(canvas, runs, context, box)
+        end
+
+        def self.render_text(canvas, runs, context, box)
+          font = resolve_font_metrics(context)
+          if font
+            engine_render(canvas, runs, context, box, font)
+          else
+            simple_render(canvas, runs, context, box)
+          end
+        end
+        private_class_method :render_text
+
+        def self.chain_head?(frame)
+          frame.previous_text_frame.nil? || frame.previous_text_frame == "n"
+        end
+        private_class_method :chain_head?
+
+        def self.frame_box(frame, page_height)
+          bounds = frame.geometric_bounds
+          unless bounds
+            return { x: 72.0, y: page_height - 72.0, width: 400.0,
+                     height: 600.0 }
+          end
+
+          transform = Geometry.parse_transform(frame.item_transform)
+          transformed = Geometry.transform_bounds(bounds, transform)
+          Geometry.bounds_to_pdf_rect(transformed, page_height)
+        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
+
+          runs.each do |run|
+            baseline_y = render_run_lines(
+              canvas, run, context, box, font, baseline_y
+            )
+          end
+        end
+        private_class_method :engine_render
+
+        def self.render_run_lines(canvas, run, context, box, font, baseline_y)
+          size = run.point_size
+          glyphs = TextEngine::Shaper.shape(
+            text: run.text, font: font, size: size,
+          )
+          lines = TextEngine::LineBreaker.break(
+            glyphs: glyphs, frame_width: box[:width],
+          )
+
+          lines.each do |line|
+            break if baseline_y < box[:y]
+
+            line_text = line.glyphs.map { |g| [g.codepoint].pack("U") }.join
+            canvas.text(line_text, at: [box[:x], baseline_y],
+                                   font: context.font_ps_name,
+                                   size: size)
+            baseline_y -= size * LEADING_FACTOR
+          end
+          baseline_y
+        end
+        private_class_method :render_run_lines
+      end
+    end
+  end
+end

data/lib/idml/render/renderers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Namespace for per-type page-item renderers. Each class has a
+    # `self.render(context)` class method that returns a string of PDF
+    # content-stream operators (or nil to skip the item).
+    module Renderers
+    end
+  end
+end

data/lib/idml/render/spread_renderer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+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,
+                     package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
+                     font_ref_resolver: nil)
+        @font_resolver = font_resolver
+        @font_ps_name = font_ps_name
+        @package = package
+        @layer_filter = layer_filter
+        @font_ref_resolver = font_ref_resolver
+      end
+
+      def render(canvas, spread, page_width:, page_height:, image_refs: [])
+        context_base = {
+          package: @package,
+          font_resolver: @font_resolver,
+          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,
+        }
+
+        canvas.save_graphics_state do
+          render_background(canvas, page_width, page_height)
+          render_images(canvas, image_refs)
+          render_master_items(canvas, spread, context_base)
+          spread.each_page_item do |item|
+            next unless @layer_filter.visible?(item)
+
+            context = RenderContext.new(context_base.merge(item: item))
+            PageItemRenderer.render(canvas, context)
+          end
+        end
+      end
+
+      private
+
+      def render_background(canvas, width, height)
+        canvas.fill_color([:gray, 1.0])
+        canvas.rectangle(0, 0, width, height)
+        canvas.fill
+      end
+
+      def render_images(canvas, image_refs)
+        return if image_refs.empty?
+
+        image_refs.each do |ref|
+          placement = ref[:placement]
+          canvas.save_graphics_state do
+            apply_image_clip(canvas, ref)
+            canvas.concat(placement[:scale_x], 0, 0, placement[:scale_y],
+                          placement[:x], placement[:y])
+            canvas.emit_op(PdfrbExt::InvokeXObject, ref[:name])
+          end
+        end
+      end
+
+      def apply_image_clip(canvas, ref)
+        clip_box = ref[:clip_box]
+        return unless clip_box
+
+        canvas.rectangle(clip_box[:x], clip_box[:y],
+                         clip_box[:width], clip_box[:height])
+        canvas.emit_op(PdfrbExt::Clip)
+        canvas.emit_op(PdfrbExt::EndPath)
+      end
+
+      def render_master_items(canvas, spread, context_base)
+        return unless @package
+
+        resolve_master_spreads(spread).each do |master|
+          render_master_page_items(canvas, master, context_base)
+        end
+      end
+
+      def resolve_master_spreads(spread)
+        masters = []
+        spread.spread.flat_map(&:page).each do |page|
+          next unless page.applied_master
+
+          master = @package.master_spread_by_id(page.applied_master)
+          masters << master if master && !masters.include?(master)
+        end
+        masters
+      end
+
+      def render_master_page_items(canvas, master_part, context_base)
+        master_part.master_spread.each do |master_so|
+          master_so.each_page_item do |item|
+            next unless @layer_filter.visible?(item)
+
+            context = RenderContext.new(context_base.merge(item: item))
+            PageItemRenderer.render(canvas, context)
+          end
+        end
+      end
+
+      def build_color_resolver
+        return nil unless @package&.graphic
+
+        ColorResolver.new(@package.graphic)
+      end
+    end
+  end
+end