idml 0.9.6 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76ef12540a7d7d1805189664f88fc0c5b400b8d1240fbc495239ddb35f64822c
-  data.tar.gz: 941893920b3e23a32c196de4286a64f10edb0e377bb716a5287ba110bc3052bd
+  metadata.gz: 29f97721ebdd63304b8c879eaa45764906dfa40b85363688aa9d860ccdd6f62c
+  data.tar.gz: 439a3e3454be081957617ce5107ae735a47d56c4dc206104d3e483c5a20db669
 SHA512:
-  metadata.gz: 95da409c1987bac0a36ab73793c02e349d3060f313f3f4fc2670f22efffd89bd2d5f0bcfba4096dab595cf39a7843134ee0fc4f06f9e4136d477c65f44870586
-  data.tar.gz: a74c7d9a0a1ccd22e57308890a0f6b257e9ec2d3aab7d3d8a407c23b4b52f466cd2c39f86be48d4b89e912e26fcd3a582dbdf27455d8db49a405219ede022357
+  metadata.gz: 0c669bcf817d1e2b8ab74c116e3a0e472b8ca5529fdfeba4f0adb85d7f1ddb78da5d422c63907cbe68f4a7c381ce5862d17b674063070bce64e9664584159b97
+  data.tar.gz: b427dc2a77703a71074fc541eb8eea36485dc78607dea9faa8f13d3ca69c70e013a749374ef8abca81057bdf5e7563f6717bea30e45ad967a5836ead3e325d6a

data/TODO.pdf/123-keep-options.md

@@ -0,0 +1,24 @@
+# TODO PDF 123: Keep options (widow/orphan control)
+
+## Status: COMPLETE — implemented 2026-08-20
+
+## What was done
+
+- `StyleResolver::Paragraph` carries `keep_all_lines_together`
+  from the PSR.
+- `TextFrameRenderer.consume_paragraphs` pre-measures the paragraph
+  (TextEngine::Measurement) and, when KeepAllLinesTogether is set,
+  the paragraph cannot fully fit the remaining frame space, and at
+  least one paragraph was already placed, pushes the whole
+  paragraph to the next frame via the chain state — no widowed
+  first lines. The first paragraph in a frame never pushes, so
+  progress is always made.
+
+## Known limitations
+
+- KeepLinesTogether with per-side KeepFirstLines / KeepLastLines
+  counts (partial keep windows) is not modeled — only the
+  whole-paragraph KeepAllLinesTogether form.
+- KeepWithNext (binding a paragraph to the next) is not modeled.
+- Vertical writing mode does not apply keep options (column model
+  differs).

data/TODO.pdf/124-tatechuyoko-vertical.md

@@ -0,0 +1,23 @@
+# TODO PDF 124: Tate-chu-yoko and vertical multi-run columns
+
+## Status: COMPLETE — implemented 2026-08-20
+
+## What was done
+
+- Multi-run column continuity (bug fix): every run in a vertical
+  frame used to restart at column 0, overlapping earlier runs.
+  `VerticalTextLayout.layout` takes `start_column`; the frame
+  renderer threads the next-unused column across runs and
+  paragraphs, and persists it in the chain state (`column_offset`)
+  so vertical text continues correctly into the next frame of a
+  chain.
+- Tate-chu-yoko (`Tatechuyoko="true"` on the CSR — note the
+  schema's lowercase c): the run's glyphs render HORIZONTALLY,
+  sharing one baseline at the top of their column slot and centered
+  in it, consuming one column. Groups wider than the column height
+  fall back to stacked layout. StyledRun carries `tatechuyoko`.
+
+## Remaining from TODO 13
+
+Mojikumi (punctuation spacing classes) is the last documented
+stretch goal.

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/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/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

@@ -177,17 +177,20 @@ module Idml
           layout_frame = layout_frame(context.item, box)
           left_limit = layout_frame.x + (layout_frame.inset_left || 0)
           resume_vertical_paragraph(state)
+          next_column = state.column_offset || 0
           pending = 0
 
           state.paragraphs.each do |paragraph|
-            remaining_runs = vertical_paragraph(
-              canvas, paragraph, context, layout_frame, font, left_limit
+            remaining_runs, next_column = vertical_paragraph(
+              canvas, paragraph, context, layout_frame, font,
+              left_limit, next_column
             )
             if remaining_runs.empty?
               pending += 1
             else
               state.current_paragraph = paragraph
               state.runs_remaining = remaining_runs
+              state.column_offset = next_column
               break
             end
           end
@@ -198,7 +201,9 @@ module Idml
 
         # Folds a chain-resumed paragraph (runs_remaining) back to
         # the head of the paragraph list so the vertical path sees a
-        # uniform sequence.
+        # uniform sequence. The consumed column offset persists in
+        # the state so the next frame continues right where this
+        # frame's columns ended.
         def self.resume_vertical_paragraph(state)
           return unless state.current_paragraph
 
@@ -209,10 +214,13 @@ module Idml
         end
         private_class_method :resume_vertical_paragraph
 
-        # Renders one paragraph's runs as vertical columns. Returns
-        # the runs that did not fit (empty when all placed).
+        # Renders one paragraph's runs as vertical columns starting
+        # at `start_column`. Returns [runs that did not fit (empty
+        # when all placed), the next unused column index].
         def self.vertical_paragraph(canvas, paragraph, context,
-                                    layout_frame, font, left_limit)
+                                    layout_frame, font, left_limit,
+                                    start_column)
+          next_column = start_column
           paragraph.runs.each_with_index do |run, index|
             size = run.point_size || DEFAULT_SIZE
             leading = TextEngine::VerticalLayout.leading_for(
@@ -220,25 +228,72 @@ module Idml
             )
             glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
                                               size: size)
-            positioned, columns = TextEngine::VerticalTextLayout.layout(
-              glyphs: glyphs, frame: layout_frame, leading: leading,
-              size: size
-            )
-            unless vertical_fits?(layout_frame, leading, columns,
+            grouped = tatechuyoko_group(run, glyphs, layout_frame,
+                                        leading, size, next_column)
+            positioned, next_column = grouped ||
+              TextEngine::VerticalTextLayout.layout(
+                glyphs: glyphs, frame: layout_frame, leading: leading,
+                size: size, start_column: next_column
+              )
+            unless vertical_fits?(layout_frame, leading, next_column,
                                   left_limit)
-              return paragraph.runs[index..]
+              return [paragraph.runs[index..], start_column]
             end
 
-            positioned.each do |glyph|
-              emit_vertical_glyph(canvas, glyph, run, context, size)
-            end
+            emit_vertical_run(canvas, positioned, grouped, run, context,
+                              size)
             emit_vertical_ruby(canvas, run, positioned, layout_frame,
                                size, context)
           end
-          []
+          [[], next_column]
         end
         private_class_method :vertical_paragraph
 
+        # A tate-chu-yoko group for runs that declare it (and whose
+        # glyphs fit horizontally in a column slot); nil otherwise.
+        def self.tatechuyoko_group(run, glyphs, layout_frame, leading,
+                                   size, start_column)
+          return nil unless run.tatechuyoko
+
+          TextEngine::VerticalTextLayout.tatechuyoko_group(
+            glyphs: glyphs, frame: layout_frame, leading: leading,
+            size: size, start_column: start_column
+          )
+        end
+        private_class_method :tatechuyoko_group
+
+        # Emits a vertical run's glyphs: rotated/normal vertical
+        # handling for stacked columns, plain upright emission for
+        # tate-chu-yoko groups.
+        def self.emit_vertical_run(canvas, positioned, grouped, run,
+                                   context, size)
+          if grouped
+            positioned.each do |glyph|
+              emit_upright_glyph(canvas, glyph, run, context, size)
+            end
+          else
+            positioned.each do |glyph|
+              emit_vertical_glyph(canvas, glyph, run, context, size)
+            end
+          end
+        end
+        private_class_method :emit_vertical_run
+
+        def self.emit_upright_glyph(canvas, positioned, run, context,
+                                    size)
+          text = [positioned.codepoint].pack("U")
+          text_kwargs = CharacterStyle.text_kwargs(
+            run,
+            {
+              at: [positioned.x, positioned.y],
+              font: font_for_run(run, context),
+              size: size,
+            },
+          )
+          canvas.text(text, **text_kwargs)
+        end
+        private_class_method :emit_upright_glyph
+
         def self.vertical_fits?(layout_frame, leading, columns, left_limit)
           right = layout_frame.x + layout_frame.width -
             (layout_frame.inset_right || 0)
@@ -576,7 +631,9 @@ module Idml
           pending = 0
           state.paragraphs.each do |paragraph|
             break if cursor_y < bottom_limit
-            break if paragraph_break?(paragraph) && pending.positive?
+            break if paragraph_deferred?(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,
@@ -908,6 +965,26 @@ module Idml
         end
         private_class_method :layout_run
 
+        # 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
+        # frame's first paragraph, so progress is always made).
+        def self.paragraph_deferred?(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
+
+          wrap_width = TextEngine::VerticalLayout.wrap_width(
+            layout_frame, paragraph.right_indent || 0
+          )
+          height = TextEngine::Measurement.paragraph_height(
+            paragraph, font, wrap_width
+          )
+          (cursor_y - height) < bottom_limit
+        end
+        private_class_method :paragraph_deferred?
+
         # True when the paragraph requests a forced break to the
         # next frame/column (StartParagraph). All break flavors act
         # at frame/column granularity.

data/lib/idml/render/story_chain_controller.rb

@@ -25,6 +25,9 @@ module Idml
         :current_paragraph,
         :runs_remaining,
         :char_cursor,
+        # Vertical-writing path: columns already consumed when the
+        # paragraph chain continues into the next frame.
+        :column_offset,
         keyword_init: true,
       )
 

data/lib/idml/render/style_resolver.rb

@@ -48,6 +48,7 @@ module Idml
         :ruby_string,
         :ruby_font_size,
         :ruby_position,
+        :tatechuyoko,
         keyword_init: true,
       )
 
@@ -70,6 +71,9 @@ module Idml
         # Forced paragraph break (StartParagraph: NextPage /
         # NextColumn / NextFrame / NextOddPage / NextEvenPage).
         :start_paragraph,
+        # Widow/orphan control: KeepAllLinesTogether pushes the whole
+        # paragraph to the next frame when it cannot fully fit.
+        :keep_all_lines_together,
         :bullets_and_numbering_list_type,
         :bullet_character_value,
         :bullets_text_after,
@@ -200,6 +204,9 @@ module Idml
             ),
             start_paragraph: resolve_attr(style_lookup, psr,
                                           :start_paragraph),
+            keep_all_lines_together: resolve_attr(
+              style_lookup, psr, :keep_all_lines_together
+            ),
             drop_cap_lines: resolve_attr(style_lookup, psr, :drop_cap_lines),
             drop_cap_characters: resolve_attr(style_lookup, psr,
                                               :drop_cap_characters),
@@ -390,6 +397,7 @@ module Idml
           ruby_string: resolve_csr(style_lookup, csr, :ruby_string),
           ruby_font_size: resolve_csr(style_lookup, csr, :ruby_font_size),
           ruby_position: resolve_csr(style_lookup, csr, :ruby_position),
+          tatechuyoko: resolve_csr(style_lookup, csr, :tatechuyoko),
         )
       end
       private_class_method :text_run

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/text_engine/vertical_text_layout.rb

@@ -13,18 +13,19 @@ module Idml
       PositionedGlyph = Struct.new(:codepoint, :x, :y, keyword_init: true)
 
       # Stacks `glyphs` into columns of at most the frame's text
-      # height; column 0 is the rightmost. Returns
-      # [positioned_glyphs, column_count].
-      def self.layout(glyphs:, frame:, leading:, size:)
+      # height; column 0 is the rightmost. `start_column` places
+      # the first column after already-used columns (multi-run
+      # frames). Returns [positioned_glyphs, next_column_index].
+      def self.layout(glyphs:, frame:, leading:, size:, start_column: 0)
         lines = TextEngine::LineBreaker.break(
           glyphs: glyphs, frame_width: column_height(frame),
         )
         positioned = []
-        lines.each_with_index do |line, column_index|
+        lines.each_with_index do |line, index|
           stack_column(positioned, line.glyphs, frame, leading, size,
-                       column_index)
+                       index + start_column)
         end
-        [positioned, lines.length]
+        [positioned, start_column + lines.length]
       end
 
       # The frame's usable vertical extent for one column of text.
@@ -47,6 +48,32 @@ module Idml
       end
       private_class_method :stack_column
 
+      # Positions a tate-chu-yoko group (e.g. the digits "12" kept
+      # horizontal inside vertical text): glyphs share one baseline
+      # at the top of the given column slot and advance left-to-
+      # right, centered in the slot. Returns
+      # [positioned_glyphs, next_column_index]; nil when the group
+      # is wider than the column height (caller falls back to
+      # stacked layout).
+      def self.tatechuyoko_group(glyphs:, frame:, leading:, size:,
+                                 start_column:)
+        total = glyphs.sum(&:width)
+        return nil if total > column_height(frame)
+
+        right = frame.x + frame.width - (frame.inset_right || 0)
+        slot_center = right - ((start_column + 0.5) * leading)
+        x = slot_center - (total / 2.0)
+        baseline_y = frame.y + frame.height - (frame.inset_top || 0) - size
+        positioned = glyphs.map do |glyph|
+          glyph_position = PositionedGlyph.new(
+            codepoint: glyph.codepoint, x: x, y: baseline_y,
+          )
+          x += glyph.width
+          glyph_position
+        end
+        [positioned, start_column + 1]
+      end
+
       # Vertical advance of one glyph — its measured width (the em
       # for the common square-CJK case).
       def self.advance(glyph)

data/lib/idml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.8
 platform: ruby
 authors:
 - Ribose
@@ -181,6 +181,10 @@ files:
 - TODO.pdf/120-start-paragraph-breaks.md
 - TODO.pdf/121-cell-edge-strokes.md
 - 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/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
 - TODO.pdf/15-wire-spread-children.md