idml 0.1.0

data/lib/idml/render/story_threader.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Builds text frame chains from PreviousTextFrame/NextTextFrame
+    # links. A story flows across linked frames: the first frame gets
+    # lines that fit, overflow goes to the next frame, and so on.
+    class StoryThreader
+      Thread = Struct.new(:story_id, :frames, keyword_init: true)
+
+      def self.build_chains(spread)
+        chains = []
+        return chains unless spread
+
+        frames_by_id = collect_text_frames(spread)
+        frames_by_id.each_value do |frame|
+          next unless chain_head?(frame)
+
+          chains << build_chain(frame, frames_by_id)
+        end
+        chains
+      end
+
+      # A chain head has previous_text_frame == "n" (no predecessor).
+      def self.chain_head?(frame)
+        frame.previous_text_frame.nil? || frame.previous_text_frame == "n"
+      end
+      private_class_method :chain_head?
+
+      def self.build_chain(head, frames_by_id)
+        frames = []
+        current = head
+        while current && !frames.include?(current)
+          frames << current
+          next_id = current.next_text_frame
+          break if next_id.nil? || next_id == "n"
+
+          current = frames_by_id[next_id]
+        end
+        Thread.new(story_id: head.parent_story, frames: frames)
+      end
+      private_class_method :build_chain
+
+      def self.collect_text_frames(spread)
+        result = {}
+        spread.each_page_item do |item|
+          next unless item.is_a?(Idml::Elements::TextFrame)
+
+          result[item.self_attr] = item
+        end
+        result
+      end
+      private_class_method :collect_text_frames
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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).
+    class StyleResolver
+      StyledRun = Struct.new(
+        :text, :font_style, :point_size,
+        :fill_color, :fill_tint, :applied_font, keyword_init: true
+      )
+
+      DEFAULT_POINT_SIZE = 12.0
+
+      def self.extract_runs(story)
+        return [] unless story&.inner
+
+        story.inner.paragraph_style_range.flat_map do |psr|
+          csr_runs(psr)
+        end
+      end
+
+      def self.csr_runs(psr)
+        psr.character_style_range.filter_map do |csr|
+          text = csr.text_content
+          next if text.nil? || text.empty?
+
+          StyledRun.new(
+            text: text,
+            font_style: csr.font_style,
+            point_size: csr.point_size || DEFAULT_POINT_SIZE,
+            fill_color: csr.fill_color,
+            fill_tint: csr.fill_tint,
+            applied_font: csr.applied_font,
+          )
+        end
+      end
+      private_class_method :csr_runs
+
+      # 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)
+        runs.map(&:text).join
+      end
+    end
+  end
+end

data/lib/idml/render/text.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# DEPRECATED: This module is superseded by Canvas#text method.
+# Text rendering is now handled by pdfrb's Canvas API.
+
+module Idml
+  module Render
+    # Converts positioned glyphs to PDF text-showing operators.
+    module Text
+      module_function
+
+      # Begin text block
+      def begin_text
+        "BT"
+      end
+
+      # End text block
+      def end_text
+        "ET"
+      end
+
+      # Set font: `/FontName size Tf`
+      def set_font(font_name, size)
+        format("/%<name>s %<size>.1f Tf", name: font_name, size: size)
+      end
+
+      # Move text position: `x y Td`
+      def move_to(x, y)
+        format("%<x>.2f %<y>.2f Td", x: x, y: y)
+      end
+
+      # Set text matrix: `a b c d e f Tm`
+      def set_matrix(a:, b:, c:, d:, e:, f:)
+        format("%<a>.4f %<b>.4f %<c>.4f %<d>.4f %<e>.2f %<f>.2f Tm",
+               a: a, b: b, c: c, d: d, e: e, f: f)
+      end
+
+      # Show a text string: `(escaped) Tj`
+      def show(text_string)
+        "(#{escape(text_string)}) Tj"
+      end
+
+      # Build a complete text-showing block for a run of glyphs
+      # at the same font/size, positioned at (x, y).
+      def show_run(text_string:, font_name:, size:, x:, y:)
+        [
+          begin_text,
+          set_font(font_name, size),
+          move_to(x, y),
+          show(text_string),
+          end_text,
+        ].join("\n")
+      end
+
+      # Emit positioned glyphs. Groups glyphs by y coordinate into
+      # lines, sets the text matrix per-line for absolute positioning,
+      # then shows the line text. Multiple lines within one BT/ET block.
+      def show_positioned(glyphs)
+        return "" if glyphs.empty?
+
+        lines = group_by_line(glyphs)
+        lines.map do |line|
+          [
+            set_matrix(a: 1, b: 0, c: 0, d: 1,
+                       e: line.first.x, f: line.first.y),
+            show(line.map { |g| [g.codepoint].pack("U") }.join),
+          ].join("\n")
+        end.join("\n")
+      end
+
+      def group_by_line(glyphs)
+        result = []
+        current = nil
+        glyphs.each do |glyph|
+          if current.nil? || current.first.y != glyph.y
+            current = []
+            result << current
+          end
+          current << glyph
+        end
+        result
+      end
+      private_class_method :group_by_line
+
+      # Escape characters that are special in PDF strings.
+      def escape(str)
+        str.to_s.gsub("\\", "\\\\\\\\").gsub("(", "\\(").gsub(")", "\\)")
+      end
+    end
+  end
+end

data/lib/idml/render.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "pdfrb"
+
+module Idml
+  module Render
+    autoload :Color,            "#{__dir__}/render/color"
+    autoload :ColorHelper,      "#{__dir__}/render/color_helper"
+    autoload :Path,             "#{__dir__}/render/path"
+    autoload :Text,             "#{__dir__}/render/text"
+    autoload :Image,            "#{__dir__}/render/image"
+    autoload :FontEmbedder,     "#{__dir__}/render/font_embedder"
+    autoload :PdfrbWriter,      "#{__dir__}/render/pdfrb_writer"
+    autoload :PdfrbExt,         "#{__dir__}/render/pdfrb_ext"
+    autoload :Text,             "#{__dir__}/render/text"
+    autoload :Image,            "#{__dir__}/render/image"
+    autoload :FontEmbedder,     "#{__dir__}/render/font_embedder"
+    autoload :ColorResolver,    "#{__dir__}/render/color_resolver"
+    autoload :StyleResolver,    "#{__dir__}/render/style_resolver"
+    autoload :FontReferenceResolver,
+             "#{__dir__}/render/font_reference_resolver"
+    autoload :GradientResolver, "#{__dir__}/render/gradient_resolver"
+    autoload :LayerFilter,      "#{__dir__}/render/layer_filter"
+    autoload :StoryThreader,    "#{__dir__}/render/story_threader"
+    autoload :PdfWriter,        "#{__dir__}/render/pdf_writer"
+    autoload :SpreadRenderer,   "#{__dir__}/render/spread_renderer"
+    autoload :Pipeline,         "#{__dir__}/render/pipeline"
+    autoload :RenderContext,    "#{__dir__}/render/render_context"
+    autoload :PageItemRenderer, "#{__dir__}/render/page_item_renderer"
+    autoload :Renderers,        "#{__dir__}/render/renderers"
+
+    DEFAULT_FONT = "Helvetica"
+
+    def self.render(package:, to:, font_search_paths: nil, compliance: nil)
+      Pipeline.new(package, to, font_search_paths, compliance: compliance).call
+    end
+  end
+end
+
+Idml::Render::Renderers.autoload(
+  :RectangleRenderer,
+  "#{__dir__}/render/renderers/rectangle_renderer",
+)
+Idml::Render::Renderers.autoload(
+  :TextFrameRenderer,
+  "#{__dir__}/render/renderers/text_frame_renderer",
+)
+Idml::Render::Renderers.autoload(
+  :PolygonRenderer,
+  "#{__dir__}/render/renderers/polygon_renderer",
+)
+Idml::Render::Renderers.autoload(
+  :GraphicLineRenderer,
+  "#{__dir__}/render/renderers/graphic_line_renderer",
+)
+Idml::Render::Renderers.autoload(
+  :GroupRenderer,
+  "#{__dir__}/render/renderers/group_renderer",
+)
+Idml::Render::Renderers.autoload(
+  :TableRenderer,
+  "#{__dir__}/render/renderers/table_renderer",
+)

data/lib/idml/text_engine/cjk_layout.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Idml
+  module TextEngine
+    # CJK text layout utilities: character classification, kinsoku
+    # shori (line-breaking rules), and vertical writing-mode helpers.
+    module CjkLayout
+      module_function
+
+      CJK_RANGES = [
+        0x3000..0x303F, # CJK Symbols and Punctuation
+        0x3040..0x309F, # Hiragana
+        0x30A0..0x30FF, # Katakana
+        0x3400..0x4DBF, # CJK Extension A
+        0x4E00..0x9FFF, # CJK Unified Ideographs
+        0xAC00..0xD7AF, # Hangul Syllables
+        0xF900..0xFAFF, # CJK Compatibility Ideographs
+        0xFF00..0xFFEF, # Halfwidth and Fullwidth Forms
+      ].freeze
+
+      # Characters forbidden at line start (kinsoku shori).
+      FORBIDDEN_LINE_START = %w[
+        、 。， ． ｡ ： ； ？ ｿ ﾞ ﾟ ! ！ ” 〉 》 」 』 】
+        〕 ｝ ） ｣ ゛ ゝ ゞ 〃 々 〆 〇 ー 〜
+        ぁ ぃ ぅ ぇ ぉ っ ゃ ゅ ょ ゎ
+        ァ ィ ゥ ェ ォ ッ ャ ュ ョ ヮ
+        ぁ ぃ ぅ ぇ ぉ
+      ].map(&:codepoints).flatten.freeze
+
+      # Characters forbidden at line end (kinsoku shori).
+      FORBIDDEN_LINE_END = %w[
+        “ 〈 《 「 『 【 〔 ｛ （ ｢
+      ].map(&:codepoints).flatten.freeze
+
+      def cjk?(codepoint)
+        CJK_RANGES.any? { |range| range.include?(codepoint) }
+      end
+
+      def forbidden_start?(codepoint)
+        FORBIDDEN_LINE_START.include?(codepoint)
+      end
+
+      def forbidden_end?(codepoint)
+        FORBIDDEN_LINE_END.include?(codepoint)
+      end
+
+      # Check if text contains any CJK characters.
+      def contains_cjk?(text)
+        text.each_codepoint.any? { |cp| cjk?(cp) }
+      end
+
+      # Apply kinsoku shori to an array of Line objects. Moves
+      # forbidden-start chars from the beginning of a line to the
+      # end of the previous line, and forbidden-end chars from the
+      # end of a line to the beginning of the next line.
+      def apply_kinsoku(lines)
+        return lines if lines.length < 2
+
+        result = [dup_line(lines.first)]
+        lines[1..].each do |line|
+          prev = result.last
+          curr = dup_line(line)
+          adjusted_prev, adjusted_current = adjust_boundary(prev, curr)
+          result[-1] = adjusted_prev
+          result << adjusted_current
+        end
+        result
+      end
+
+      def dup_line(line)
+        Line.new(line.glyphs.dup, line.width, line.x_offset)
+      end
+
+      # Adjust the boundary between two lines according to kinsoku rules.
+      def adjust_boundary(prev_line, current_line)
+        prev = dup_line(prev_line)
+        curr = dup_line(current_line)
+
+        # Move forbidden-start chars from current line start to prev line end.
+        until curr.glyphs.empty? || !forbidden_start?(curr.glyphs.first.codepoint)
+          moved = curr.glyphs.shift
+          prev.glyphs << moved
+          prev.width += moved.width
+          curr.width -= moved.width
+        end
+
+        # Move forbidden-end chars from prev line end to current line start.
+        until prev.glyphs.empty? || !forbidden_end?(prev.glyphs.last.codepoint)
+          moved = prev.glyphs.pop
+          prev.width -= moved.width
+          curr.glyphs.unshift(moved)
+          curr.width += moved.width
+        end
+
+        [prev, curr]
+      end
+
+      # Detect if a codepoint is a CJK full-width digit (０-９).
+      def fullwidth_digit?(codepoint)
+        codepoint.between?(0xFF10, 0xFF19)
+      end
+
+      # Tate-Chu-Yoko candidate: 1-2 digit horizontal runs in vertical text.
+      def tate_chu_yoko?(codepoint)
+        codepoint.between?(0x30, 0x39) || fullwidth_digit?(codepoint)
+      end
+
+      # Check if a StoryOrientation value indicates vertical writing.
+      def vertical_mode?(orientation)
+        ["TopToBottom", "RightToLeftTopToBottom"].include?(orientation)
+      end
+    end
+  end
+end

data/lib/idml/text_engine/font_metrics.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "fontisan"
+
+module Idml
+  module TextEngine
+    # Reads OpenType/TrueType font metrics via Fontisan. Uses Fontisan's
+    # FontLoader to open the font file and locate table offsets, then
+    # parses the head, hhea, hmtx, and cmap tables directly from the
+    # binary. No ttfunk.
+    class FontMetrics
+      @cache = {}
+
+      def self.open(path)
+        @cache[path] ||= new(path)
+      end
+
+      def self.clear_cache
+        @cache.clear
+      end
+
+      def initialize(path)
+        @path = path
+        @font = Fontisan::FontLoader.load(path)
+        @io = File.open(path, "rb")
+        parse_head
+        parse_hhea
+        parse_hmtx
+        parse_cmap
+        @width_cache = {}
+      end
+
+      attr_reader :units_per_em, :ascent, :descent, :line_gap, :path
+
+      def glyph_width(codepoint)
+        @width_cache[codepoint] ||=
+          begin
+            glyph_id = @code_map[codepoint] || 0
+            metric = @advance_widths[glyph_id]
+            metric || @advance_widths.last || 0
+          end
+      end
+
+      def kerning_pair(_left_cp, _right_cp)
+        0
+      end
+
+      def measure_text(text, size:)
+        total = 0
+        text.each_codepoint { |cp| total += glyph_width(cp) }
+        total.to_f / units_per_em * size
+      end
+
+      def postscript_name
+        @postscript_name ||= parse_name_entry(6) || "Unknown"
+      end
+
+      def family_name
+        @family_name ||= parse_name_entry(1) || "Unknown"
+      end
+
+      def style_name
+        @style_name ||= parse_name_entry(2) || "Regular"
+      end
+
+      private
+
+      def find_table(tag)
+        @font.tables.find { |entry| entry.tag == tag }
+      end
+
+      def read_table_bytes(tag)
+        entry = find_table(tag)
+        return nil unless entry
+
+        @io.seek(entry.offset)
+        @io.read(entry.table_length)
+      end
+
+      def parse_head
+        data = read_table_bytes("head")
+        return unless data
+
+        @units_per_em = data[18, 2].unpack1("n")
+      end
+
+      def parse_hhea
+        data = read_table_bytes("hhea")
+        return unless data
+
+        @ascent = sign_extend(data[4, 2].unpack1("n"))
+        @descent = sign_extend(data[6, 2].unpack1("n"))
+        @line_gap = sign_extend(data[8, 2].unpack1("n"))
+        @num_hmetrics = data[34, 2].unpack1("n")
+      end
+
+      def parse_hmtx
+        data = read_table_bytes("hmtx")
+        return unless data
+
+        @advance_widths = []
+        @num_hmetrics.times do |i|
+          offset = i * 4
+          @advance_widths[i] = data[offset, 2].unpack1("n")
+        end
+      end
+
+      def parse_cmap
+        data = read_table_bytes("cmap")
+        return unless data
+
+        _, num_subtables = data[0, 4].unpack("nn")
+        @code_map = {}
+
+        best_offset = nil
+        num_subtables.times do |i|
+          rec_off = 4 + (i * 4)
+          platform_id, encoding_id, offset = data[rec_off, 8].unpack("nnN")
+          if platform_id == 3 && encoding_id == 1
+            best_offset = offset
+            break
+          end
+          best_offset ||= offset if platform_id.zero?
+        end
+        return unless best_offset
+
+        parse_cmap_subtable(data, best_offset)
+      end
+
+      def parse_cmap_subtable(data, offset)
+        format = data[offset, 2].unpack1("n")
+        parse_cmap_format4(data, offset) if format == 4
+        parse_cmap_format0(data, offset) if format.zero?
+      end
+
+      def sign_extend(uint16)
+        uint16 >= 32768 ? uint16 - 65536 : uint16
+      end
+
+      def parse_cmap_format4(data, offset)
+        seg_count_x2 = data[offset + 6, 2].unpack1("n")
+        seg_count = seg_count_x2 / 2
+
+        end_start = offset + 14
+        start_start = end_start + seg_count_x2 + 2
+        delta_start = start_start + seg_count_x2
+        range_start = delta_start + seg_count_x2
+
+        seg_count.times do |i|
+          end_code = data[end_start + (i * 2), 2].unpack1("n")
+          start_code = data[start_start + (i * 2), 2].unpack1("n")
+          delta = sign_extend(data[delta_start + (i * 2), 2].unpack1("n"))
+          range_off = data[range_start + (i * 2), 2].unpack1("n")
+
+          (start_code..end_code).each do |cp|
+            if range_off.zero?
+              glyph_id = (cp + delta) & 0xFFFF
+            else
+              idx = range_start + (i * 2) + range_off + ((cp - start_code) * 2)
+              glyph_id = data[idx, 2].unpack1("n")
+              glyph_id = (glyph_id + delta) & 0xFFFF if glyph_id != 0
+            end
+            @code_map[cp] = glyph_id if glyph_id != 0
+          end
+        end
+      end
+
+      def parse_cmap_format0(data, offset)
+        256.times do |cp|
+          glyph_id = data[offset + 6 + cp, 1].unpack1("C")
+          @code_map[cp] = glyph_id if glyph_id != 0
+        end
+      end
+
+      def parse_name_entry(name_id)
+        data = read_table_bytes("name")
+        return nil unless data
+
+        _format, count, string_offset = data[0, 6].unpack("nnn")
+        best = nil
+        best_priority = 99
+        count.times do |i|
+          rec = 6 + (i * 12)
+          platform_id, encoding_id, _lang_id, id, length, str_off =
+            data[rec, 12].unpack("nnnnnn")
+          next unless id == name_id
+
+          priority = name_platform_priority(platform_id, encoding_id)
+          next if priority >= best_priority
+
+          raw = data[string_offset + str_off, length]
+          decoded = decode_name_string(raw, platform_id)
+          next unless decoded && !decoded.empty?
+
+          best = decoded
+          best_priority = priority
+        end
+        best
+      end
+
+      # Prefer Windows (platform 3, encoding 1) name records, then
+      # any Windows record, then Macintosh, then Unicode.
+      def name_platform_priority(platform_id, encoding_id)
+        case platform_id
+        when 3 then encoding_id == 1 ? 0 : 1
+        when 0 then 3
+        when 1 then 2
+        else 4
+        end
+      end
+
+      def decode_name_string(raw, platform_id)
+        result =
+          case platform_id
+          when 3, 0
+            raw.encode("UTF-8", "UTF-16BE", invalid: :replace, undef: :replace)
+          when 1
+            raw.encode("UTF-8", "MacRoman", invalid: :replace, undef: :replace)
+          else
+            raw.dup.force_encoding("UTF-8").scrub("")
+          end
+        result.strip
+      end
+    end
+  end
+end

data/lib/idml/text_engine/font_resolver.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Idml
+  module TextEngine
+    # Maps IDML font references (family + style name) to .ttf/.otf
+    # file paths on disk via Fontisan. Searches system font dirs and
+    # any user-configured search paths.
+    class FontResolver
+      DEFAULT_SEARCH_PATHS = [
+        "/System/Library/Fonts",
+        "/Library/Fonts",
+        File.expand_path("~/Library/Fonts"),
+        "/usr/share/fonts",
+        File.expand_path("~/.local/share/fonts"),
+      ].freeze
+
+      STYLE_ALIASES = {
+        "Regular" => %w[Regular Normal Book Roman Medium],
+        "Bold" => %w[Bold Semibold Heavy Black],
+        "Italic" => %w[Italic Oblique Slanted],
+        "Bold Italic" => %w[Bold\ Italic BoldOblique SemiboldItalic],
+      }.freeze
+
+      def initialize(search_paths: DEFAULT_SEARCH_PATHS)
+        @search_paths = search_paths
+        @cache = {}
+      end
+
+      def resolve(family_name:, style_name: "Regular")
+        key = [family_name, style_name]
+        @cache[key] ||= find_font(family_name, style_name)
+      end
+
+      # Search by PostScriptName (e.g., "MinionPro-Regular").
+      # More precise than family+style — maps directly to the font's
+      # internal PostScript name. Used when the IDML document references
+      # a specific PostScriptName from Fonts.xml.
+      def resolve_by_ps_name(ps_name)
+        return nil unless ps_name
+
+        @ps_cache ||= {}
+        return @ps_cache[ps_name] if @ps_cache.key?(ps_name)
+
+        @ps_cache[ps_name] = find_by_ps_name(ps_name)
+      end
+
+      private
+
+      def find_by_ps_name(ps_name)
+        @search_paths.each do |dir|
+          next unless Dir.exist?(dir)
+
+          Dir.glob(File.join(dir, "**", "*.ttf")).each do |path|
+            font = safe_load(path)
+            next unless font
+
+            return FontMetrics.open(path) if font.postscript_name == ps_name
+          end
+          Dir.glob(File.join(dir, "**", "*.otf")).each do |path|
+            font = safe_load(path)
+            next unless font
+
+            return FontMetrics.open(path) if font.postscript_name == ps_name
+          end
+        end
+        nil
+      end
+
+      def find_font(family, style)
+        candidates = STYLE_ALIASES[style] || [style]
+        @search_paths.each do |dir|
+          next unless Dir.exist?(dir)
+
+          Dir.glob(File.join(dir, "**", "*.ttf")).each do |path|
+            font = safe_load(path)
+            next unless font
+
+            return FontMetrics.open(path) if matches?(font, family, candidates)
+          end
+          Dir.glob(File.join(dir, "**", "*.otf")).each do |path|
+            font = safe_load(path)
+            next unless font
+
+            return FontMetrics.open(path) if matches?(font, family, candidates)
+          end
+        end
+        nil
+      end
+
+      def matches?(font, family, style_candidates)
+        return false unless font.family_name.match?(/#{Regexp.escape(family)}/i)
+
+        style_candidates.any? do |s|
+          font.style_name.match?(/#{Regexp.escape(s)}/i)
+        end
+      end
+
+      def safe_load(path)
+        FontMetrics.open(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end