idml 0.9.7 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d49d9954838f3326eab4e65e2915eab9cd18a526ce7c4dd58669e6dacb8910e
-  data.tar.gz: 56713c3d26980c24c6baf8d080543cd2471aef5dea4ca83c33be82f73fe2e83e
+  metadata.gz: fd4031c47fca99598c64ed757ac446d3e1f2d2870603eb31af338132dae01288
+  data.tar.gz: 520a5ded7c74cfc50d0f893921486930c295b113f7e0d3c7af4dfb576186498c
 SHA512:
-  metadata.gz: d52298b420e04ae5c4b8292e01d951eb23d03d4e01357f463111477e842aea9dd89f6e162a88ad05dd50fa8b721faf6522f891eb66e3405dd6207769f7a9bfe8
-  data.tar.gz: 1d7f89c274a8aac75868064826567901fbc0503ead631953fc7b24eaa282e0f1d8870d2e33f1dc6e81c834b4e3c00fc4b2b465b1a12cc349484b0e653628e63f
+  metadata.gz: bad5a41e54b9e173241e08ba9e7006e6f621230ff782e89e4821d6b26749ee11b30fe8a38dae5185ee1cb41e4497ec20f32267584852cac43c9a37e41f488990
+  data.tar.gz: a62b908ae372636a3dec1722265ee44b24ab847510b348dd0029a3d04b388e41c6ad708f53c11ba21d7077817cfa831d700626ee73cc0380e46bfcb02e7ea58d

data/TODO.pdf/125-script-spacing.md

@@ -0,0 +1,22 @@
+# TODO PDF 125: CJK/Latin automatic script spacing (mojikumi subset)
+
+## Status: COMPLETE — implemented 2026-08-20
+
+## What was done
+
+- `TextEngine::CjkLayout.apply_script_spacing` widens the leading
+  glyph by an eighth em at every CJK ↔ ASCII alphanumeric boundary
+  — InDesign's default inter-script auto spacing (a mojikumi
+  behavior).
+- Wired inside `TextEngine::Shaper#shape`, so every shaping path
+  (horizontal frame text, footnotes, ruby, vertical columns)
+  applies it uniformly — one integration point, no per-caller
+  changes.
+- Punctuation neighbors are ignored (only letters/digits form
+  boundaries).
+
+## Remaining from TODO 13
+
+Class-based mojikumi (per-pair punctuation compression tables,
+line-end punctuation hanging beyond half-em) remains a documented
+stretch goal.

data/TODO.pdf/126-part-cache.md

@@ -0,0 +1,22 @@
+# TODO PDF 126: Package#part memoization
+
+## Status: COMPLETE — implemented 2026-08-20
+
+## Problem
+
+`Package#part(name)` re-read and re-parsed the zip entry on every
+call. Rendering resolves `story_by_id` per frame plus preferences
+(Footnote.option), styles, and graphics repeatedly — each lookup
+decompressed and re-parsed the same XML.
+
+## What was done
+
+Parsed parts are memoized in a per-`Package` hash
+(`parse_part` remains the single read+parse path; `each_part` /
+`read_part` stay uncached raw reads for round-trip byte fidelity).
+
+## Acceptance criteria
+
+- [x] Repeated `part(name)` calls return the same object.
+- [x] Different parts do not share objects.
+- [x] Whole-package round-trip specs unchanged (raw reads).

data/TODO.pdf/127-keep-with-next.md

@@ -0,0 +1,20 @@
+# TODO PDF 127: KeepWithNext
+
+## Status: COMPLETE — implemented 2026-08-20
+
+## What was done
+
+- `StyleResolver::Paragraph` carries `keep_with_next` from the PSR.
+- A paragraph with KeepWithNext defers to the next frame when the
+  FOLLOWING paragraph is forced there (StartParagraph break) or
+  when the follower's first line would not fit after this
+  paragraph (pre-measured via TextEngine::Measurement plus the
+  follower's leading). Combined with TODO 123's KeepAllLinesTogether,
+  both keep flavors share one deferral predicate in
+  `consume_paragraphs`.
+
+## Known limitations
+
+- The numeric strength of KeepWithNext (1–5, lines to keep) is
+  treated as boolean.
+- Not applied in vertical writing mode.

data/TODO.pdf/13-cjk-text-layout.md

@@ -20,9 +20,11 @@ kinsoku shori, ruby annotations).
   frame width (previously they overflowed as one long line) — this
   also fixes horizontal CJK wrapping.
 
-Remaining stretch goals: tate-chu-yoko, mojikumi, Latin rotation in
-vertical mode, vertical ruby placement. See
-`lib/idml/text_engine/cjk_layout.rb` and
+2026-08-20 completions: tate-chu-yoko (TODO 124), Latin rotation
+and vertical ruby (TODO 122), CJK/Latin automatic script spacing
+(TODO 125, a mojikumi subset wired into Shaper). The remaining
+stretch goal is full class-based mojikumi (per-pair punctuation
+compression tables). See `lib/idml/text_engine/cjk_layout.rb` and
 `lib/idml/text_engine/vertical_text_layout.rb`.
 
 ## Progress 2026-08-17

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

@@ -1,35 +1,51 @@
 # TODO PDF 61: Known limitations and future work
 
-## Status: DOCUMENTED
+## Status: DOCUMENTED — refreshed 2026-08-20
 
-## Known limitations
-
-1. **Font embedding**: pdfrb 0.3.0 registers fonts by name but does
-   not embed FontFile2 binary data in the PDF. Text renders correctly
-   on systems with the font installed but may not render on other
-   systems. Requires pdfrb font subsetting support (TODO 52).
+Previously listed limitations (font embedding, tagged PDF, per-run
+styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
+this list reflects the current state.
 
-2. **Image fixture tests**: The fixture IDML references an external
-   JPEG at a macOS-specific path. Tests that check image embedding
-   are skipped on CI. A self-contained fixture with an embedded image
-   would fix this.
-
-3. **Text engine integration**: TextFrameRenderer uses the text engine
-   for line breaking when FontMetrics is available (Helvetica as .ttf).
-   On macOS, Helvetica is a .ttc collection, so the fallback simple
-   renderer is used (no line breaking). Per-run styling (different
-   fonts/sizes in one frame) is simplified to use the first run's style.
+## Known limitations
 
-4. **Dead code**: Old modules (PdfWriter, FontEmbedder, Color, Path,
-   Text) are marked DEPRECATED but cannot be deleted per the project's
-   "never delete source files" policy. They are not used by any active
-   code path.
+### Text layout
+- **Hyphenation** is not implemented (Hyphenation* attributes are
+  parsed but unused); a hyphenation dictionary would be required.
+- **Justification**: word/letter spacing caps apply (TODO 119);
+  glyph scaling (Min/Max/DesiredGlyphScaling) is not applied;
+  ToBinding / RTL binding alignment maps to left.
+- **Keep options**: whole-paragraph KeepAllLinesTogether and
+  KeepWithNext(first-line) are honored; partial keep windows
+  (KeepFirstLines / KeepLastLines) are not.
+- **StartParagraph** breaks act at frame/column granularity — no
+  odd/even page parity.
+- **Text wrap** (TODO 114): BoundingBox mode only; Shape contour
+  following and Inverse mode are not implemented.
+
+### CJK
+- **Mojikumi**: CJK/Latin auto script spacing is applied (TODO
+  125); full class-based punctuation compression tables are not.
+- **Vertical mode**: Latin rotation is per glyph (not run-grouped);
+  ruby placement is beside-column; keep options do not apply.
+
+### Structural features
+- **Endnotes** (TODO 117): reference markers render; endnote TEXT
+  rendering is gated on a real fixture (the EndnoteTextRange
+  reference chain is opaque without one).
+- **Footnotes** number per story; overflow balancing (NoSplitting)
+  is not modeled; the simple-render fallback shows markers without
+  footnote text.
+- **Anchored objects** render at stored geometry; AnchorType
+  text-reflow is not simulated.
+- **Tables** do not span frames (no repeated header rows); diagonal
+  cell strokes are modeled but not drawn.
+- **Inline anchored objects / footnotes inside table cells** are
+  not handled.
 
 ## Future enhancements
 
-- Font subsetting (TODO 52) — requires pdfrb enhancement
-- Tagged PDF / PDF/UA (TODO 53) — requires pdfrb StructTreeRoot
-- Dead code removal (TODO 51) — when policy allows
-- Self-contained test fixture with embedded image
-- Per-run text styling with cursor tracking
+- Hyphenation dictionary integration
+- Shape-mode text wrap contours
+- Frame-spanning tables with header repeats
+- Class-based mojikumi tables
 - Performance benchmark for 100+ page documents

data/lib/idml/package.rb

@@ -134,13 +134,23 @@ module Idml
     # Returns a typed part instance for `name` when a class is registered
     # for that file pattern (e.g. Designmap for designmap.xml). Falls
     # back to Parts::Raw — a lossless XML wrapper — for unmodeled parts.
+    # Parsed parts are memoized: rendering resolves stories,
+    # preferences, and styles repeatedly (per frame), and each
+    # un-memoized read would re-decompress and re-parse the zip
+    # entry.
     def part(name)
+      @part_cache ||= {}
+      @part_cache[name] ||= parse_part(name)
+    end
+
+    def parse_part(name)
       xml = read_part(name)
       klass = Idml::Parts.class_for(name)
       return Idml::Parts::Raw.from_xml(xml) unless klass
 
       klass.from_xml(xml)
     end
+    private :parse_part
 
     def each_part
       return enum_for(:each_part) unless block_given?

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

@@ -629,11 +629,13 @@ module Idml
                                     cursor_y, bottom_limit, char_cursor,
                                     footnotes)
           pending = 0
-          state.paragraphs.each do |paragraph|
+          state.paragraphs.each_with_index do |paragraph, index|
             break if cursor_y < bottom_limit
-            break if paragraph_deferred?(paragraph, layout_frame, font,
-                                         cursor_y, bottom_limit,
-                                         pending.positive?)
+
+            next_paragraph = state.paragraphs[index + 1]
+            break if paragraph_deferred?(paragraph, next_paragraph,
+                                         layout_frame, font, cursor_y,
+                                         bottom_limit, pending.positive?)
 
             remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
               canvas, paragraph, paragraph.runs, context,
@@ -969,11 +971,25 @@ module Idml
         # frame: a StartParagraph forced break, or KeepAllLines-
         # Together with insufficient remaining space (never for the
         # frame's first paragraph, so progress is always made).
-        def self.paragraph_deferred?(paragraph, layout_frame, font,
-                                     cursor_y, bottom_limit, placed_any)
+        def self.paragraph_deferred?(paragraph, next_paragraph,
+                                     layout_frame, font, cursor_y,
+                                     bottom_limit, placed_any)
           return true if paragraph_break?(paragraph) && placed_any
-          return false unless paragraph.keep_all_lines_together
           return false unless placed_any
+          return true if keep_with_next_break?(paragraph, next_paragraph,
+                                               layout_frame, font,
+                                               cursor_y, bottom_limit)
+
+          keep_all_lines_break?(paragraph, layout_frame, font,
+                                cursor_y, bottom_limit)
+        end
+        private_class_method :paragraph_deferred?
+
+        # KeepAllLinesTogether: defer when the paragraph cannot
+        # fully fit the remaining space.
+        def self.keep_all_lines_break?(paragraph, layout_frame, font,
+                                       cursor_y, bottom_limit)
+          return false unless paragraph.keep_all_lines_together
 
           wrap_width = TextEngine::VerticalLayout.wrap_width(
             layout_frame, paragraph.right_indent || 0
@@ -983,7 +999,40 @@ module Idml
           )
           (cursor_y - height) < bottom_limit
         end
-        private_class_method :paragraph_deferred?
+        private_class_method :keep_all_lines_break?
+
+        # KeepWithNext: this paragraph defers when the next
+        # paragraph is forced to the next frame, or when the next
+        # paragraph's first line would not fit after this one.
+        def self.keep_with_next_break?(paragraph, next_paragraph,
+                                       layout_frame, font, cursor_y,
+                                       bottom_limit)
+          return false unless keepable_pair?(paragraph, next_paragraph)
+          return true if paragraph_break?(next_paragraph)
+
+          wrap_width = TextEngine::VerticalLayout.wrap_width(
+            layout_frame, paragraph.right_indent || 0
+          )
+          height = TextEngine::Measurement.paragraph_height(
+            paragraph, font, wrap_width
+          )
+          (cursor_y - height - follower_leading(next_paragraph)) <
+            bottom_limit
+        end
+        private_class_method :keep_with_next_break?
+
+        def self.keepable_pair?(paragraph, next_paragraph)
+          !paragraph.keep_with_next.nil? && !next_paragraph.nil?
+        end
+        private_class_method :keepable_pair?
+
+        def self.follower_leading(next_paragraph)
+          size = next_paragraph.runs.first&.point_size || DEFAULT_SIZE
+          TextEngine::VerticalLayout.leading_for(
+            next_paragraph.auto_leading, size
+          )
+        end
+        private_class_method :follower_leading
 
         # True when the paragraph requests a forced break to the
         # next frame/column (StartParagraph). All break flavors act

data/lib/idml/render/style_resolver.rb

@@ -72,8 +72,11 @@ module Idml
         # NextColumn / NextFrame / NextOddPage / NextEvenPage).
         :start_paragraph,
         # Widow/orphan control: KeepAllLinesTogether pushes the whole
-        # paragraph to the next frame when it cannot fully fit.
+        # paragraph to the next frame when it cannot fully fit;
+        # KeepWithNext binds this paragraph to the next paragraph's
+        # first line.
         :keep_all_lines_together,
+        :keep_with_next,
         :bullets_and_numbering_list_type,
         :bullet_character_value,
         :bullets_text_after,
@@ -207,6 +210,8 @@ module Idml
             keep_all_lines_together: resolve_attr(
               style_lookup, psr, :keep_all_lines_together
             ),
+            keep_with_next: resolve_attr(style_lookup, psr,
+                                         :keep_with_next),
             drop_cap_lines: resolve_attr(style_lookup, psr, :drop_cap_lines),
             drop_cap_characters: resolve_attr(style_lookup, psr,
                                               :drop_cap_characters),

data/lib/idml/text_engine/cjk_layout.rb

@@ -7,6 +7,38 @@ module Idml
     module CjkLayout
       module_function
 
+      # 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.
+      SCRIPT_SPACING_EM = 0.125
+
+      def apply_script_spacing(glyphs, size)
+        spacing = size * SCRIPT_SPACING_EM
+        (0...(glyphs.length - 1)).each do |index|
+          leading = glyphs[index]
+          following = glyphs[index + 1]
+          next unless script_boundary?(leading.codepoint,
+                                       following.codepoint)
+
+          leading.width += spacing
+        end
+        glyphs
+      end
+
+      # True when exactly one of the pair is CJK and the other is
+      # an ASCII letter or digit.
+      def script_boundary?(left, right)
+        (cjk?(left) && ascii_alnum?(right)) ||
+          (ascii_alnum?(left) && cjk?(right))
+      end
+
+      def ascii_alnum?(codepoint)
+        (0x30..0x39).cover?(codepoint) ||
+          (0x41..0x5A).cover?(codepoint) ||
+          (0x61..0x7A).cover?(codepoint)
+      end
+
       CJK_RANGES = [
         0x3000..0x303F, # CJK Symbols and Punctuation
         0x3040..0x309F, # Hiragana

data/lib/idml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.9
 platform: ruby
 authors:
 - Ribose
@@ -183,6 +183,9 @@ files:
 - TODO.pdf/122-vertical-latin-ruby.md
 - TODO.pdf/123-keep-options.md
 - TODO.pdf/124-tatechuyoko-vertical.md
+- TODO.pdf/125-script-spacing.md
+- TODO.pdf/126-part-cache.md
+- TODO.pdf/127-keep-with-next.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
 - TODO.pdf/15-wire-spread-children.md