idml 0.6.2 → 0.7.1

data/lib/idml/render/paragraph_rules.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Emits paragraph-level rules (RuleAbove / RuleBelow) on a pdfrb
+    # canvas. Centralizes the IDML → PDF mapping for the paragraph
+    # rule attributes carried by `StyleResolver::Paragraph`.
+    #
+    # Each rule is a horizontal stroke above (RuleAbove) or below
+    # (RuleBelow) the paragraph block. The rule's weight, color,
+    # tint, offset, and indent come from the PSR's RuleAbove* /
+    # RuleBelow* attributes; defaults approximate InDesign behavior
+    # when an attribute is missing.
+    #
+    # Used by `TextFrameRenderer` so paragraph rules live in one
+    # place (DRY).
+    module ParagraphRules
+      DEFAULT_LINE_WEIGHT = 0.5
+      DEFAULT_TINT = 1.0
+      DEFAULT_OFFSET = 0.0
+
+      # Emits RuleAbove if `paragraph.rule_above` is true. The rule
+      # sits above the paragraph's first line. `top_y` is the y of
+      # the paragraph's top edge (before SpaceBefore is applied);
+      # `frame_left` / `frame_right` are the column's text bounds.
+      def self.emit_rule_above(canvas, paragraph, context, top_y,
+                               frame_left, frame_right)
+        return unless paragraph.rule_above
+
+        emit_rule(canvas, paragraph, context, top_y, frame_left,
+                  frame_right,
+                  weight: paragraph.rule_above_line_weight,
+                  color: paragraph.rule_above_color,
+                  tint: paragraph.rule_above_tint,
+                  offset: paragraph.rule_above_offset,
+                  left_indent: paragraph.rule_above_left_indent,
+                  right_indent: paragraph.rule_above_right_indent,
+                  width_mode: paragraph.rule_above_width,
+                  position: :above)
+      end
+
+      # Emits RuleBelow if `paragraph.rule_below` is true. The rule
+      # sits below the paragraph's last line. `bottom_y` is the y of
+      # the paragraph's bottom edge (after SpaceAfter is applied).
+      def self.emit_rule_below(canvas, paragraph, context, bottom_y,
+                               frame_left, frame_right)
+        return unless paragraph.rule_below
+
+        emit_rule(canvas, paragraph, context, bottom_y, frame_left,
+                  frame_right,
+                  weight: paragraph.rule_below_line_weight,
+                  color: paragraph.rule_below_color,
+                  tint: paragraph.rule_below_tint,
+                  offset: paragraph.rule_below_offset,
+                  left_indent: paragraph.rule_below_left_indent,
+                  right_indent: paragraph.rule_below_right_indent,
+                  width_mode: paragraph.rule_below_width,
+                  position: :below)
+      end
+
+      def self.emit_rule(canvas, paragraph, context, anchor_y,
+                         frame_left, frame_right,
+                         weight:, color:, tint:, offset:,
+                         left_indent:, right_indent:, width_mode:,
+                         position:)
+        thickness = (weight || DEFAULT_LINE_WEIGHT).to_f
+        return unless thickness.positive?
+
+        tint_value = (tint || DEFAULT_TINT).to_f
+        return unless tint_value.positive?
+
+        offset_value = (offset || DEFAULT_OFFSET).to_f
+        x1, x2 = rule_extents(frame_left, frame_right, left_indent,
+                              right_indent, width_mode, paragraph)
+        y = rule_y(anchor_y, offset_value, position)
+
+        apply_rule_color(canvas, color, tint_value, context)
+        canvas.line_width = thickness
+        canvas.move_to(x1, y)
+        canvas.line_to(x2, y)
+        canvas.stroke
+      end
+      private_class_method :emit_rule
+
+      # Returns `[x1, x2]` for the rule. Width mode "Text" indents
+      # the rule by the paragraph's left/right indent (matches the
+      # text bounds); "Column" (default) spans the full column.
+      def self.rule_extents(frame_left, frame_right, rule_left_indent,
+                            rule_right_indent, width_mode, paragraph)
+        left = frame_left
+        right = frame_right
+        if width_mode == "Text"
+          left += (paragraph.left_indent || 0).to_f
+          right -= (paragraph.right_indent || 0).to_f
+        end
+        left += (rule_left_indent || 0).to_f
+        right -= (rule_right_indent || 0).to_f
+        [left, right]
+      end
+      private_class_method :rule_extents
+
+      def self.rule_y(anchor_y, offset, position)
+        position == :above ? anchor_y + offset : anchor_y - offset
+      end
+      private_class_method :rule_y
+
+      def self.apply_rule_color(canvas, color_name, tint_value, context)
+        color = resolve_color(color_name, tint_value, context)
+        canvas.stroke_color(color)
+      end
+      private_class_method :apply_rule_color
+
+      def self.resolve_color(color_name, tint_value, context)
+        return [:gray, 1.0 * tint_value] unless color_name
+        return [:gray, 1.0 * tint_value] if color_name == "Color/None"
+
+        color = context&.color_resolver&.resolve(color_name)
+        return [:gray, 1.0 * tint_value] unless color
+
+        ColorHelper.apply_tint(color, tint_value)
+      end
+      private_class_method :resolve_color
+    end
+  end
+end

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

@@ -4,9 +4,8 @@ module Idml
   module Render
     module Renderers
       # 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.
+      # ops, then renders inline text in each cell. Cells with no
+      # text render as empty rectangles.
       #
       # Two table layouts are supported:
       #
@@ -19,9 +18,20 @@ module Idml
       #      `table_cell` collection. Nested structure.
       #
       # The renderer auto-detects which layout is present.
+      #
+      # Honors per-cell:
+      # - `fill_color` / `fill_tint` — background fill before stroke.
+      # - `top_inset` / `left_inset` / `bottom_inset` / `right_inset`
+      #   — text insets (replaces fixed `INSET = 4.0`).
+      # - `vertical_justification` — Top / Center / Bottom / Justify.
+      # - `paragraph_style_range` → typed runs (per-run font + size).
+      #
+      # Honors per-table:
+      # - `single_column_width` — overrides the even-division default
+      #   for column widths.
       class TableRenderer
         DEFAULT_SIZE = 10.0
-        INSET = 4.0
+        DEFAULT_INSET = 4.0
 
         def self.render(canvas, context)
           table = context.item
@@ -57,17 +67,42 @@ module Idml
 
         # 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.
+        # derived from `column_count` attribute or max col + 1.
         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_background(canvas, cell, cell_x, cell_y, cell_w, cell_h,
+                                   context)
+            render_cell_border(canvas, cell_x, cell_y, cell_w, cell_h)
             render_cell_text(canvas, cell, cell_x, cell_y, cell_h, context)
           end
         end
         private_class_method :render_schema_faithful
 
+        def self.render_cell_background(canvas, cell, x, y, w, h, context)
+          color = cell_fill_color(cell, context)
+          return unless color
+
+          canvas.fill_color(ColorHelper.to_canvas(color))
+          canvas.rectangle(x, y, w, h)
+          canvas.fill
+        end
+        private_class_method :render_cell_background
+
+        def self.render_cell_border(canvas, x, y, w, h)
+          canvas.rectangle(x, y, w, h)
+          canvas.stroke
+        end
+        private_class_method :render_cell_border
+
+        def self.cell_fill_color(cell, context)
+          return nil unless cell.fill_color
+          return nil if cell.fill_color == "Color/None"
+
+          context.color_resolver&.resolve(cell.fill_color)
+        end
+        private_class_method :cell_fill_color
+
         # Legacy: Table > TableRow > TableCell nested.
         def self.render_legacy(canvas, table, box, context)
           return if table.table_row.empty?
@@ -93,33 +128,122 @@ module Idml
         private_class_method :render_legacy
 
         def self.render_cell_text(canvas, cell, x, y, height, context)
+          runs = cell_text_runs(cell, context)
+          return if runs.empty?
+
+          insets = cell_insets(cell)
+          baseline = vertical_baseline(y, height, insets, cell)
+          canvas.text_rich(runs, at: [x + insets[:left], baseline])
+        end
+        private_class_method :render_cell_text
+
+        # Builds pdfrb runs from the cell's typed PSR/CSR children.
+        # Walks ParagraphStyleRange → CharacterStyleRange → Content
+        # so each run carries its own font + size (per-cell CSR
+        # styling). Falls back to a single DEFAULT_SIZE run when
+        # the cell has no typed paragraphs (legacy TableCell).
+        def self.cell_text_runs(cell, context)
+          psr = typed_paragraphs(cell)
+          return default_text_runs(cell, context) if psr.empty?
+
+          psr.flat_map { |paragraph| paragraph_runs(paragraph, context) }
+        end
+        private_class_method :cell_text_runs
+
+        def self.paragraph_runs(paragraph, context)
+          paragraph.character_style_range.filter_map do |csr|
+            text = csr.text_content
+            next if text.nil? || text.empty?
+
+            {
+              text: text,
+              font: context.font_ps_name,
+              size: csr.point_size || DEFAULT_SIZE,
+            }
+          end
+        end
+        private_class_method :paragraph_runs
+
+        # Real IDML `Cell` exposes paragraph_style_range; the legacy
+        # `TableCell` (synthetic fixture only) doesn't, so we treat
+        # it as having no typed paragraphs and fall through to the
+        # default_text_runs path.
+        def self.typed_paragraphs(cell)
+          return [] unless cell.is_a?(Idml::Elements::Cell)
+
+          cell.paragraph_style_range
+        end
+        private_class_method :typed_paragraphs
+
+        def self.default_text_runs(cell, context)
           text = cell.text_content
-          return if text.nil? || text.empty?
+          return [] if text.nil? || text.empty?
 
-          runs = [{
+          [{
             text: text,
             font: context.font_ps_name,
             size: DEFAULT_SIZE,
           }]
-          baseline = y + (height / 2)
-          canvas.text_rich(runs, at: [x + INSET, baseline])
         end
-        private_class_method :render_cell_text
+        private_class_method :default_text_runs
+
+        # Cell insets: prefer typed TextTopInset/Left/Bottom/Right,
+        # fall back to DEFAULT_INSET for any that are missing.
+        def self.cell_insets(cell)
+          {
+            top: cell.top_inset || DEFAULT_INSET,
+            bottom: cell.bottom_inset || DEFAULT_INSET,
+            left: cell.left_inset || DEFAULT_INSET,
+            right: cell.right_inset || DEFAULT_INSET,
+          }
+        end
+        private_class_method :cell_insets
+
+        # Vertical baseline for the cell's first text line, per the
+        # cell's VerticalJustification. IDML values: TopAlign,
+        # CenterAlign, BottomAlign, JustifyAlign. Default: CenterAlign
+        # (legacy behavior).
+        def self.vertical_baseline(y, height, insets, cell)
+          case cell.vertical_justification
+          when "TopAlign"
+            y + height - insets[:top]
+          when "BottomAlign"
+            y + insets[:bottom]
+          else # CenterAlign, JustifyAlign, nil
+            y + (height / 2)
+          end
+        end
+        private_class_method :vertical_baseline
 
         # 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).
+        # widths come from `Table#single_column_width` when present
+        # (uniform columns only — per-column widths would require
+        # ColumnAttributes, which IDML doesn't model separately),
+        # else divide evenly.
+        #
+        # Honors `Cell#column_span` and `Cell#row_span`: a spanning
+        # cell covers multiple grid positions and is rendered once
+        # at its top-left corner with the merged rect. Cells covered
+        # by another cell's span are skipped.
         SchemaLayout = Struct.new(:table, :box, keyword_init: true) do
           def each_cell
+            covered = Set.new
+
             row_count.times do |row_idx|
               col_count.times do |col_idx|
+                next if covered.include?([col_idx, row_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
+                col_span = cell.column_span || 1
+                row_span = cell.row_span || 1
+                mark_covered(covered, col_idx, row_idx, col_span, row_span)
+
+                yield cell_x(col_idx), cell_y(row_idx, col_span, row_span),
+                      cell_w(col_span), cell_h(row_idx, row_span), cell
               end
             end
           end
@@ -130,11 +254,16 @@ module Idml
 
           def col_count
             @col_count ||= begin
-              max_col = cells.filter_map(&:col_row).map(&:first).max || 0
-              max_col + 1
+              declared = table.column_count
+              declared&.positive? ? declared : derived_col_count
             end
           end
 
+          def derived_col_count
+            max_col = cells.filter_map(&:col_row).map(&:first).max || 0
+            max_col + 1
+          end
+
           def rows
             table.row
           end
@@ -147,20 +276,52 @@ module Idml
             cells.find { |c| c.col_row == [col, row] }
           end
 
+          def mark_covered(covered, col, row, col_span, row_span)
+            col_span.times do |dc|
+              row_span.times do |dr|
+                covered << [col + dc, row + dr]
+              end
+            end
+          end
+          private :mark_covered
+
           def cell_x(col)
-            box[:x] + (col * cell_w)
+            box[:x] + (col * per_col_width)
           end
 
-          def cell_y(row)
-            box[:y] + total_height - cumulative_height(row) - cell_h(row)
+          # PDF-coordinate bottom y of the cell's rectangle. For a
+          # row_spanning cell, this is the bottom edge of the last
+          # spanned row. PDF rectangle takes (x, y_bottom, w, h).
+          def cell_y(row, _col_span, row_span)
+            last_row = row + row_span - 1
+            box[:y] + total_height - cumulative_height(last_row + 1)
           end
 
-          def cell_w
-            box[:width] / [col_count, 1].max
+          # Width covered by `span` columns starting at the cell's col.
+          def cell_w(span)
+            per_col_width * (span || 1)
           end
 
-          def cell_h(row_idx)
-            row_heights[row_idx] || (box[:height] / [row_count, 1].max)
+          # Total height covered by `span` rows starting at `row_idx`.
+          def cell_h(row_idx, span)
+            (span || 1).times.sum { |i| row_height(row_idx + i) }
+          end
+
+          def per_col_width
+            return @per_col_width if @per_col_width
+
+            declared = table.single_column_width
+            @per_col_width = if declared&.positive?
+                               declared
+                             else
+                               box[:width] / [col_count, 1].max
+                             end
+          end
+
+          def row_height(idx)
+            return 0.0 unless idx.between?(0, row_count - 1)
+
+            row_heights[idx] || (box[:height] / [row_count, 1].max)
           end
 
           def row_heights
@@ -171,11 +332,11 @@ module Idml
           end
 
           def total_height
-            @total_height ||= row_count.times.sum { |i| cell_h(i) }
+            @total_height ||= row_count.times.sum { |i| row_height(i) }
           end
 
           def cumulative_height(up_to_row)
-            up_to_row.times.sum { |i| cell_h(i) }
+            up_to_row.times.sum { |i| row_height(i) }
           end
         end
         private_constant :SchemaLayout