idml 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f0fb65e931a0ba911043cdc0a885dab5d79257519b519896c07f8a8de9cc14
-  data.tar.gz: c25ece7b2f8d61ee13e7e572a3e4089cda665f307e20831a7a46cfa7c7c2ff52
+  metadata.gz: 83554bfc44e2eb23732f64f5283c221965a70823f48db100abdcb953306681e2
+  data.tar.gz: c3a13c6b72cd20fb5280f863db1712c10df2e636adbb777dd0d393a3042fe5cb
 SHA512:
-  metadata.gz: e2113e93725afbf9d5c025b1d0b50d698b4bd0ef47815f7fda87a703e007627b769bbb1118b924ce6d932cf78aff23877d20de303b60f3a9df1cd51f53947849
-  data.tar.gz: 856b9aa6fad47550fd6da61a1ebbc348be2752cde9eb5a1a165beadfd8b16c5d2ed763d0b5af68af6252b2631561b1c521200cadae00bfdafb0a15a0807d702e
+  metadata.gz: 798716bc9426f8ad558255e8cdca0130bc9fbc4df0b982bf052108c8ad985d8512acc478fe420c629a6823e9b474864dd6570942a95db95ecd91277dba60a36a
+  data.tar.gz: c3e14713c820726f1bc07ebbad6186a4f9d5f3e8a163a175f3b2905ca4183be595f5ccadf219647859fa172e754407f11fa137a6cea64074156d209ad3a31d36

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    idml (0.4.6)
+    idml (0.4.7)
       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.7)
   json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
   language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

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,60 @@ 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
-
           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_row
+        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_legacy
 
         def self.render_cell_text(canvas, cell, x, y, height, context)
           text = cell.text_content
@@ -59,6 +94,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/version.rb

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

metadata

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