idml 0.10.8 → 0.10.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05a75aaa533dcd8f478d6b4ab635d15cf6c64ac85bebbd42fe3b136ed0c6783
-  data.tar.gz: 3a478cdb4b23ac26ceb9914d5e3740286ef6fda60c80605a01dc6f2a38086b7a
+  metadata.gz: c3ebdf83496770ecda7b37cc6f6cdc2388874785ccad23ac57aa396f76aef03b
+  data.tar.gz: d7304a209e09d4de3ee6d9f7556d18053f838ee3fef9a4f787f06693aa42ee32
 SHA512:
-  metadata.gz: effb89c7a3869aa7c268027e4653ecc2072fc41402d53ff2ad8ca0405862b83076bd82637cc9f64a369cd3ceb2ca23b2e6e9ca7ba300de2fd9f073801c65c199
-  data.tar.gz: 371206ab57061b8fa94733db6e489565eeb0cd588ffb6b0908a9a0c6e84fcec2d64745501dd8ec7b8147cb3044119c47d08f479e50cec26e939a35f5127ecf9e
+  metadata.gz: bd4dc75a85966131506edf7f3e01df91127fbf26525bb02edcf783f0c07580380be0d8bd38562c11a477602731e2efff8de78061580b471f1389f3bb87a07119
+  data.tar.gz: 74286965e709455a356789cc6f7e4c93f75d414a1132301ee8e347a85d114065bd1988921c180a522c646824d79f2049bdfacf7db609e9981b270d3a88b71fbb

data/TODO.pdf/145-apply-mojikumi-aki.md

@@ -0,0 +1,37 @@
+# TODO PDF 145: Apply mojikumi aki to layout
+
+## Status: COMPLETE — implemented 2026-08-28
+
+## Problem
+
+Two gaps: (a) `apply_script_spacing` (TODO 125) was implemented
+but never wired into the render pipeline — CJK/Latin auto spacing
+never actually applied; (b) the named mojikumi sets modeled in
+TODO 144 were parsed but unused.
+
+## Solution
+
+- `CjkLayout.apply_script_spacing` now takes the document's aki
+  overrides: when the designmap declares a `MojikumiTable`, each
+  adjacent glyph pair whose classes match an
+  `OverrideMojikumiAki` entry (Target/Side class ×
+  SideIsAfterTarget) gets that entry's Desired spacing (em ×
+  point size). Unlisted pairs keep the default eighth-em at
+  CJK/Latin script boundaries.
+- New `CjkLayout.mojikumi_class` classifies the seven InDesign
+  mojikumi classes (ideograph, opening bracket, closing bracket,
+  comma/period, middle dot, digit — incl. fullwidth, Latin —
+  incl. fullwidth).
+- `TextFrameRenderer#layout_run` applies the spacing between
+  shaping and line breaking, using
+  `mojikumi_aki_overrides(context)` (first named set from the
+  designmap; empty when absent).
+
+The result: documents declaring custom mojikumi now render their
+declared inter-class spacing.
+
+## Files
+
+- `lib/idml/text_engine/cjk_layout.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/text_engine/cjk_layout_spec.rb`

data/TODO.pdf/146-next-column-wrap.md

@@ -0,0 +1,25 @@
+# TODO PDF 146: NextColumn wrap behavior
+
+## Status: COMPLETE (approximation) — implemented 2026-08-28
+
+## Problem
+
+NextColumnTextWrap approximated as the bounding box (text narrowed
+beside the object). InDesign moves the text to the next COLUMN.
+
+## Solution
+
+NextColumnTextWrap now joins JumpObjectTextWrap in the jump path:
+the object blocks the full frame width and the run skips below
+the object's bottom edge. In a single-column frame this matches
+InDesign's visible outcome (the "next column" is below).
+
+Remaining approximation (documented in TODO.pdf/61): in a
+MULTI-column frame, true NextColumn jumps to the next column in
+the same frame — that needs column-jump chain integration, which
+stays a future enhancement.
+
+## Files
+
+- `lib/idml/render/text_wrap_resolver.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`

data/TODO.pdf/147-side-aware-shapes.md

@@ -0,0 +1,27 @@
+# TODO PDF 147: Side-aware Contour shapes
+
+## Status: COMPLETE — implemented 2026-08-28
+
+## Problem
+
+TextWrapSide applied only to BoundingBoxTextWrap contours;
+Contour-mode shapes narrowed by polygon overlap regardless of
+side — text smeared over shapes at frame edges instead of
+flowing around the chosen side.
+
+## Solution
+
+`WrapContour::Shape` carries `side`; `wrap_adjustment`'s shape
+branch dispatches through the shared interval-based side logic
+using the polygon's bounding box: LeftSide keeps text left of the
+shape, RightSide shifts lines past its right edge, LargestArea
+picks the roomier side; BothSides (and spine variants) keep the
+exact polygon-overlap narrowing. Inverse shapes keep their
+flip-to-inside semantics. The side dispatch is now one shared
+`interval_side_adjustment` for boxes and shapes alike.
+
+## Files
+
+- `lib/idml/render/wrap_contour.rb`
+- `lib/idml/render/text_wrap_resolver.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`

data/TODO.pdf/61-known-limitations.md

@@ -1,6 +1,6 @@
 # TODO PDF 61: Known limitations and future work
 
-## Status: DOCUMENTED — refreshed 2026-08-27 (second refresh)
+## Status: DOCUMENTED — refreshed 2026-08-28
 
 Previously listed limitations (font embedding, tagged PDF, per-run
 styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
@@ -25,18 +25,19 @@ this list reflects the current state.
 - **StartParagraph** breaks act at frame/column granularity — no
   odd/even page parity.
 - **Text wrap**: BoundingBoxTextWrap, Contour, and Inverse modes
-  render (TODOs 130-131) with TextWrapSide side-awareness (TODO 138:
-  LeftSide / RightSide / LargestArea pick the flow side; spine
-  variants approximate as BothSides); JumpObject moves text below
-  the object (TODO 143); NextColumn approximates as the box;
-  Contour-mode shapes are not side-aware.
+  render (TODOs 130-131) with TextWrapSide side-awareness for both
+  box contours and Contour shapes (TODOs 138/147); JumpObject and
+  NextColumn move text below the object (TODOs 143/146) — NextColumn
+  in a MULTI-column frame should jump to the next column instead
+  (chain integration, future); spine variants approximate as
+  BothSides.
 
 ### CJK
-- **Mojikumi**: script spacing (TODO 125), line-end compression
-  (TODO 132), and class-based pair compression are applied; named
-  mojikumi sets are modeled (TODO 144: MojikumiTable +
-  OverrideMojikumiAki parse and round-trip) but not yet APPLIED to
-  layout — the built-in class-based aki rules stand in.
+- **Mojikumi**: script spacing (TODO 125, now actually wired),
+  line-end compression (TODO 132), class-based pair compression,
+  and named-set aki overrides (TODO 145: OverrideMojikumiAki
+  Desired applies per class pair) are applied; Minimum/Maximum
+  aki bounds and CompressionPriority are parsed but unused.
 - **Vertical mode**: Latin runs rotate as one group per segment
   (TODO 142); ruby placement is beside-column; keep options do
   not apply.
@@ -59,8 +60,7 @@ this list reflects the current state.
 ## Future enhancements
 
 - Hyphenation dictionary integration
-- Shape-mode text wrap contours (side-aware)
-- Apply named mojikumi sets to CJK layout (consume TODO 144's model)
-- NextColumn wrap via column-jump chaining
+- NextColumn wrap via column-jump chaining (multi-column frames)
+- Minimum/Maximum mojikumi aki bounds + CompressionPriority
 - ToBinding / RTL binding alignment
 - Vertical-mode keep options

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

@@ -1145,6 +1145,9 @@ module Idml
           glyphs = TextEngine::Shaper.shape(
             text: run.text, font: font, size: size,
           )
+          glyphs = TextEngine::CjkLayout.apply_script_spacing(
+            glyphs, size, mojikumi_aki_overrides(context)
+          )
           lines = TextEngine::LineBreaker.break(
             glyphs: glyphs, frame_width: wrap_width,
           )
@@ -1169,6 +1172,19 @@ module Idml
         end
         private_class_method :layout_run
 
+        # Aki overrides from the document's first named mojikumi
+        # set, when the designmap declares one (TODO 145). Empty
+        # otherwise — apply_script_spacing then uses the default
+        # CJK/Latin script spacing.
+        def self.mojikumi_aki_overrides(context)
+          package = context.package
+          return [] unless package&.has_part?("designmap.xml")
+
+          table = package.designmap.mojikumi_table.first
+          table&.aki_overrides || []
+        end
+        private_class_method :mojikumi_aki_overrides
+
         # True when the paragraph should move wholly to the next
         # frame: a StartParagraph forced break, or KeepAllLines-
         # Together with insufficient remaining space (never for the

data/lib/idml/render/text_wrap_resolver.rb

@@ -63,10 +63,23 @@ module Idml
           width = WrapContour.overlap_width(contour, line_y,
                                             line_height, frame_x,
                                             frame_right)
-          next unless contour.inverse
+          if contour.inverse
+            reduction = [reduction,
+                         (frame_right - frame_x) - width].max
+            next
+          end
 
-          reduction = [reduction,
-                       (frame_right - frame_x) - width].max
+          # Side-aware shapes (TODO 147): the side dispatch uses
+          # the polygon's bounding box; narrowing itself keeps the
+          # exact polygon overlap for BothSides.
+          bbox_left, _bottom, bbox_right, = WrapContour.bounding_box(
+            contour,
+          )
+          r, s = interval_side_adjustment(contour.side, bbox_left,
+                                          bbox_right, width,
+                                          frame_x, frame_right)
+          reduction = [reduction, r].max
+          shift = [shift, s].max
         end
         [reduction, shift]
       end
@@ -86,12 +99,14 @@ module Idml
 
         return [0.0, 0.0] if overlap.zero?
 
-        # JumpObject: text never flows beside the object — the full
-        # frame width is blocked and the renderer skips the run
-        # below the object's bottom edge.
+        # JumpObject / NextColumn: text never flows beside the
+        # object — the full frame width is blocked and the renderer
+        # skips the run below the object's bottom edge.
         return [frame_right - frame_x, 0.0] if contour.jump
 
-        side_adjustment(contour, overlap, frame_x, frame_right)
+        interval_side_adjustment(contour.side, contour.x,
+                                 contour.x + contour.width, overlap,
+                                 frame_x, frame_right)
       end
       private :box_adjustment
 
@@ -114,30 +129,35 @@ module Idml
       end
       private :box_contour?
 
-      def side_adjustment(contour, overlap, frame_x, frame_right)
-        case contour.side
+      # Side dispatch over an object's horizontal extent
+      # [obj_left, obj_right] (TODO 138/147 — shared by box
+      # contours and Contour shapes' bounding boxes): LeftSide
+      # keeps text left of the object (reduce to its left edge, no
+      # shift); RightSide moves text past its right edge (reduce +
+      # shift); LargestArea picks the roomier side; BothSides and
+      # the spine variants reduce by `overlap` only.
+      def interval_side_adjustment(side, obj_left, obj_right, overlap,
+                                   frame_x, frame_right)
+        case side
         when "LeftSide"
-          [frame_right - contour.x, 0.0]
+          [frame_right - obj_left, 0.0]
         when "RightSide"
-          shift = contour.x + contour.width - frame_x
+          shift = obj_right - frame_x
           [shift, shift]
         when "LargestArea"
-          largest_side_adjustment(contour, frame_x, frame_right)
+          left_free = obj_left - frame_x
+          right_free = frame_right - obj_right
+          if left_free >= right_free
+            [frame_right - obj_left, 0.0]
+          else
+            shift = obj_right - frame_x
+            [shift, shift]
+          end
         else
           [overlap, 0.0]
         end
       end
-      private :side_adjustment
-
-      def largest_side_adjustment(contour, frame_x, frame_right)
-        left_free = contour.x - frame_x
-        right_free = frame_right - (contour.x + contour.width)
-        return [frame_right - contour.x, 0.0] if left_free >= right_free
-
-        shift = contour.x + contour.width - frame_x
-        [shift, shift]
-      end
-      private :largest_side_adjustment
+      private :interval_side_adjustment
 
       # Returns the total horizontal overlap of all contours with a
       # text line at the given y range within the given x range.
@@ -164,10 +184,11 @@ module Idml
       # The wrap shape for an item: a bounding-box rectangle
       # (BoundingBoxTextWrap — the legacy "BoundingBox" spelling is
       # also accepted from early synthetic fixtures) or a flattened
-      # PathGeometry polygon (Contour mode). JumpObject /
-      # NextColumn modes approximate as the bounding box (the
-      # per-run width reduction already pushes text past the
-      # object).
+      # PathGeometry polygon (Contour mode). JumpObject moves text
+      # below the object; NextColumn approximates as the same
+      # jump-below in a single-column frame (true column jumping
+      # needs chain integration, documented in TODO.pdf/61).
+      JUMP_MODES = %w[JumpObjectTextWrap NextColumnTextWrap].freeze
       def self.contour_for(item, page_height)
         pref = wrap_preference(item)
         return nil unless pref
@@ -190,7 +211,7 @@ module Idml
           x: rect[:x], y: rect[:y],
           width: rect[:width], height: rect[:height],
           side: pref&.text_wrap_side,
-          jump: pref&.text_wrap_mode == "JumpObjectTextWrap"
+          jump: JUMP_MODES.include?(pref&.text_wrap_mode)
         )
       end
       private_class_method :box_contour

data/lib/idml/render/wrap_contour.rb

@@ -13,8 +13,9 @@ module Idml
 
       # A wrap shape: flattened polygons (one per subpath) plus the
       # TextWrapOffset bounds. `inverse` flips the wrap region:
-      # text may only flow INSIDE the shape.
-      Shape = Struct.new(:polygons, :offset, :inverse,
+      # text may only flow INSIDE the shape. `side` carries
+      # TextWrapSide for side-aware narrowing (TODO 147).
+      Shape = Struct.new(:polygons, :offset, :inverse, :side,
                          keyword_init: true)
 
       # Builds the wrap shape for an item's PathGeometry and wrap
@@ -24,7 +25,16 @@ module Idml
         return nil if polygons.empty?
 
         Shape.new(polygons: polygons, offset: wrap_offset(pref),
-                  inverse: pref.inverse)
+                  inverse: pref.inverse, side: pref.text_wrap_side)
+      end
+
+      # The shape's bounding box: [left, bottom, right, top] in
+      # PDF coordinates, flattened across subpaths.
+      def self.bounding_box(shape)
+        points = shape.polygons.flatten(1)
+        xs = points.map(&:first)
+        ys = points.map(&:last)
+        [xs.min, ys.min, xs.max, ys.max]
       end
 
       def self.polygons_for(item, page_height)

data/lib/idml/text_engine/cjk_layout.rb

@@ -10,22 +10,95 @@ module Idml
       # Mojikumi subset: automatic inter-script spacing — an eighth
       # em is inserted between adjacent CJK and ASCII alphanumeric
       # glyphs (widenning the leading glyph of each pair), matching
-      # InDesign's default CJK/Latin auto spacing.
+      # InDesign's default CJK/Latin auto spacing. A named
+      # mojikumi set's OverrideMojikumiAki entries take precedence
+      # when given: the Desired value (em units) applies to each
+      # matching class pair (TODO 145).
       SCRIPT_SPACING_EM = 0.125
 
-      def apply_script_spacing(glyphs, size)
-        spacing = size * SCRIPT_SPACING_EM
+      # Mojikumi character classes (InDesign mojikumi table rows).
+      CLASS_IDEOGRAPH = 1
+      CLASS_OPENING = 2
+      CLASS_CLOSING = 3
+      CLASS_COMMA_PERIOD = 4
+      CLASS_MIDDLE_DOT = 5
+      CLASS_DIGIT = 6
+      CLASS_LATIN = 7
+
+      COMMA_PERIOD_CODEPOINTS = [
+        0x3001, # 、 ideographic comma
+        0x3002, # 。 ideographic full stop
+      ].freeze
+
+      CLOSING_CODEPOINTS = [
+        0x3009, # 〉
+        0x300B, # 》
+        0x300D, # 」
+        0x300F, # 』
+        0x3011, # 】
+        0x3015, # 〕
+        0xFF09, # ）fullwidth right paren
+        0xFF3D, # ］
+        0xFF5D, # ｝
+      ].freeze
+
+      def apply_script_spacing(glyphs, size, aki_overrides = [])
         (0...(glyphs.length - 1)).each do |index|
           leading = glyphs[index]
           following = glyphs[index + 1]
-          next unless script_boundary?(leading.codepoint,
-                                       following.codepoint)
+          em = aki_em(leading.codepoint, following.codepoint,
+                      aki_overrides)
+          next unless em&.positive?
 
-          leading.width += spacing
+          leading.width += em * size
         end
         glyphs
       end
 
+      # Spacing (em units) between an adjacent pair: the named
+      # set's Desired aki for a matching class-pair override, else
+      # the default eighth-em at CJK/Latin script boundaries, else
+      # none.
+      def aki_em(left, right, aki_overrides)
+        override = aki_overrides.find do |entry|
+          entry.side_is_after_target &&
+            entry.target_mojikumi_class == mojikumi_class(left) &&
+            entry.side_mojikumi_class == mojikumi_class(right)
+        end
+        return override.desired if override&.desired
+
+        return SCRIPT_SPACING_EM if script_boundary?(left, right)
+
+        nil
+      end
+
+      # The mojikumi class of a codepoint, or nil outside the
+      # CJK punctuation / script classes. Ideographs (the default
+      # CJK class) win only when no special class matches.
+      def mojikumi_class(codepoint)
+        return CLASS_OPENING if OPENING_CODEPOINTS.include?(codepoint)
+        return CLASS_COMMA_PERIOD if COMMA_PERIOD_CODEPOINTS.include?(codepoint)
+        return CLASS_CLOSING if CLOSING_CODEPOINTS.include?(codepoint)
+        return CLASS_MIDDLE_DOT if MIDDLE_CODEPOINTS.include?(codepoint)
+        return CLASS_DIGIT if digit_class?(codepoint)
+        return CLASS_LATIN if latin_class?(codepoint)
+        return CLASS_IDEOGRAPH if cjk?(codepoint)
+
+        nil
+      end
+
+      def digit_class?(codepoint)
+        (0x30..0x39).cover?(codepoint) ||
+          (0xFF10..0xFF19).cover?(codepoint)
+      end
+
+      def latin_class?(codepoint)
+        (0x41..0x5A).cover?(codepoint) ||
+          (0x61..0x7A).cover?(codepoint) ||
+          (0xFF21..0xFF3A).cover?(codepoint) ||
+          (0xFF41..0xFF5A).cover?(codepoint)
+      end
+
       # True when exactly one of the pair is CJK and the other is
       # an ASCII letter or digit.
       def script_boundary?(left, right)

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.8
+  version: 0.10.9
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -208,6 +208,9 @@ files:
 - TODO.pdf/142-vertical-latin-run-groups.md
 - TODO.pdf/143-jump-object-below.md
 - TODO.pdf/144-mojikumi-table-model.md
+- TODO.pdf/145-apply-mojikumi-aki.md
+- TODO.pdf/146-next-column-wrap.md
+- TODO.pdf/147-side-aware-shapes.md
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/16-typed-model-pipeline.md
 - TODO.pdf/17-shape-rendering.md