idml 0.10.13 → 0.10.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f2a7b73c56645a87269780fc0cab9f998f5a6bf0d167b0ce9433dba9a8019cd
-  data.tar.gz: e4bb1522273937a4c2cf5631de1927f4583f63d16f2b351f893921407d89dc88
+  metadata.gz: 578a2a0fbd712f1931eaff74db316971441be4a967afd67d47ab55ecdc9679d1
+  data.tar.gz: e93c08f8694da2e0522a787ff0f58b4f607952f7024a0dd0d54bab42599ac8e9
 SHA512:
-  metadata.gz: 83756750d549a02ff7080686509ac45acce77405db6c9d3ba0ee6dae3643622b8eb89198d28fead77047dac50bdcf9491bdab05b7e03d02e18560f1021fa5360
-  data.tar.gz: 8a9fc59030029b4342019b205f9fe7da46ae6296729d641c49c199391cd5765ffea195dfca6cde46ff0df6518f496dcf9a1b66dc5dad0b808503230be8057107
+  metadata.gz: 260e3fdbcd2339d2e461aae7f2992b311120a0b15544d48b65c39d915dee9fd0219fcb3ee6d9e07ce40eaeb9bf68846fa72bdf2475d9ce12d1982cdd1503afd5
+  data.tar.gz: 6d760f50d28216bbe1a620aa4ba2b43028ab3051384e0fee559764892f8495b04f5623b2a3ba14698f89cf6bf1e3de9f0426be158e3e7faf0d8d7a3b639e289e

data/TODO.pdf/152-rtl-alignment.md

@@ -0,0 +1,27 @@
+# TODO PDF 152: RTL paragraph alignment
+
+## Status: COMPLETE — implemented 2026-08-31
+
+## Problem
+
+ParagraphDirection (LeftToRightDirection /
+RightToLeftDirection) was parsed but unused: RTL paragraphs
+aligned left/right by LTR convention, so Arabic/Hebrew text sat
+on the wrong edge.
+
+## Solution
+
+`StyleResolver::Paragraph` carries `paragraph_direction` (PSR or
+paragraph style); `TextEngine::Justifier` gains a `direction:`
+argument that mirrors the visual alignment under
+RightToLeftDirection — left↔right, start↔end; center and
+justified unchanged. Both justify call sites (frame renderer and
+footnote layout) pass the paragraph's direction.
+
+## Files
+
+- `lib/idml/text_engine/justifier.rb`
+- `lib/idml/render/style_resolver.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `lib/idml/render/footnote.rb`
+- `spec/idml/text_engine/text_engine_spec.rb`

data/TODO.pdf/153-vertical-keeps.md

@@ -0,0 +1,31 @@
+# TODO PDF 153: Keep options in vertical writing
+
+## Status: COMPLETE (approximation) — implemented 2026-08-31
+
+## Problem
+
+Keep options (TODOs 123/127/133) applied only to the horizontal
+engine; vertical paragraphs split across frames regardless of
+KeepAllLinesTogether / KeepWithNext.
+
+## Solution
+
+`VerticalEmit.vertical_render` consults a keep check BEFORE
+placing each paragraph (deferral after placement cannot un-emit):
+
+- **KeepAllLinesTogether** defers the paragraph wholly to the
+  next frame when its column need exceeds the remaining columns.
+- **KeepWithNext** also defers when the follower's forced break
+  or column need would strand it.
+- Never defers the frame's first paragraph — the same progress
+  guarantee as KeepPolicy (shared: `KeepPolicy.paragraph_break?`).
+
+Approximation: column need = runs count (one column per run),
+which under-estimates runs spanning several columns — deferral
+errs toward placing. KeepFirstLines/KeepLastLines windows remain
+horizontal-only (they are line-window concepts).
+
+## Files
+
+- `lib/idml/render/renderers/vertical_emit.rb`
+- `spec/idml/render/vertical_render_spec.rb`

data/TODO.pdf/154-vertical-keep-windows.md

@@ -0,0 +1,21 @@
+# TODO PDF 154: Vertical keep windows
+
+## Status: COMPLETE (approximation) — implemented 2026-09-01
+
+## Problem
+
+KeepFirstLines / KeepLastLines windows (TODO 133) applied only to
+the horizontal engine; vertical paragraphs ignored them.
+
+## Solution
+
+`VerticalEmit`'s pre-placement keep check (TODO 153) also honors
+the windows on the same column-count approximation: a splitting
+paragraph (needed columns > available) defers when fewer than
+KeepFirstLines columns fit, or when the stranded tail would hold
+fewer than KeepLastLines columns.
+
+## Files
+
+- `lib/idml/render/renderers/vertical_emit.rb`
+- `spec/idml/render/vertical_render_spec.rb`

data/TODO.pdf/155-next-column-jump.md

@@ -0,0 +1,29 @@
+# TODO PDF 155: NextColumn column jumping in multi-column frames
+
+## Status: COMPLETE — implemented 2026-09-01
+
+## Problem
+
+NextColumnTextWrap approximated as JumpObject-below (TODO 146):
+in a multi-column frame, InDesign moves the text to the NEXT
+COLUMN, not below the object.
+
+## Solution
+
+The wrap contour carries the mode: `jump` (JumpObjectTextWrap)
+vs `next_column` (NextColumnTextWrap). Both block the full column
+width; the renderer chooses the response —
+`TextFrameRenderer#next_column_jump?` abandons the column when a
+NextColumn contour blocks the run's band in a multi-column frame:
+the cursor drops to the bottom limit mid-run, the unplaced runs
+return to the chain state, and the next column (or frame)
+resumes them. Single-column frames and JumpObject keep the
+skip-below path (`jump_contour_bottom` reports the resume point
+for both flavors).
+
+## Files
+
+- `lib/idml/render/text_wrap_resolver.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`
+- `spec/idml/render/jump_object_render_spec.rb` (end-to-end)

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

@@ -1,6 +1,6 @@
 # TODO PDF 61: Known limitations and future work
 
-## Status: DOCUMENTED — refreshed 2026-08-28
+## Status: DOCUMENTED — refreshed 2026-09-01
 
 Previously listed limitations (font embedding, tagged PDF, per-run
 styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
@@ -14,8 +14,9 @@ this list reflects the current state.
   wrap after explicit hyphens (TODO 139).
 - **Justification**: word/letter spacing caps apply (TODO 119),
   MaximumGlyphScaling stretches (TODO 129) and MinimumGlyphScaling
-  compresses overlong lines (TODO 135); ToBinding / RTL binding
-  alignment is not applied.
+  compresses overlong lines (TODO 135); RTL paragraphs mirror
+  left/right alignment (TODO 152); ToBinding / kashida-based
+  Arabic justification is not applied.
 - **Keep options**: KeepAllLinesTogether (TODO 123), KeepWithNext
   (TODO 127), and the KeepFirstLines / KeepLastLines windows
   (TODO 133, line-count approximation) are honored.
@@ -26,11 +27,10 @@ this list reflects the current state.
   odd/even page parity.
 - **Text wrap**: BoundingBoxTextWrap, Contour, and Inverse modes
   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.
+  box contours and Contour shapes (TODOs 138/147); JumpObject moves
+  text below the object (TODO 143); NextColumn jumps to the next
+  column in multi-column frames and below the object otherwise
+  (TODOs 146/155); spine variants approximate as BothSides.
 
 ### CJK
 - **Mojikumi**: script spacing (TODO 125, now actually wired),
@@ -39,8 +39,8 @@ this list reflects the current state.
   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.
+  (TODO 142); ruby placement is beside-column; keep options apply
+  with a column-count approximation (TODOs 153-154).
 
 ### Structural features
 - **Endnotes** (TODO 117): reference markers render and endnote TEXT
@@ -60,7 +60,5 @@ this list reflects the current state.
 ## Future enhancements
 
 - Hyphenation dictionary integration
-- NextColumn wrap via column-jump chaining (multi-column frames)
 - Minimum/Maximum mojikumi aki bounds + CompressionPriority
-- ToBinding / RTL binding alignment
-- Vertical-mode keep options
+- ToBinding / kashida Arabic justification

data/lib/idml/render/footnote.rb

@@ -138,6 +138,7 @@ module Idml
             TextEngine::Justifier.justify(
               line: line, frame_width: wrap_width,
               alignment: paragraph.alignment || :left,
+              direction: paragraph.paragraph_direction,
               last_line: last_line?(paragraph, run, index, lines),
               limits: limits
             )

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

@@ -543,6 +543,11 @@ module Idml
               context, layout_frame, cursor_y, run
             )
             run_wrap -= wrap_reduction
+            if next_column_jump?(context, layout_frame, cursor_y, run,
+                                 run_wrap)
+              cursor_y = bottom_limit
+              break
+            end
             cursor_y, run_wrap, wrap_shift = skip_below_jump_object(
               context, layout_frame, cursor_y, run, run_wrap, wrap_shift,
               wrap_reduction, bottom_limit
@@ -612,6 +617,37 @@ module Idml
         end
         private_class_method :render_footnote_entries
 
+        # NextColumnTextWrap in a multi-column frame (TODO 155):
+        # abandon the column — the unplaced runs return to the
+        # chain state and the next column resumes them. Falls
+        # through to skip-below everywhere else (single-column
+        # frames included).
+        def self.next_column_jump?(context, layout_frame, cursor_y, run,
+                                   run_wrap)
+          size = run.point_size || DEFAULT_SIZE
+          return false unless run_wrap < size
+          return false unless multi_column_frame?(context)
+
+          blocked_in_band?(context, layout_frame, cursor_y, size)
+        end
+
+        def self.multi_column_frame?(context)
+          text_column_count(context).to_i > 1
+        end
+        private_class_method :multi_column_frame?
+
+        def self.blocked_in_band?(context, layout_frame, cursor_y, size)
+          resolver = context.text_wrap_resolver
+          return false unless resolver
+
+          frame_x = layout_frame.x + (layout_frame.inset_left || 0)
+          frame_right = layout_frame.x + layout_frame.width -
+            (layout_frame.inset_right || 0)
+          resolver.next_column_block?(cursor_y, size, frame_x, frame_right)
+        end
+        private_class_method :blocked_in_band?
+        private_class_method :next_column_jump?
+
         # JumpObjectTextWrap blocks the full column width: when the
         # run's band is fully blocked, move the cursor below the
         # object's bottom edge and re-measure once. InDesign's
@@ -853,7 +889,8 @@ module Idml
               line: line, frame_width: wrap_width,
               alignment: paragraph.alignment || :left,
               last_line: paragraph_last && index == lines.length - 1,
-              limits: limits
+              limits: limits,
+              direction: paragraph.paragraph_direction
             )
           end
         end

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

@@ -24,10 +24,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
+          entry_offset = state.column_offset || 0
+          next_column = entry_offset
           pending = 0
 
-          state.paragraphs.each do |paragraph|
+          state.paragraphs.each_with_index do |paragraph, index|
+            if vertical_keep_deferred?(paragraph, state.paragraphs[index + 1],
+                                       layout_frame, font, left_limit,
+                                       next_column, pending, entry_offset)
+              state.current_paragraph = nil
+              state.runs_remaining = []
+              state.column_offset = 0
+              break
+            end
+
             remaining_runs, next_column = vertical_paragraph(
               canvas, paragraph, context, layout_frame, font,
               left_limit, next_column
@@ -45,6 +55,87 @@ module Idml
           state.paragraphs = state.paragraphs[pending..]
         end
 
+        # Keep options in vertical mode (TODO 153, column-count
+        # approximation — one column per run under-estimates runs
+        # that span several columns, so deferral errs toward
+        # placing): KeepAllLinesTogether defers the paragraph
+        # wholly to the next frame; KeepWithNext also defers when
+        # the follower (or its forced break) would strand. Never
+        # defers the frame's first paragraph — the progress
+        # guarantee, shared with KeepPolicy.
+        def vertical_keep_deferred?(paragraph, next_paragraph,
+                                    layout_frame, _font, left_limit,
+                                    next_column, pending, entry_offset)
+          placed = pending.positive? || entry_offset.positive?
+          return false unless placed
+          return false unless keep_flagged?(paragraph)
+
+          needed = [paragraph.runs.length, 1].max
+          room = vertical_room(layout_frame, paragraph, left_limit,
+                               next_column)
+          return true if keep_all_deferred?(paragraph, needed, room)
+          return true if window_deferred?(paragraph, needed, room)
+
+          with_next_deferred?(paragraph, next_paragraph, layout_frame,
+                              left_limit, next_column, needed)
+        end
+
+        def keep_flagged?(paragraph)
+          paragraph.keep_all_lines_together ||
+            !paragraph.keep_with_next.nil? ||
+            paragraph.keep_first_lines ||
+            paragraph.keep_last_lines
+        end
+
+        def keep_all_deferred?(paragraph, needed, room)
+          paragraph.keep_all_lines_together && needed > room
+        end
+
+        # Keep windows on the same column-count approximation:
+        # defer a splitting paragraph when fewer than
+        # KeepFirstLines columns fit, or when the stranded tail
+        # would hold fewer than KeepLastLines columns.
+        def window_deferred?(paragraph, needed, room)
+          return false unless needed > room
+
+          if paragraph.keep_first_lines &&
+              room < paragraph.keep_first_lines
+            return true
+          end
+
+          paragraph.keep_last_lines &&
+            (needed - room) < paragraph.keep_last_lines
+        end
+
+        def with_next_deferred?(paragraph, next_paragraph, layout_frame,
+                                left_limit, next_column, needed)
+          return false if paragraph.keep_with_next.nil?
+
+          follower_needed = [next_paragraph&.runs&.length || 1, 1].max
+          follower_break = KeepPolicy.paragraph_break?(next_paragraph)
+          room = vertical_room(layout_frame, paragraph, left_limit,
+                               next_column)
+          follower_break || needed + follower_needed > room
+        end
+
+        def vertical_room(layout_frame, paragraph, left_limit,
+                          next_column)
+          leading = TextEngine::VerticalLayout.leading_for(
+            paragraph.auto_leading,
+            paragraph.runs.first&.point_size ||
+              TextFrameRenderer::DEFAULT_SIZE,
+          )
+          vertical_available_columns(layout_frame, leading, left_limit,
+                                     next_column)
+        end
+
+        def vertical_available_columns(layout_frame, leading, left_limit,
+                                       next_column)
+          right = layout_frame.x + layout_frame.width -
+            (layout_frame.inset_right || 0)
+          (((right - left_limit) / leading).floor - next_column).to_i
+        end
+
         # Folds a chain-resumed paragraph (runs_remaining) back to
         # the head of the paragraph list so the vertical path sees a
         # uniform sequence. The consumed column offset persists in

data/lib/idml/render/style_resolver.rb

@@ -70,6 +70,9 @@ module Idml
         :maximum_letter_spacing,
         :maximum_glyph_scaling,
         :minimum_glyph_scaling,
+        # ParagraphDirection (LeftToRightDirection /
+        # RightToLeftDirection) — mirrors alignment under RTL.
+        :paragraph_direction,
         # Forced paragraph break (StartParagraph: NextPage /
         # NextColumn / NextFrame / NextOddPage / NextEvenPage).
         :start_paragraph,
@@ -197,6 +200,9 @@ module Idml
           paragraph = Paragraph.new(
             runs: runs,
             alignment: runs.first.alignment,
+            paragraph_direction: resolve_attr(
+              style_lookup, psr, :paragraph_direction
+            ),
             space_before: resolve_attr(style_lookup, psr, :space_before),
             space_after: resolve_attr(style_lookup, psr, :space_after),
             first_line_indent: resolve_attr(style_lookup, psr,

data/lib/idml/render/text_wrap_resolver.rb

@@ -18,7 +18,7 @@ module Idml
     class TextWrapResolver
       # A wrap contour: a PDF-coordinate rectangle the text avoids.
       Contour = Struct.new(
-        :x, :y, :width, :height, :inverse, :side, :jump,
+        :x, :y, :width, :height, :inverse, :side, :jump, :next_column,
         keyword_init: true
       )
 
@@ -100,9 +100,10 @@ module Idml
         return [0.0, 0.0] if overlap.zero?
 
         # 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
+        # object — the full frame width is blocked. The renderer
+        # either skips below (JumpObject) or jumps column
+        # (NextColumn in multi-column frames).
+        return [frame_right - frame_x, 0.0] if blocks_full_width?(contour)
 
         interval_side_adjustment(contour.side, contour.x,
                                  contour.x + contour.width, overlap,
@@ -115,7 +116,7 @@ module Idml
       # jump contour blocks the band.
       def jump_contour_bottom(line_y, line_height, frame_x, frame_right)
         bottoms = @contours.filter_map do |contour|
-          next unless box_contour?(contour) && contour.jump
+          next unless skip_contour?(contour)
           next unless y_overlap?(contour, line_y, line_height) &&
             x_overlap?(contour, frame_x, frame_right)
 
@@ -124,6 +125,25 @@ module Idml
         bottoms.min
       end
 
+      # Contours whose block resolves as skip-below (both jump
+      # flavors report a resume point; the renderer chooses).
+      def skip_contour?(contour)
+        box_contour?(contour) &&
+          (contour.jump || contour.next_column)
+      end
+      private :skip_contour?
+
+      # True when a NextColumn contour blocks the given band: in a
+      # multi-column frame the renderer abandons the column and
+      # the chain resumes in the next one.
+      def next_column_block?(line_y, line_height, frame_x, frame_right)
+        @contours.any? do |contour|
+          box_contour?(contour) && contour.next_column &&
+            y_overlap?(contour, line_y, line_height) &&
+            x_overlap?(contour, frame_x, frame_right)
+        end
+      end
+
       def box_contour?(contour)
         !contour.is_a?(WrapContour::Shape)
       end
@@ -136,6 +156,14 @@ module Idml
       # shift); RightSide moves text past its right edge (reduce +
       # shift); LargestArea picks the roomier side; BothSides and
       # the spine variants reduce by `overlap` only.
+      # JumpObject / NextColumn both forbid text beside the
+      # object; the renderer decides between skip-below and
+      # column jump.
+      def blocks_full_width?(contour)
+        contour.jump || contour.next_column
+      end
+      private :blocks_full_width?
+
       def interval_side_adjustment(side, obj_left, obj_right, overlap,
                                    frame_x, frame_right)
         case side
@@ -185,11 +213,13 @@ module Idml
 
         rect = Geometry.placement_rect(bounds, item.item_transform,
                                        page_height)
+        mode = pref&.text_wrap_mode
         Contour.new(
           x: rect[:x], y: rect[:y],
           width: rect[:width], height: rect[:height],
           side: pref&.text_wrap_side,
-          jump: JUMP_MODES.include?(pref&.text_wrap_mode)
+          jump: mode == "JumpObjectTextWrap",
+          next_column: mode == "NextColumnTextWrap"
         )
       end
       private_class_method :box_contour

data/lib/idml/text_engine/justifier.rb

@@ -21,13 +21,13 @@ module Idml
       DEFAULT_MIN_GLYPH_SCALING = 100.0
 
       def self.justify(line:, frame_width:, alignment: :left,
-                       last_line: false, limits: nil)
-        new(frame_width, alignment, last_line, limits).justify(line)
+                       last_line: false, limits: nil, direction: nil)
+        new(frame_width, alignment, last_line, limits, direction).justify(line)
       end
 
-      def initialize(frame_width, alignment, last_line, limits)
+      def initialize(frame_width, alignment, last_line, limits, direction)
         @frame_width = frame_width
-        @alignment = alignment
+        @alignment = mirrored_alignment(alignment, direction)
         @last_line = last_line
         @limits = limits
       end
@@ -44,7 +44,18 @@ module Idml
         line
       end
 
-      private
+      RTL_ALIGNMENT_MIRROR = {
+        left: :right, right: :left,
+        start: :end, end: :start
+      }.freeze
+
+      # RightToLeftDirection mirrors the visual alignment: what is
+      # "left" in an LTR paragraph sits right in an RTL one.
+      def mirrored_alignment(alignment, direction)
+        return alignment unless direction == "RightToLeftDirection"
+
+        RTL_ALIGNMENT_MIRROR[alignment] || alignment
+      end
 
       # The paragraph's last line stays ragged under full
       # justification.

data/lib/idml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.13
+  version: 0.10.15
 platform: ruby
 authors:
 - Ribose
@@ -216,6 +216,10 @@ files:
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/150-architecture-round-three.md
 - TODO.pdf/151-schema-conformance.md
+- TODO.pdf/152-rtl-alignment.md
+- TODO.pdf/153-vertical-keeps.md
+- TODO.pdf/154-vertical-keep-windows.md
+- TODO.pdf/155-next-column-jump.md
 - TODO.pdf/16-typed-model-pipeline.md
 - TODO.pdf/17-shape-rendering.md
 - TODO.pdf/18-text-rendering.md