idml 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a713a0a63c6af7b6090c9a6260467db40ee9a7c497f37561dccf2526ceadaa71
-  data.tar.gz: a6695a7318b96ed6664e15b9e2a99e40d2da6ef05139154ba7ccfab73e3eeecf
+  metadata.gz: bdf6a3aba5bbe199af39e5addabae082b795dfef1583dd14f33a9d7415086ead
+  data.tar.gz: eb1a78bd1a11fdc7500543b903b4d927114a96a70fea97a7e8b4c62db813451e
 SHA512:
-  metadata.gz: 92e8aff4adbb8935c2e3ec7b7ead236458ec2f7171a2923eee9de63b4b4f0ed96d95f7f39c9c184d97643b0aa9096e3aa1b40e890610e82d514bb36b17c6f14b
-  data.tar.gz: 88c470bb2d55962f57a950fe6c1ef526d34ce36d7fafe38ed045d4f7019821586a9045d1f027e28eb304a1d0a57da9f157256603a83e48e873decd3f2620554c
+  metadata.gz: e47ca1b121cd27336a516f8b0cb863d5ad03edbdc43455bfa3efcb41807865a1dae4aec35ccbf380e003dc383d9f0d3704b42e23efa0d56c6925f316b68030c1
+  data.tar.gz: 3ac803ec48c5a0e2a2e3eec6f17845993a2a3194ddb8046bd5e8ea7225fcd8709abef22817684c12c51814b26a6ca9d3e07f2b4a735b519b9cb3d99e9eaaec5c

data/TODO.pdf/116-applied-style-resolution.md

@@ -1,6 +1,9 @@
 # TODO PDF 116: AppliedParagraphStyle / AppliedCharacterStyle resolution from Resources/Styles.xml
 
-## Status: OPEN — critical gap identified in 2026-08-10 audit
+## Status: DONE — `Render::StyleLookup` indexes ParagraphStyle and
+CharacterStyle from Resources/Styles.xml by Self. StyleResolver
+uses it to fill in formatting attributes that PSR/CSR elements don't
+declare inline. PSR/CSR inline attributes override style values.
 
 ## Problem
 

data/lib/idml/render/pipeline.rb

@@ -39,6 +39,7 @@ module Idml
         position_tracker = PositionTracker.new
         layer_filter = LayerFilter.from_designmap(@package.designmap)
         condition_filter = ConditionFilter.from_designmap(@package.designmap)
+        style_lookup = StyleLookup.from_package(@package)
         font_ref_resolver = FontReferenceResolver.build(@package)
         font_setup = FontSetup.new(package: @package,
                                    font_search_paths: @font_search_paths)
@@ -52,7 +53,7 @@ module Idml
                                      font_ref_resolver, font_resource,
                                      font_metrics, font_map, structure,
                                      position_tracker, condition_filter,
-                                     page_index)
+                                     style_lookup, page_index)
         end
 
         structure.flush(writer)
@@ -92,14 +93,16 @@ module Idml
 
       def render_spread(writer, spread, layer_filter, font_ref_resolver,
                         font_resource, font_metrics, font_map, structure,
-                        position_tracker, condition_filter, page_offset)
+                        position_tracker, condition_filter, style_lookup,
+                        page_offset)
         pages = spread.spread.flat_map(&:page)
         image_refs = ImageCollector.new(writer: writer,
                                         base_dir: File.dirname(@package.path),
                                         page_height: DEFAULT_HEIGHT).collect(spread)
         renderer = build_renderer(layer_filter, font_ref_resolver,
                                   font_resource, font_metrics, font_map,
-                                  structure, position_tracker, condition_filter)
+                                  structure, position_tracker, condition_filter,
+                                  style_lookup)
         current = page_offset
 
         pages.each do |page|
@@ -129,7 +132,7 @@ module Idml
 
       def build_renderer(layer_filter, font_ref_resolver, font_resource,
                          font_metrics, font_map, structure, position_tracker,
-                         condition_filter)
+                         condition_filter, style_lookup)
         SpreadRenderer.new(
           font_metrics: font_metrics,
           font_ps_name: font_resource,
@@ -140,6 +143,7 @@ module Idml
           structure: structure,
           position_tracker: position_tracker,
           condition_filter: condition_filter,
+          style_lookup: style_lookup,
         )
       end
 

data/lib/idml/render/render_context.rb

@@ -22,6 +22,7 @@ module Idml
       :position_tracker,
       :chain_controller,
       :condition_filter,
+      :style_lookup,
       keyword_init: true,
     )
   end

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

@@ -71,7 +71,8 @@ module Idml
 
         def self.fresh_state(story, context)
           paragraphs = StyleResolver.extract_paragraphs(
-            story, condition_filter: context.condition_filter
+            story, condition_filter: context.condition_filter,
+                   style_lookup: context.style_lookup
           )
           return nil if paragraphs.empty?
 

data/lib/idml/render/spread_renderer.rb

@@ -8,7 +8,7 @@ module Idml
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil,
                      position_tracker: nil, font_map: {},
-                     condition_filter: nil)
+                     condition_filter: nil, style_lookup: nil)
         @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
@@ -18,6 +18,7 @@ module Idml
         @position_tracker = position_tracker
         @font_map = font_map
         @condition_filter = condition_filter
+        @style_lookup = style_lookup
       end
 
       def render(canvas, spread, page_width:, page_height:, image_refs: [],
@@ -37,6 +38,7 @@ module Idml
           position_tracker: @position_tracker,
           chain_controller: StoryChainController.new,
           condition_filter: @condition_filter,
+          style_lookup: @style_lookup,
         }
 
         canvas.save_graphics_state do

data/lib/idml/render/style_lookup.rb

@@ -0,0 +1,78 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Resolves `AppliedParagraphStyle` and `AppliedCharacterStyle`
+    # references to their style definitions in Resources/Styles.xml.
+    # Built once per render pass from `Parts::Style`; StyleResolver
+    # consults it to fill in formatting attributes that the PSR/CSR
+    # element doesn't declare inline.
+    #
+    # Merge semantics: PSR/CSR inline attributes override style
+    # attributes. When the PSR/CSR declares a value (non-nil), that
+    # wins. When it doesn't, the style definition's value is used
+    # as a default. When neither declares a value, the attribute
+    # remains nil and the renderer applies its own default.
+    class StyleLookup
+      def self.from_package(package)
+        styles = package&.style
+        return new({}, {}) unless styles
+
+        para_styles = index_styles(styles.paragraph_style)
+        char_styles = index_styles(styles.character_style)
+        new(para_styles, char_styles)
+      end
+
+      def initialize(para_styles, char_styles)
+        @para_styles = para_styles
+        @char_styles = char_styles
+      end
+
+      # Returns the ParagraphStyle referenced by `self_ref`, or nil.
+      # `self_ref` is the PSR's AppliedParagraphStyle value (e.g.,
+      # "ParagraphStyle/$ID/NormalParagraphStyle").
+      def paragraph_style(self_ref)
+        return nil unless self_ref
+
+        @para_styles[self_ref]
+      end
+
+      # Returns the CharacterStyle referenced by `self_ref`, or nil.
+      def character_style(self_ref)
+        return nil unless self_ref
+
+        @char_styles[self_ref]
+      end
+
+      # Returns the value of `attr_name` from the PSR, or from the
+      # referenced ParagraphStyle when the PSR doesn't declare it.
+      # Uses `public_send` (not `send`) to stay within public API
+      # boundaries — the attribute readers generated by lutaml-model
+      # are public.
+      def resolve_para_attr(psr, attr_name)
+        psr_value = psr.public_send(attr_name)
+        return psr_value unless psr_value.nil?
+
+        style = paragraph_style(psr.applied_paragraph_style)
+        style&.public_send(attr_name)
+      end
+
+      # Returns the value of `attr_name` from the CSR, or from the
+      # referenced CharacterStyle when the CSR doesn't declare it.
+      def resolve_char_attr(csr, attr_name)
+        csr_value = csr.public_send(attr_name)
+        return csr_value unless csr_value.nil?
+
+        style = character_style(csr.applied_character_style)
+        style&.public_send(attr_name)
+      end
+
+      def self.index_styles(collection)
+        collection.each_with_object({}) do |style, hash|
+          hash[style.self_attr] = style if style.self_attr
+        end
+      end
+      private_class_method :index_styles
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -110,53 +110,74 @@ module Idml
       # its runs and carries the paragraph-level attributes from the
       # owning PSR. Empty paragraphs (no runs after filtering) are
       # skipped.
-      def self.extract_paragraphs(story, condition_filter: nil)
+      def self.extract_paragraphs(story, condition_filter: nil,
+                                  style_lookup: nil)
         return [] unless story&.inner
 
         story.inner.paragraph_style_range.filter_map do |psr|
           next unless condition_visible?(psr, condition_filter)
 
-          runs = csr_runs(psr, condition_filter: condition_filter)
+          runs = csr_runs(psr, condition_filter: condition_filter,
+                               style_lookup: style_lookup)
           next if runs.empty?
 
           paragraph = Paragraph.new(
             runs: runs,
             alignment: runs.first.alignment,
-            space_before: psr.space_before,
-            space_after: psr.space_after,
-            first_line_indent: psr.first_line_indent,
-            left_indent: psr.left_indent,
-            right_indent: psr.right_indent,
-            auto_leading: psr.auto_leading,
-            drop_cap_lines: psr.drop_cap_lines,
-            drop_cap_characters: psr.drop_cap_characters,
-            bullets_and_numbering_list_type: psr.bullets_and_numbering_list_type,
-            bullet_character_value: psr.bullet_character_value,
-            bullets_text_after: psr.bullets_text_after,
-            numbering_expression: psr.numbering_expression,
-            rule_above: psr.rule_above,
-            rule_above_line_weight: psr.rule_above_line_weight,
-            rule_above_color: psr.stroke_color,
-            rule_above_tint: psr.rule_above_tint,
-            rule_above_offset: psr.rule_above_offset,
-            rule_above_left_indent: psr.rule_above_left_indent,
-            rule_above_right_indent: psr.rule_above_right_indent,
-            rule_above_width: psr.rule_above_width,
-            rule_below: psr.rule_below,
-            rule_below_line_weight: psr.rule_below_line_weight,
-            rule_below_color: psr.stroke_color,
-            rule_below_tint: psr.rule_below_tint,
-            rule_below_offset: psr.rule_below_offset,
-            rule_below_left_indent: psr.rule_below_left_indent,
-            rule_below_right_indent: psr.rule_below_right_indent,
-            rule_below_width: psr.rule_below_width,
+            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,
+                                            :first_line_indent),
+            left_indent: resolve_attr(style_lookup, psr, :left_indent),
+            right_indent: resolve_attr(style_lookup, psr, :right_indent),
+            auto_leading: resolve_attr(style_lookup, psr, :auto_leading),
+            drop_cap_lines: resolve_attr(style_lookup, psr, :drop_cap_lines),
+            drop_cap_characters: resolve_attr(style_lookup, psr,
+                                              :drop_cap_characters),
+            bullets_and_numbering_list_type: resolve_attr(
+              style_lookup, psr, :bullets_and_numbering_list_type
+            ),
+            bullet_character_value: resolve_attr(style_lookup, psr,
+                                                 :bullet_character_value),
+            bullets_text_after: resolve_attr(style_lookup, psr,
+                                             :bullets_text_after),
+            numbering_expression: resolve_attr(style_lookup, psr,
+                                               :numbering_expression),
+            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_tint: resolve_attr(style_lookup, psr,
+                                          :rule_above_tint),
+            rule_above_offset: resolve_attr(style_lookup, psr,
+                                            :rule_above_offset),
+            rule_above_left_indent: resolve_attr(style_lookup, psr,
+                                                 :rule_above_left_indent),
+            rule_above_right_indent: resolve_attr(style_lookup, psr,
+                                                  :rule_above_right_indent),
+            rule_above_width: resolve_attr(style_lookup, psr,
+                                           :rule_above_width),
+            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_tint: resolve_attr(style_lookup, psr,
+                                          :rule_below_tint),
+            rule_below_offset: resolve_attr(style_lookup, psr,
+                                            :rule_below_offset),
+            rule_below_left_indent: resolve_attr(style_lookup, psr,
+                                                 :rule_below_left_indent),
+            rule_below_right_indent: resolve_attr(style_lookup, psr,
+                                                  :rule_below_right_indent),
+            rule_below_width: resolve_attr(style_lookup, psr,
+                                           :rule_below_width),
           )
           prepend_list_marker(paragraph)
           paragraph
         end
       end
 
-      def self.csr_runs(psr, condition_filter: nil)
+      def self.csr_runs(psr, condition_filter: nil, style_lookup: nil)
         psr.character_style_range.filter_map do |csr|
           next unless condition_visible?(csr, condition_filter)
 
@@ -165,29 +186,54 @@ module Idml
 
           StyledRun.new(
             text: text,
-            font_style: csr.font_style,
-            point_size: csr.point_size || DEFAULT_POINT_SIZE,
-            fill_color: csr.fill_color,
-            fill_tint: csr.fill_tint,
-            applied_font: csr.applied_font,
+            font_style: resolve_csr(style_lookup, csr, :font_style),
+            point_size: resolve_csr(style_lookup, csr, :point_size) ||
+                        DEFAULT_POINT_SIZE,
+            fill_color: resolve_csr(style_lookup, csr, :fill_color),
+            fill_tint: resolve_csr(style_lookup, csr, :fill_tint),
+            applied_font: resolve_csr(style_lookup, csr, :applied_font),
             alignment: alignment_for(csr),
-            tracking: csr.tracking,
-            capitalization: csr.capitalization,
-            position: csr.position,
-            underline: csr.underline,
-            underline_offset: csr.underline_offset,
-            underline_weight: csr.underline_weight,
-            strike_thru: csr.strike_thru,
-            strike_through_offset: csr.strike_through_offset,
-            strike_through_weight: csr.strike_through_weight,
-            horizontal_scale: csr.horizontal_scale,
-            vertical_scale: csr.vertical_scale,
-            baseline_shift: csr.baseline_shift,
+            tracking: resolve_csr(style_lookup, csr, :tracking),
+            capitalization: resolve_csr(style_lookup, csr, :capitalization),
+            position: resolve_csr(style_lookup, csr, :position),
+            underline: resolve_csr(style_lookup, csr, :underline),
+            underline_offset: resolve_csr(style_lookup, csr,
+                                          :underline_offset),
+            underline_weight: resolve_csr(style_lookup, csr,
+                                          :underline_weight),
+            strike_thru: resolve_csr(style_lookup, csr, :strike_thru),
+            strike_through_offset: resolve_csr(style_lookup, csr,
+                                               :strike_through_offset),
+            strike_through_weight: resolve_csr(style_lookup, csr,
+                                               :strike_through_weight),
+            horizontal_scale: resolve_csr(style_lookup, csr,
+                                          :horizontal_scale),
+            vertical_scale: resolve_csr(style_lookup, csr, :vertical_scale),
+            baseline_shift: resolve_csr(style_lookup, csr, :baseline_shift),
           )
         end
       end
       private_class_method :csr_runs
 
+      # Resolves a paragraph-level attribute from PSR or its
+      # referenced ParagraphStyle. When style_lookup is nil,
+      # falls back to reading the PSR directly (backward compat).
+      def self.resolve_attr(style_lookup, psr, attr_name)
+        return psr.public_send(attr_name) unless style_lookup
+
+        style_lookup.resolve_para_attr(psr, attr_name)
+      end
+      private_class_method :resolve_attr
+
+      # Resolves a character-level attribute from CSR or its
+      # referenced CharacterStyle.
+      def self.resolve_csr(style_lookup, csr, attr_name)
+        return csr.public_send(attr_name) unless style_lookup
+
+        style_lookup.resolve_char_attr(csr, attr_name)
+      end
+      private_class_method :resolve_csr
+
       # Drops the PSR/CSR when any of its AppliedConditions
       # references a hidden Condition. Returns true when no filter
       # is supplied (caller doesn't care about conditions).

data/lib/idml/render.rb

@@ -8,6 +8,7 @@ module Idml
     autoload :Image,               "#{__dir__}/render/image"
     autoload :ColorResolver,       "#{__dir__}/render/color_resolver"
     autoload :StyleResolver,       "#{__dir__}/render/style_resolver"
+    autoload :StyleLookup,         "#{__dir__}/render/style_lookup"
     autoload :FontReferenceResolver,
              "#{__dir__}/render/font_reference_resolver"
     autoload :GradientResolver,    "#{__dir__}/render/gradient_resolver"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-09 00:00:00.000000000 Z
+date: 2026-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -469,6 +469,7 @@ files:
 - lib/idml/render/stroke_style.rb
 - lib/idml/render/structure_mapper.rb
 - lib/idml/render/structure_tracker.rb
+- lib/idml/render/style_lookup.rb
 - lib/idml/render/style_resolver.rb
 - lib/idml/text_engine.rb
 - lib/idml/text_engine/cjk_layout.rb