idml 0.4.6 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f0fb65e931a0ba911043cdc0a885dab5d79257519b519896c07f8a8de9cc14
-  data.tar.gz: c25ece7b2f8d61ee13e7e572a3e4089cda665f307e20831a7a46cfa7c7c2ff52
+  metadata.gz: bfe99408096a550d69277aae9bf709c0dcb0257f17756fcef498c9ea3982a603
+  data.tar.gz: 83fc58f40dccb82324b6098aab6665765cd0e1a08b12ade7e08f6d600c6e69c3
 SHA512:
-  metadata.gz: e2113e93725afbf9d5c025b1d0b50d698b4bd0ef47815f7fda87a703e007627b769bbb1118b924ce6d932cf78aff23877d20de303b60f3a9df1cd51f53947849
-  data.tar.gz: 856b9aa6fad47550fd6da61a1ebbc348be2752cde9eb5a1a165beadfd8b16c5d2ed763d0b5af68af6252b2631561b1c521200cadae00bfdafb0a15a0807d702e
+  metadata.gz: 8b9646bd611f3618e6a7c3c689a402b368b231f66f6f06430098f9357179d4b79ae0884058b20c92df03dce6e65aa7cf74c245bb8100a772a9454c37f310b4bd
+  data.tar.gz: 7b639edc906f60c9e82128bf599966cd37e2fb0458e06e62158d14767d2293d918bed5fe75163cd2caa2cb20fed7174a0c18a709ac722a673b9099532e8f5b33

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    idml (0.4.6)
+    idml (0.4.8)
       bigdecimal
       lutaml-model (~> 0.8.18)
       pdfrb
@@ -183,7 +183,7 @@ CHECKSUMS
   ffi (1.17.4-x86_64-darwin) sha256=aa70390523cf3235096cf64962b709b4cfbd5c082a2cb2ae714eb0fe2ccda496
   ffi (1.17.4-x86_64-linux-gnu) sha256=9d3db14c2eae074b382fa9c083fe95aec6e0a1451da249eab096c34002bc752d
   ffi (1.17.4-x86_64-linux-musl) sha256=3fdf9888483de005f8ef8d1cf2d3b20d86626af206cbf780f6a6a12439a9c49e
-  idml (0.4.6)
+  idml (0.4.8)
   json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
   language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/TODO.pdf/84-schema-faithful-table.md

@@ -48,15 +48,21 @@ The existing `Elements::Table`/`TableRow`/`TableCell` classes
 `table_renderer_spec.rb` test. They are not removed because no
 real IDML uses them and removing them would break the existing test.
 
-## Future work
-
-- Migrate `TableRenderer` to use the schema-faithful `cell`/`row`
-  collections instead of legacy `table_row`. The renderer is the
-  last consumer of the legacy structure.
-- Render Tables discovered in Stories (currently only Spread-level
-  tables are dispatched to TableRenderer; CSR-embedded Tables are
-  skipped — they need TextFrameRenderer integration to render in
-  place).
+## What was completed in this round
+
+- `TableRenderer` migrated to auto-detect schema-faithful
+  (`cell`/`row` siblings) vs legacy (`table_row`/`table_cell`
+  nested) layout. New `SchemaLayout` Struct computes per-cell rects
+  from `Row#single_row_height` and `Cell#col_row` max col + 1.
+- `TextFrameRenderer` discovers inline Tables via
+  `Story > PSR > CSR > Table` and renders each within the frame's
+  bounds via `TableRenderer.render_in_box`. This is the path that
+  real IDML fixtures use (Tables live in Stories, not Spreads).
+- New `TableRenderer.render_in_box(canvas, table, box, context)`
+  API accepts caller-supplied bounds (real Tables have no own
+  geometry).
+- The sample-with-table-more fixture's Table now renders 83 cell
+  rectangles end-to-end (verified by spec).
 
 ## Current state vs schema
 

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

@@ -3,10 +3,22 @@
 module Idml
   module Render
     module Renderers
-      # Renders an IDML Table. Draws the cell grid via rectangle ops,
-      # then renders inline `<CharacterStyleRange>` text in each cell
-      # via `canvas.text_rich`. Cells with no text render as empty
+      # Renders an IDML Table. Draws the cell grid via rectangle
+      # ops, then renders inline text in each cell via
+      # `canvas.text_rich`. Cells with no text render as empty
       # rectangles.
+      #
+      # Two table layouts are supported:
+      #
+      #   1. **Schema-faithful** (real IDML): `Table` has `cell`
+      #      and `row` sibling collections. Cell `Name` encodes
+      #      column and row as `"col:row"`. Row order determines
+      #      vertical position; cell Name determines horizontal.
+      #   2. **Legacy** (synthetic test fixture): `Table` has a
+      #      `table_row` collection, each `TableRow` has a
+      #      `table_cell` collection. Nested structure.
+      #
+      # The renderer auto-detects which layout is present.
       class TableRenderer
         DEFAULT_SIZE = 10.0
         INSET = 4.0
@@ -14,37 +26,71 @@ module Idml
         def self.render(canvas, context)
           table = context.item
           return if table.visible == false
-          return if table.table_row.empty?
 
           box = Placement.box(table, context.page_height)
           return unless box
 
-          row_count = table.table_row.length
-          row_height = box[:height] / row_count
+          render_in_box(canvas, table, box, context)
+        end
+
+        # Renders a Table using caller-supplied bounds (no
+        # Placement.box lookup). Used by TextFrameRenderer to
+        # render Tables inlined in a story — real IDML Tables
+        # have no own geometry, so the containing TextFrame's
+        # bounds stand in for the Table's bounds.
+        def self.render_in_box(canvas, table, box, context)
+          return if table.visible == false
 
           canvas.save_graphics_state do
-            table.table_row.each_with_index do |row, row_index|
-              render_row(canvas, row, row_index, row_count, box, row_height,
-                         context)
+            if schema_faithful?(table)
+              render_schema_faithful(canvas, table, box, context)
+            else
+              render_legacy(canvas, table, box, context)
             end
           end
         end
 
-        def self.render_row(canvas, row, row_index, row_count, box, row_height,
-                            context)
-          row_y = box[:y] + ((row_count - 1 - row_index) * row_height)
-          cell_count = row.table_cell.length
-          return unless cell_count.positive?
+        def self.schema_faithful?(table)
+          !table.cell.empty? || !table.row.empty?
+        end
+        private_class_method :schema_faithful?
 
-          cell_width = box[:width] / cell_count
-          row.table_cell.each_with_index do |cell, cell_index|
-            cell_x = box[:x] + (cell_index * cell_width)
-            canvas.rectangle(cell_x, row_y, cell_width, row_height)
+        # Real IDML: Table > {Cell, Row} siblings. Cell Name is
+        # "col:row". Row count from `row` collection; column count
+        # derived from max col + 1 across cells.
+        def self.render_schema_faithful(canvas, table, box, context)
+          layout = SchemaLayout.new(table: table, box: box)
+          layout.each_cell do |cell_x, cell_y, cell_w, cell_h, cell|
+            canvas.rectangle(cell_x, cell_y, cell_w, cell_h)
             canvas.stroke
-            render_cell_text(canvas, cell, cell_x, row_y, row_height, context)
+            render_cell_text(canvas, cell, cell_x, cell_y, cell_h, context)
+          end
+        end
+        private_class_method :render_schema_faithful
+
+        # Legacy: Table > TableRow > TableCell nested.
+        def self.render_legacy(canvas, table, box, context)
+          return if table.table_row.empty?
+
+          row_count = table.table_row.length
+          row_height = box[:height] / row_count
+
+          table.table_row.each_with_index do |row, row_index|
+            row_y = box[:y] + ((row_count - 1 - row_index) * row_height)
+            cell_count = row.table_cell.length
+            next unless cell_count.positive?
+
+            cell_width = box[:width] / cell_count
+            row.table_cell.each_with_index do |cell, cell_index|
+              cell_x = box[:x] + (cell_index * cell_width)
+              canvas.rectangle(cell_x, row_y, cell_width, row_height)
+              canvas.stroke
+              render_cell_text(canvas, cell, cell_x, row_y, row_height,
+                               context)
+            end
           end
         end
-        private_class_method :render_row
+        private_class_method :render_legacy
 
         def self.render_cell_text(canvas, cell, x, y, height, context)
           text = cell.text_content
@@ -59,6 +105,80 @@ module Idml
           canvas.text_rich(runs, at: [x + INSET, baseline])
         end
         private_class_method :render_cell_text
+
+        # Computes per-cell rects for the schema-faithful layout.
+        # Row heights come from `Row#single_row_height` when present,
+        # else fall back to evenly-divided table height. Column
+        # widths are evenly divided (precise column widths would
+        # require ColumnAttributes lookup, deferred).
+        SchemaLayout = Struct.new(:table, :box, keyword_init: true) do
+          def each_cell
+            row_count.times do |row_idx|
+              col_count.times do |col_idx|
+                cell = cell_at(col_idx, row_idx)
+                next unless cell
+
+                yield cell_x(col_idx), cell_y(row_idx), cell_w, cell_h(row_idx),
+                      cell
+              end
+            end
+          end
+
+          def row_count
+            rows.length
+          end
+
+          def col_count
+            @col_count ||= begin
+              max_col = cells.filter_map(&:col_row).map(&:first).max || 0
+              max_col + 1
+            end
+          end
+
+          def rows
+            table.row
+          end
+
+          def cells
+            table.cell
+          end
+
+          def cell_at(col, row)
+            cells.find { |c| c.col_row == [col, row] }
+          end
+
+          def cell_x(col)
+            box[:x] + (col * cell_w)
+          end
+
+          def cell_y(row)
+            box[:y] + total_height - cumulative_height(row) - cell_h(row)
+          end
+
+          def cell_w
+            box[:width] / [col_count, 1].max
+          end
+
+          def cell_h(row_idx)
+            row_heights[row_idx] || (box[:height] / [row_count, 1].max)
+          end
+
+          def row_heights
+            @row_heights ||= rows.map do |row|
+              h = row.single_row_height
+              h&.positive? ? h : nil
+            end
+          end
+
+          def total_height
+            @total_height ||= row_count.times.sum { |i| cell_h(i) }
+          end
+
+          def cumulative_height(up_to_row)
+            up_to_row.times.sum { |i| cell_h(i) }
+          end
+        end
+        private_constant :SchemaLayout
       end
     end
   end

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

@@ -20,13 +20,41 @@ module Idml
           story = context.package&.story_by_id(frame.parent_story)
           return unless story
 
+          box = frame_box(frame, context.page_height)
+          render_inline_tables(canvas, story, box, context)
+
           runs = StyleResolver.extract_runs(story)
           return if runs.empty?
 
-          box = frame_box(frame, context.page_height)
           render_text(canvas, runs, context, box)
         end
 
+        # Discovers Tables inlined in the story (Story > PSR > CSR >
+        # Table — the real IDML structure) and renders each within
+        # the frame's bounds. Real IDML Tables have no own geometry,
+        # so the containing TextFrame's box stands in. Synthetic
+        # spread-level Tables dispatch separately via
+        # PageItemRenderer.
+        def self.render_inline_tables(canvas, story, box, context)
+          tables = tables_in_story(story)
+          return if tables.empty?
+
+          tables.each do |table|
+            TableRenderer.render_in_box(canvas, table, box, context)
+          end
+        end
+        private_class_method :render_inline_tables
+
+        def self.tables_in_story(story)
+          inner = story&.inner
+          return [] unless inner
+
+          inner.paragraph_style_range.flat_map do |psr|
+            psr.character_style_range.flat_map(&:table)
+          end.compact
+        end
+        private_class_method :tables_in_story
+
         def self.render_text(canvas, runs, context, box)
           font = context.font_metrics
           if font

data/lib/idml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.8
 platform: ruby
 authors:
 - Ribose