idml 0.8.9 → 0.9.2

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

@@ -25,6 +25,7 @@ module Idml
       # FontMetrics is available (no shaper → no wrap → rough output).
       class TextFrameRenderer
         DEFAULT_SIZE = 12.0
+        RUBY_SIZE_FACTOR = 0.5
 
         def self.render(canvas, context)
           frame = context.item
@@ -445,6 +446,12 @@ module Idml
 
           emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
                                   frame_left, frame_right, first_paragraph)
+          block_top, block_bottom = paragraph_block_extent(
+            paragraph, font, wrap_width, cursor_y, bottom_limit
+          )
+          ParagraphRules.emit_shading(canvas, paragraph, context,
+                                      block_top, block_bottom,
+                                      frame_left, frame_right)
           drop_cap = emit_drop_cap(canvas, paragraph, context, frame_left,
                                    cursor_y, first_paragraph)
 
@@ -463,10 +470,28 @@ module Idml
                                                 cursor_y, frame_left,
                                                 frame_right, para_attrs,
                                                 remaining_runs)
+          ParagraphRules.emit_border(canvas, paragraph, context,
+                                     block_top, block_bottom,
+                                     frame_left, frame_right)
           [remaining_runs, cursor_y, char_cursor]
         end
         private_class_method :render_runs_for_paragraph
 
+        # The paragraph's block extent: top at the current cursor,
+        # bottom at the pre-measured height clamped to the frame's
+        # bottom limit. Shading and border both use this one rect so
+        # they agree even when the paragraph splits across frames
+        # (the split case shades only the rendered part).
+        def self.paragraph_block_extent(paragraph, font, wrap_width,
+                                        cursor_y, bottom_limit)
+          height = TextEngine::Measurement.paragraph_height(
+            paragraph, font, wrap_width
+          )
+          block_bottom = [cursor_y - height, bottom_limit].max
+          [cursor_y, block_bottom]
+        end
+        private_class_method :paragraph_block_extent
+
         def self.iterate_paragraph_runs(canvas, paragraph, runs, context,
                                         layout_frame, font, wrap_width,
                                         cursor_y, bottom_limit, char_cursor,
@@ -486,7 +511,8 @@ module Idml
               canvas, run, paragraph, context, layout_frame, font,
               run_wrap, cursor_y, space_before,
               para_attrs[:first_line_indent], para_attrs[:left_indent],
-              char_cursor, bottom_limit
+              char_cursor, bottom_limit,
+              paragraph_last: run.equal?(runs.last)
             )
             char_cursor += positioned.length
             cursor_y = next_y
@@ -687,7 +713,7 @@ module Idml
         def self.layout_run(canvas, run, paragraph, context, layout_frame,
                             font, wrap_width, cursor_y, space_before,
                             first_line_indent, left_indent,
-                            char_cursor, bottom_limit)
+                            char_cursor, bottom_limit, paragraph_last: false)
           size = run.point_size || DEFAULT_SIZE
           glyphs = TextEngine::Shaper.shape(
             text: run.text, font: font, size: size,
@@ -695,12 +721,7 @@ module Idml
           lines = TextEngine::LineBreaker.break(
             glyphs: glyphs, frame_width: wrap_width,
           )
-          lines.each do |line|
-            TextEngine::Justifier.justify(
-              line: line, frame_width: wrap_width,
-              alignment: paragraph.alignment || :left
-            )
-          end
+          justify_lines(lines, paragraph, wrap_width, paragraph_last)
           leading = leading_for(paragraph, size)
 
           positioned, next_y = TextEngine::VerticalLayout.layout_block(
@@ -714,15 +735,41 @@ module Idml
             left_indent: left_indent,
           )
 
-          positioned.each do |line|
+          emit_run_lines(canvas, positioned, run, context, size, font,
+                         bottom_limit, char_cursor)
+          [positioned, next_y]
+        end
+        private_class_method :layout_run
+
+        # Justifies the run's lines; only the final line of the
+        # paragraph's final run stays ragged under full
+        # justification.
+        def self.justify_lines(lines, paragraph, wrap_width,
+                               paragraph_last)
+          lines.each_with_index do |line, index|
+            TextEngine::Justifier.justify(
+              line: line, frame_width: wrap_width,
+              alignment: paragraph.alignment || :left,
+              last_line: paragraph_last && index == lines.length - 1
+            )
+          end
+        end
+        private_class_method :justify_lines
+
+        # Emits the run's positioned lines (clipped at the bottom
+        # limit), recording positions and annotating the first line
+        # with the run's ruby when present.
+        def self.emit_run_lines(canvas, positioned, run, context, size,
+                                font, bottom_limit, char_cursor)
+          positioned.each_with_index do |line, index|
             break if line.y < bottom_limit
 
             emit_line(canvas, line, run, context, size)
             record_position(context, line, size, char_cursor)
+            emit_ruby(canvas, run, line, size, font, context) if index.zero?
           end
-          [positioned, next_y]
         end
-        private_class_method :layout_run
+        private_class_method :emit_run_lines
 
         # Emits one positioned line: applies character-level styling
         # (fill color + tint, capitalization, position, tracking,
@@ -755,6 +802,36 @@ module Idml
         end
         private_class_method :emit_line
 
+        # Emits the run's ruby (phonetic annotation) above the first
+        # line of the annotated run, centered over the line's width.
+        # RubyFontSize defaults to half the base size; RubyPosition
+        # values containing "Below" place it under the base text.
+        # Approximation: IDML attaches ruby to a character range;
+        # we annotate the whole first line.
+        def self.emit_ruby(canvas, run, line, base_size, font, context)
+          ruby_text = run.ruby_string
+          return if ruby_text.nil? || ruby_text.empty?
+
+          ruby_size = run.ruby_font_size || (base_size * RUBY_SIZE_FACTOR)
+          glyphs = TextEngine::Shaper.shape(text: ruby_text, font: font,
+                                            size: ruby_size)
+          ruby_width = glyphs.sum(&:width)
+          x = line.x + ((line.width - ruby_width) / 2)
+          y = ruby_y(run, line, base_size, ruby_size)
+          canvas.text(ruby_text, at: [x, y],
+                                 font: font_for_run(run, context), size: ruby_size)
+        end
+        private_class_method :emit_ruby
+
+        def self.ruby_y(run, line, base_size, ruby_size)
+          if run.ruby_position.to_s.include?("Below")
+            line.y - (base_size * 0.25) - ruby_size
+          else
+            line.y + (base_size * 0.45) + ruby_size
+          end
+        end
+        private_class_method :ruby_y
+
         def self.leading_for(paragraph, size)
           TextEngine::VerticalLayout.leading_for(paragraph.auto_leading, size)
         end

data/lib/idml/render/style_resolver.rb

@@ -43,6 +43,11 @@ module Idml
         :baseline_shift,
         :footnote_number,
         :footnote_paragraphs,
+        # Ruby (phonetic annotation) — from the CSR's Ruby*
+        # attributes. Present only on runs with a RubyString.
+        :ruby_string,
+        :ruby_font_size,
+        :ruby_position,
         keyword_init: true,
       )
 
@@ -82,6 +87,28 @@ module Idml
         :rule_below_left_indent,
         :rule_below_right_indent,
         :rule_below_width,
+        # ParagraphShading — fill rect behind the paragraph block.
+        # Color comes from Properties > ParagraphShadingColor.
+        :paragraph_shading_on,
+        :paragraph_shading_color,
+        :paragraph_shading_tint,
+        :paragraph_shading_width,
+        :paragraph_shading_left_offset,
+        :paragraph_shading_right_offset,
+        :paragraph_shading_top_offset,
+        :paragraph_shading_bottom_offset,
+        # ParagraphBorder — per-side strokes around the paragraph.
+        :paragraph_border_on,
+        :paragraph_border_color,
+        :paragraph_border_tint,
+        :paragraph_border_top_line_weight,
+        :paragraph_border_left_line_weight,
+        :paragraph_border_right_line_weight,
+        :paragraph_border_bottom_line_weight,
+        :paragraph_border_top_offset,
+        :paragraph_border_left_offset,
+        :paragraph_border_right_offset,
+        :paragraph_border_bottom_offset,
         keyword_init: true,
       )
 
@@ -171,7 +198,8 @@ module Idml
             rule_above: resolve_attr(style_lookup, psr, :rule_above),
             rule_above_line_weight: resolve_attr(style_lookup, psr,
                                                  :rule_above_line_weight),
-            rule_above_color: resolve_attr(style_lookup, psr, :stroke_color),
+            rule_above_color: properties_color(psr, :rule_above_color) ||
+                             resolve_attr(style_lookup, psr, :stroke_color),
             rule_above_tint: resolve_attr(style_lookup, psr,
                                           :rule_above_tint),
             rule_above_offset: resolve_attr(style_lookup, psr,
@@ -185,7 +213,8 @@ module Idml
             rule_below: resolve_attr(style_lookup, psr, :rule_below),
             rule_below_line_weight: resolve_attr(style_lookup, psr,
                                                  :rule_below_line_weight),
-            rule_below_color: resolve_attr(style_lookup, psr, :stroke_color),
+            rule_below_color: properties_color(psr, :rule_below_color) ||
+                             resolve_attr(style_lookup, psr, :stroke_color),
             rule_below_tint: resolve_attr(style_lookup, psr,
                                           :rule_below_tint),
             rule_below_offset: resolve_attr(style_lookup, psr,
@@ -196,12 +225,70 @@ module Idml
                                                   :rule_below_right_indent),
             rule_below_width: resolve_attr(style_lookup, psr,
                                            :rule_below_width),
+            paragraph_shading_on: resolve_attr(style_lookup, psr,
+                                               :paragraph_shading_on),
+            paragraph_shading_color: properties_color(psr,
+                                                      :paragraph_shading_color),
+            paragraph_shading_tint: resolve_attr(style_lookup, psr,
+                                                 :paragraph_shading_tint),
+            paragraph_shading_width: resolve_attr(style_lookup, psr,
+                                                  :paragraph_shading_width),
+            paragraph_shading_left_offset: resolve_attr(
+              style_lookup, psr, :paragraph_shading_left_offset
+            ),
+            paragraph_shading_right_offset: resolve_attr(
+              style_lookup, psr, :paragraph_shading_right_offset
+            ),
+            paragraph_shading_top_offset: resolve_attr(
+              style_lookup, psr, :paragraph_shading_top_offset
+            ),
+            paragraph_shading_bottom_offset: resolve_attr(
+              style_lookup, psr, :paragraph_shading_bottom_offset
+            ),
+            paragraph_border_on: resolve_attr(style_lookup, psr,
+                                              :paragraph_border_on),
+            paragraph_border_color: properties_color(psr,
+                                                     :paragraph_border_color),
+            paragraph_border_tint: resolve_attr(style_lookup, psr,
+                                                :paragraph_border_tint),
+            paragraph_border_top_line_weight: resolve_attr(
+              style_lookup, psr, :paragraph_border_top_line_weight
+            ),
+            paragraph_border_left_line_weight: resolve_attr(
+              style_lookup, psr, :paragraph_border_left_line_weight
+            ),
+            paragraph_border_right_line_weight: resolve_attr(
+              style_lookup, psr, :paragraph_border_right_line_weight
+            ),
+            paragraph_border_bottom_line_weight: resolve_attr(
+              style_lookup, psr, :paragraph_border_bottom_line_weight
+            ),
+            paragraph_border_top_offset: resolve_attr(
+              style_lookup, psr, :paragraph_border_top_offset
+            ),
+            paragraph_border_left_offset: resolve_attr(
+              style_lookup, psr, :paragraph_border_left_offset
+            ),
+            paragraph_border_right_offset: resolve_attr(
+              style_lookup, psr, :paragraph_border_right_offset
+            ),
+            paragraph_border_bottom_offset: resolve_attr(
+              style_lookup, psr, :paragraph_border_bottom_offset
+            ),
           )
           prepend_list_marker(paragraph)
           paragraph
         end
       end
 
+      # Reads a color value element from the PSR's Properties (e.g.
+      # Properties > ParagraphShadingColor). Returns the color name
+      # string, or nil when the element is absent.
+      def self.properties_color(psr, element_attr)
+        psr.properties.first&.public_send(element_attr)&.value
+      end
+      private_class_method :properties_color
+
       def self.csr_runs(psr, condition_filter: nil, style_lookup: nil,
                         footnote_counter: nil, footnote_option: nil)
         counter = footnote_counter || Footnote.counter_for(footnote_option)
@@ -266,6 +353,9 @@ module Idml
                                         :horizontal_scale),
           vertical_scale: resolve_csr(style_lookup, csr, :vertical_scale),
           baseline_shift: resolve_csr(style_lookup, csr, :baseline_shift),
+          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),
         )
       end
       private_class_method :text_run

data/lib/idml/text_engine/justifier.rb

@@ -4,19 +4,22 @@ module Idml
   module TextEngine
     # Distributes slack space within a line per the paragraph's
     # alignment. Adjusts x_offset and optionally scales inter-word
-    # spaces for justified text.
+    # spaces for justified text. `last_line:` (the paragraph's final
+    # line) keeps ragged right under :justified, as InDesign does.
     class Justifier
-      def self.justify(line:, frame_width:, alignment: :left)
-        new(frame_width, alignment).justify(line)
+      def self.justify(line:, frame_width:, alignment: :left,
+                       last_line: false)
+        new(frame_width, alignment, last_line).justify(line)
       end
 
-      def initialize(frame_width, alignment)
+      def initialize(frame_width, alignment, last_line)
         @frame_width = frame_width
         @alignment = alignment
+        @last_line = last_line
       end
 
       def justify(line)
-        case @alignment
+        case effective_alignment
         when :left, :start then line.x_offset = 0
         when :center, :middle
           line.x_offset = (@frame_width - line.width) / 2
@@ -29,6 +32,14 @@ module Idml
 
       private
 
+      # The paragraph's last line stays ragged under full
+      # justification.
+      def effective_alignment
+        return :left if @alignment == :justified && @last_line
+
+        @alignment
+      end
+
       def justify_line(line)
         spaces = line.glyphs.count(&:is_space)
         slack = @frame_width - line.width

data/lib/idml/text_engine/line_breaker.rb

@@ -7,10 +7,20 @@ module Idml
 
     # Greedy word-wrap line breaker. Accumulates glyphs until
     # exceeding the frame width, then breaks at the last space.
+    # CJK runs get a kinsoku shori post-pass (no line starts or
+    # ends with a forbidden character).
     class LineBreaker
       def self.break(glyphs:, frame_width:)
-        new(frame_width).break(glyphs)
+        lines = new(frame_width).break(glyphs)
+        return lines unless cjk_run?(glyphs)
+
+        CjkLayout.apply_kinsoku(lines)
+      end
+
+      def self.cjk_run?(glyphs)
+        glyphs.any? { |glyph| CjkLayout.cjk?(glyph.codepoint) }
       end
+      private_class_method :cjk_run?
 
       def initialize(frame_width)
         @frame_width = frame_width

data/lib/idml/text_engine/measurement.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Idml
+  module TextEngine
+    # Height measurement for paragraphs — shape + wrap each run and
+    # sum the line count × leading. Used where a paragraph's full
+    # extent must be known before its lines are laid out (paragraph
+    # shading/border rects).
+    module Measurement
+      DEFAULT_POINT_SIZE = 12.0
+
+      # Returns the paragraph's rendered height at `wrap_width`:
+      # every run's wrapped line count × leading, plus paragraph
+      # SpaceBefore / SpaceAfter.
+      def self.paragraph_height(paragraph, font, wrap_width)
+        lines_height = paragraph.runs.sum do |run|
+          size = run.point_size || DEFAULT_POINT_SIZE
+          lines = wrapped_lines(run, font, wrap_width, size)
+          lines.length *
+            TextEngine::VerticalLayout.leading_for(paragraph.auto_leading,
+                                                   size)
+        end
+        lines_height + space_before_after(paragraph)
+      end
+
+      def self.wrapped_lines(run, font, wrap_width, size)
+        glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
+                                          size: size)
+        TextEngine::LineBreaker.break(glyphs: glyphs,
+                                      frame_width: wrap_width)
+      end
+      private_class_method :wrapped_lines
+
+      def self.space_before_after(paragraph)
+        (paragraph.space_before || 0) + (paragraph.space_after || 0)
+      end
+      private_class_method :space_before_after
+    end
+  end
+end

data/lib/idml/text_engine.rb

@@ -6,7 +6,8 @@ module Idml
   # .ttf/.otf files. IDML-agnostic — works on any styled text.
   module TextEngine
     autoload :PdfrbFontMetrics, "#{__dir__}/text_engine/pdfrb_font_metrics"
-    autoload :Shaper,          "#{__dir__}/text_engine/shaper"
+    autoload :Shaper, "#{__dir__}/text_engine/shaper"
+    autoload :Measurement, "#{__dir__}/text_engine/measurement"
     autoload :ShapedGlyph,     "#{__dir__}/text_engine/shaper"
     autoload :LineBreaker,     "#{__dir__}/text_engine/line_breaker"
     autoload :Line,            "#{__dir__}/text_engine/line_breaker"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.9.2
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-17 00:00:00.000000000 Z
+date: 2026-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -173,6 +173,8 @@ files:
 - TODO.pdf/114-text-wrap-around-shapes.md
 - TODO.pdf/115-bullet-numbered-lists.md
 - TODO.pdf/116-applied-style-resolution.md
+- TODO.pdf/116-justification-last-line.md
+- TODO.pdf/117-endnote-support.md
 - TODO.pdf/12-idml-to-pdf-pipeline.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
@@ -291,6 +293,8 @@ files:
 - lib/idml/elements/document_object.rb
 - lib/idml/elements/dotted_stroke_style.rb
 - lib/idml/elements/drop_shadow_setting.rb
+- lib/idml/elements/endnote.rb
+- lib/idml/elements/endnote_range.rb
 - lib/idml/elements/feather_setting.rb
 - lib/idml/elements/fill_transparency_setting.rb
 - lib/idml/elements/flex_layout_attribute_option.rb
@@ -407,6 +411,7 @@ files:
 - lib/idml/elements/transform_attribute_option.rb
 - lib/idml/elements/transparency_setting.rb
 - lib/idml/elements/trap_preset.rb
+- lib/idml/elements/typed_value.rb
 - lib/idml/elements/xml_element.rb
 - lib/idml/elements/xml_export_map.rb
 - lib/idml/elements/xml_import_map.rb
@@ -484,6 +489,7 @@ files:
 - lib/idml/text_engine/cjk_layout.rb
 - lib/idml/text_engine/justifier.rb
 - lib/idml/text_engine/line_breaker.rb
+- lib/idml/text_engine/measurement.rb
 - lib/idml/text_engine/pdfrb_font_metrics.rb
 - lib/idml/text_engine/shaper.rb
 - lib/idml/text_engine/vertical_layout.rb