idml 0.2.5 → 0.2.7

data/TODO.pdf/73-gradient-resolver-cleanup.md

@@ -0,0 +1,48 @@
+# TODO PDF 73: Drop dead GradientResolver approximation code
+
+## Status: DONE
+
+## What was removed
+
+`Idml::Render::GradientResolver` previously carried a 32-rectangle
+discrete-approximation renderer (`render_gradient`, `interpolate`,
+`blend_between`, `blend`, and the `SEGMENTS = 32` constant). The
+discrete approximation was replaced by real PDF shadings in TODO 66
+(pdfrb 0.4.0 `Shadings#add_axial`) and TODO 68 (`add_radial`); the
+old code became dead.
+
+The class also had a `build(graphic)` factory that built a lookup
+table no consumer reads.
+
+## What was kept
+
+- `GradientResolver.gradient?(name)` — pure predicate (`name` is a
+  `Gradient/*` reference). Still used by `RectangleRenderer#render_fill`
+  to choose between gradient and solid color paths.
+
+The module is now a 4-line pure predicate. Every other responsibility
+moved to `RectangleRenderer`'s direct `Shadings#add_axial` /
+`add_radial` calls.
+
+## Why
+
+Dead code accumulates. Three reasons to drop it:
+
+1. **Confusion** — readers see `SEGMENTS = 32` and assume the discrete
+   approximation is still in use somewhere.
+2. **Maintenance** — every time `ColorResolver` or the gradient model
+   changed, the dead code needed reading to confirm it didn't need
+   updating.
+3. **Test surface** — the dead `render_gradient` had its own spec
+   using `instance_double(Idml::Parts::Graphic)`, violating the
+   no-doubles rule. Removing the method let us delete the offending
+   spec.
+
+## Acceptance criteria
+
+- [x] `GradientResolver` exposes only `.gradient?`.
+- [x] No `render_gradient`, `interpolate`, `blend_between`, `blend`,
+      `SEGMENTS`, or `build` in the module.
+- [x] Renderer code unchanged in behavior (still routes gradient fills
+      to pdfrb Shadings).
+- [x] `bundle exec rake` green.

data/TODO.pdf/74-renderer-spec-coverage.md

@@ -0,0 +1,53 @@
+# TODO PDF 74: Renderer spec coverage
+
+## Status: DONE
+
+## What was implemented
+
+Dedicated spec files for every renderer that previously had none.
+Each spec uses real `Idml::Elements::*` instances (parsed from XML
+fragments) or lightweight `Struct` doubles that mirror the renderer's
+interface — no RSpec `double()` or `instance_double` anywhere.
+
+New spec files:
+
+- `spec/idml/render/polygon_renderer_spec.rb` — 4 examples covering
+  visibility, missing bounds, fill rendering, and stroke + cap.
+- `spec/idml/render/graphic_line_renderer_spec.rb` — 4 examples
+  covering unstrokable skip, color-miss skip, basic line drawing,
+  and StrokeStyle application.
+- `spec/idml/render/group_renderer_spec.rb` — 4 examples covering
+  empty group, child dispatch, item_transform concat, and
+  layer_filter visibility.
+- `spec/idml/render/table_renderer_spec.rb` — 4 examples covering
+  visibility skip, empty rows skip, per-cell rectangle count, and
+  stroke emission.
+- `spec/idml/render/text_frame_renderer_spec.rb` — 3 examples
+  covering no-story skip, non-chain-head skip, and end-to-end BT/ET
+  emission against the sample-with-image fixture.
+- `spec/idml/render/blending_spec.rb` — 11 examples (added earlier
+  in TODO 69).
+- `spec/idml/render/stroke_style_spec.rb` — 13 examples (added
+  earlier in TODO 72).
+- `spec/idml/render/rectangle_renderer_spec.rb` — 6 examples (added
+  earlier in TODO 68).
+
+## Cleanups
+
+- `render_helpers_spec.rb` — removed the `#render_gradient` test that
+  used `instance_double(Idml::Parts::Graphic)` (TODO 73).
+- `rectangle_renderer_spec.rb` — replaced
+  `canvas.document.shadings.instance_variable_get(:@registry)` with
+  the public `shadings.registry` reader.
+- `designmap_spec.rb` — replaced `parsed.send(actual_attr(attr))`
+  with an explicit case/when reader.
+
+## Acceptance criteria
+
+- [x] Every renderer in `lib/idml/render/renderers/` has a dedicated
+      spec file with at least 3 examples.
+- [x] No `instance_double` or `double()` in render specs.
+- [x] No `instance_variable_get` / `instance_variable_set` in render
+      specs.
+- [x] No `.send(...)` in any spec.
+- [x] `bundle exec rake` green (2350+ examples, 0 failures).

data/lib/idml/elements/graphic_line.rb

@@ -10,9 +10,14 @@ module Idml
       attribute :stroke_color, :string
       attribute :stroke_weight, :float
       attribute :stroke_tint, :float
+      attribute :end_cap, :string
+      attribute :end_join, :string
+      attribute :miter_limit, :float
+      attribute :stroke_dash_and_gap, :string
       attribute :visible, :boolean
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
+      attribute :transparency_setting, Idml::Elements::TransparencySetting
 
       xml do
         root "GraphicLine"
@@ -21,9 +26,14 @@ module Idml
         map_attribute "StrokeColor", to: :stroke_color
         map_attribute "StrokeWeight", to: :stroke_weight
         map_attribute "StrokeTint", to: :stroke_tint
+        map_attribute "EndCap", to: :end_cap
+        map_attribute "EndJoin", to: :end_join
+        map_attribute "MiterLimit", to: :miter_limit
+        map_attribute "StrokeDashAndGap", to: :stroke_dash_and_gap
         map_attribute "Visible", to: :visible
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
+        map_element "TransparencySetting", to: :transparency_setting
       end
 
       def geometric_bounds

data/lib/idml/elements/polygon.rb

@@ -12,9 +12,14 @@ module Idml
       attribute :fill_tint, :float
       attribute :stroke_color, :string
       attribute :stroke_weight, :float
+      attribute :end_cap, :string
+      attribute :end_join, :string
+      attribute :miter_limit, :float
+      attribute :stroke_dash_and_gap, :string
       attribute :visible, :boolean
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
+      attribute :transparency_setting, Idml::Elements::TransparencySetting
       attribute :image, Idml::Elements::Image, collection: true
 
       xml do
@@ -26,9 +31,14 @@ module Idml
         map_attribute "FillTint", to: :fill_tint
         map_attribute "StrokeColor", to: :stroke_color
         map_attribute "StrokeWeight", to: :stroke_weight
+        map_attribute "EndCap", to: :end_cap
+        map_attribute "EndJoin", to: :end_join
+        map_attribute "MiterLimit", to: :miter_limit
+        map_attribute "StrokeDashAndGap", to: :stroke_dash_and_gap
         map_attribute "Visible", to: :visible
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
+        map_element "TransparencySetting", to: :transparency_setting
         map_element "Image", to: :image
       end
 

data/lib/idml/elements/rectangle.rb

@@ -15,10 +15,15 @@ module Idml
       attribute :stroke_color, :string
       attribute :stroke_weight, :float
       attribute :stroke_tint, :float
+      attribute :end_cap, :string
+      attribute :end_join, :string
+      attribute :miter_limit, :float
+      attribute :stroke_dash_and_gap, :string
       attribute :visible, :boolean
       attribute :name, :string
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
+      attribute :transparency_setting, Idml::Elements::TransparencySetting
       attribute :image, Idml::Elements::Image, collection: true
 
       xml do
@@ -32,10 +37,15 @@ module Idml
         map_attribute "StrokeColor", to: :stroke_color
         map_attribute "StrokeWeight", to: :stroke_weight
         map_attribute "StrokeTint", to: :stroke_tint
+        map_attribute "EndCap", to: :end_cap
+        map_attribute "EndJoin", to: :end_join
+        map_attribute "MiterLimit", to: :miter_limit
+        map_attribute "StrokeDashAndGap", to: :stroke_dash_and_gap
         map_attribute "Visible", to: :visible
         map_attribute "Name", to: :name
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
+        map_element "TransparencySetting", to: :transparency_setting
         map_element "Image", to: :image
       end
 

data/lib/idml/elements/text_frame.rb

@@ -20,6 +20,7 @@ module Idml
       attribute :name, :string
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
+      attribute :transparency_setting, Idml::Elements::TransparencySetting
       attribute :text_frame_preference, Idml::Elements::TextFramePreference,
                 collection: true
 
@@ -39,6 +40,7 @@ module Idml
         map_attribute "Name", to: :name
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
+        map_element "TransparencySetting", to: :transparency_setting
         map_element "TextFramePreference", to: :text_frame_preference
       end
 

data/lib/idml/elements/transparency_setting.rb

@@ -7,8 +7,33 @@ module Idml
     # `reference-docs/schemas/package/Resources/Styles.rnc` is declared (0 attributes),
     # generated by `scripts/rnc_to_lutaml.rb`.
     class TransparencySetting < Lutaml::Model::Serializable
+      attribute :blending_setting, Idml::Elements::BlendingSetting
+      attribute :drop_shadow_setting, Idml::Elements::DropShadowSetting
+      attribute :feather_setting, Idml::Elements::FeatherSetting
+      attribute :inner_shadow_setting, Idml::Elements::InnerShadowSetting
+      attribute :outer_glow_setting, Idml::Elements::OuterGlowSetting
+      attribute :inner_glow_setting, Idml::Elements::InnerGlowSetting
+      attribute :bevel_and_emboss_setting, Idml::Elements::BevelAndEmbossSetting
+      attribute :satin_setting, Idml::Elements::SatinSetting
+      attribute :directional_feather_setting,
+                Idml::Elements::DirectionalFeatherSetting
+      attribute :gradient_feather_setting,
+                Idml::Elements::GradientFeatherSetting
+
       xml do
         root "TransparencySetting"
+        map_element "BlendingSetting", to: :blending_setting
+        map_element "DropShadowSetting", to: :drop_shadow_setting
+        map_element "FeatherSetting", to: :feather_setting
+        map_element "InnerShadowSetting", to: :inner_shadow_setting
+        map_element "OuterGlowSetting", to: :outer_glow_setting
+        map_element "InnerGlowSetting", to: :inner_glow_setting
+        map_element "BevelAndEmbossSetting", to: :bevel_and_emboss_setting
+        map_element "SatinSetting", to: :satin_setting
+        map_element "DirectionalFeatherSetting",
+                    to: :directional_feather_setting
+        map_element "GradientFeatherSetting",
+                    to: :gradient_feather_setting
       end
     end
   end

data/lib/idml/render/blending.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Maps an `Elements::BlendingSetting` to the keyword arguments that
+    # `Pdfrb::Content::Canvas#with_transparency` expects. IDML stores
+    # opacity as 0–100 (percentage); pdfrb wants 0.0–1.0 alpha. Blend
+    # mode names line up directly with PDF `BM` names; unknown modes
+    # fall back to `Normal`.
+    module Blending
+      PDF_BLEND_MODES = %w[
+        Normal Multiply Screen Overlay SoftLight HardLight Darken Lighten
+        ColorDodge ColorBurn Difference Exclusion Hue Saturation Color
+        Luminosity
+      ].freeze
+
+      def self.args_for(setting)
+        return nil unless setting&.blending_setting
+
+        build_args(setting.blending_setting)
+      end
+
+      def self.build_args(blending)
+        opacity = normalize_opacity(blending.opacity)
+        mode = normalize_mode(blending.blend_mode)
+        return nil unless opacity || mode
+
+        { opacity: opacity || 1.0, blend_mode: mode || "Normal" }
+      end
+      private_class_method :build_args
+
+      # Wraps the given block in `Canvas#with_transparency` when the
+      # page item has a BlendingSetting, otherwise yields directly.
+      def self.wrap(canvas, setting, &)
+        args = args_for(setting)
+        if args
+          canvas.with_transparency(**args, &)
+        else
+          yield
+        end
+      end
+
+      def self.normalize_opacity(raw)
+        return nil if raw.nil?
+
+        (raw.to_f / 100.0).clamp(0.0, 1.0)
+      end
+      private_class_method :normalize_opacity
+
+      def self.normalize_mode(raw)
+        return nil if raw.nil? || raw == "Normal"
+
+        camel = raw.to_s.dup
+        camel[0] = camel[0].upcase
+        PDF_BLEND_MODES.include?(camel) ? camel : nil
+      end
+      private_class_method :normalize_mode
+    end
+  end
+end

data/lib/idml/render/gradient_resolver.rb

@@ -2,111 +2,19 @@
 
 module Idml
   module Render
-    # Resolves IDML gradient references to discrete PDF gradient fills.
-    # A gradient is rendered as N thin colored rectangles that
-    # approximate the smooth gradient transition. This is not a true
-    # PDF shading pattern (which requires Function dictionaries), but
-    # produces a visually correct gradient without complex PDF structure.
-    class GradientResolver
-      SEGMENTS = 32
-
-      def self.build(graphic)
-        table = {}
-        return new(table) unless graphic&.gradient
-
-        graphic.gradient.each do |gradient|
-          table[gradient.self_attr] = gradient
-        end
-        new(table)
-      end
-
-      def initialize(table)
-        @table = table
-        @color_resolver = nil
-      end
-
-      # Detect if a color reference is a gradient.
+    # Identifies IDML gradient color references and exposes the
+    # gradient catalogue from `Resources/Graphic.xml`.
+    #
+    # The discrete-rectangle approximation that this module used to
+    # carry was removed once pdfrb 0.4.0 introduced real PDF shadings
+    # (TODOs 49, 66, 68). Today the renderers go through pdfrb's
+    # `Shadings#add_axial` / `add_radial` directly; this module's
+    # only remaining responsibility is the predicate that distinguishes
+    # gradient colour references from solid ones.
+    module GradientResolver
       def self.gradient?(name)
         name.is_a?(String) && name.start_with?("Gradient/")
       end
-
-      # Render a gradient fill as PDF operators. Returns nil if the
-      # color is not a gradient. The returned operators emit colored
-      # rectangles from y2 down to y1 (matching PDF Y-up coords).
-      def render_gradient(name, x:, y:, width:, height:, color_resolver:)
-        @color_resolver = color_resolver
-        gradient = @table[name]
-        return nil unless gradient
-
-        stops = gradient.gradient_stop
-        return nil if stops.length < 2
-
-        segment_height = height.to_f / SEGMENTS
-        ops = []
-        SEGMENTS.downto(1) do |i|
-          offset = (i - 1) / SEGMENTS.to_f
-          color = interpolate(stops, offset)
-          next unless color
-
-          ops << "q"
-          ops << Idml::Render::ColorHelper.to_canvas(color)
-          ops << format("%<x>.2f %<y>.2f %<w>.2f %<h>.2f re",
-                        x: x,
-                        y: y + ((SEGMENTS - i) * segment_height),
-                        w: width,
-                        h: segment_height + 0.1)
-          ops << "f"
-          ops << "Q"
-        end
-        ops.join("\n")
-      end
-
-      def interpolate(stops, offset)
-        next_stop = stops.find { |s| s.location >= offset } || stops.last
-        prev_stop = stops.reverse.find { |s| s.location <= offset } || stops.first
-        return resolve_color(next_stop.stop_color) if next_stop == prev_stop
-
-        blend_between(prev_stop, next_stop, offset)
-      end
-
-      def blend_between(prev_stop, next_stop, offset)
-        range = (next_stop.location - prev_stop.location)
-        range = 1.0 if range.zero?
-        local = (offset - prev_stop.location) / range
-
-        prev_color = resolve_color(prev_stop.stop_color)
-        next_color = resolve_color(next_stop.stop_color)
-        return prev_color unless prev_color && next_color
-        return next_color if local >= 1.0
-
-        blend(prev_color, next_color, local)
-      end
-
-      def resolve_color(name)
-        return nil unless @color_resolver && name
-
-        @color_resolver.resolve(name)
-      end
-
-      def blend(color_a, color_b, t)
-        case color_a[:model]
-        when :rgb
-          {
-            model: :rgb,
-            r: color_a[:r] + ((color_b[:r] - color_a[:r]) * t),
-            g: color_a[:g] + ((color_b[:g] - color_a[:g]) * t),
-            b: color_a[:b] + ((color_b[:b] - color_a[:b]) * t),
-          }
-        when :cmyk
-          {
-            model: :cmyk,
-            c: color_a[:c] + ((color_b[:c] - color_a[:c]) * t),
-            m: color_a[:m] + ((color_b[:m] - color_a[:m]) * t),
-            y: color_a[:y] + ((color_b[:y] - color_a[:y]) * t),
-            k: color_a[:k] + ((color_b[:k] - color_a[:k]) * t),
-          }
-        end
-      end
     end
   end
 end

data/lib/idml/render/placement.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Resolves a page item's geometric placement on the PDF page.
+    # Encapsulates the read of `geometric_bounds` and `item_transform`
+    # from any page-item model and the subsequent transform into a
+    # PDF-coordinate `{ x:, y:, width:, height: }` rect via `Geometry`.
+    #
+    # This is the single source of truth for "where does this item
+    # draw" — every shape renderer goes through here instead of each
+    # one re-implementing the bounds/transform dance.
+    module Placement
+      FALLBACK = { x: 72.0, y: 72.0, width: 400.0, height: 600.0 }.freeze
+
+      # Returns the PDF-placement rect for the given page item, or
+      # `nil` when the item has no geometric bounds. Pass
+      # `fallback: true` to receive a default rect instead of nil
+      # (used by text frames that need *somewhere* to render even
+      # when geometry is absent).
+      def self.box(item, page_height, fallback: false)
+        bounds = item.geometric_bounds
+        if bounds
+          Geometry.placement_rect(bounds, item.item_transform, page_height)
+        elsif fallback
+          FALLBACK.dup.merge(y: page_height - FALLBACK[:height] - 72.0)
+        end
+      end
+    end
+  end
+end

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

@@ -6,20 +6,22 @@ module Idml
       class GraphicLineRenderer
         def self.render(canvas, context)
           line = context.item
-          return unless RectangleRenderer.strokeable?(line)
+          return unless StrokeStyle.strokeable?(line)
 
           color = context.color_resolver&.resolve(line.stroke_color)
           return unless color
 
-          box = RectangleRenderer.placement_box(line, context.page_height)
+          box = Placement.box(line, context.page_height)
           return unless box
 
-          canvas.save_graphics_state do
-            canvas.stroke_color(ColorHelper.to_canvas(color))
-            canvas.line_width = line.stroke_weight
-            canvas.move_to(box[:x], box[:y] + box[:height])
-            canvas.line_to(box[:x] + box[:width], box[:y])
-            canvas.stroke
+          Blending.wrap(canvas, line.transparency_setting) do
+            StrokeStyle.apply(canvas, line) do
+              canvas.stroke_color(ColorHelper.to_canvas(color))
+              canvas.line_width = line.stroke_weight
+              canvas.move_to(box[:x], box[:y] + box[:height])
+              canvas.line_to(box[:x] + box[:width], box[:y])
+              canvas.stroke
+            end
           end
         end
       end

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

@@ -8,10 +8,10 @@ module Idml
           poly = context.item
           return if poly.visible == false
 
-          box = RectangleRenderer.placement_box(poly, context.page_height)
+          box = Placement.box(poly, context.page_height)
           return unless box
 
-          canvas.save_graphics_state do
+          Blending.wrap(canvas, poly.transparency_setting) do
             render_fill(canvas, poly, context, box)
             render_stroke(canvas, poly, context, box)
           end
@@ -30,15 +30,17 @@ module Idml
         private_class_method :render_fill
 
         def self.render_stroke(canvas, poly, context, box)
-          return unless RectangleRenderer.strokeable?(poly)
+          return unless StrokeStyle.strokeable?(poly)
 
           color = context.color_resolver&.resolve(poly.stroke_color)
           return unless color
 
-          canvas.stroke_color(ColorHelper.to_canvas(color))
-          canvas.line_width = poly.stroke_weight
-          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
-          canvas.stroke
+          StrokeStyle.apply(canvas, poly) do
+            canvas.stroke_color(ColorHelper.to_canvas(color))
+            canvas.line_width = poly.stroke_weight
+            canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+            canvas.stroke
+          end
         end
         private_class_method :render_stroke
       end

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

@@ -9,22 +9,15 @@ module Idml
           rect = context.item
           return if rect.visible == false
 
-          box = placement_box(rect, context.page_height)
+          box = Placement.box(rect, context.page_height)
           return unless box
 
-          canvas.save_graphics_state do
+          Blending.wrap(canvas, rect.transparency_setting) do
             render_fill(canvas, rect, context, box)
             render_stroke(canvas, rect, context, box)
           end
         end
 
-        def self.placement_box(rect, page_height)
-          bounds = rect.geometric_bounds
-          return nil unless bounds
-
-          Geometry.placement_rect(bounds, rect.item_transform, page_height)
-        end
-
         def self.render_fill(canvas, rect, context, box)
           return unless rect.fill_color
           return if rect.fill_color == "Color/None"
@@ -44,32 +37,51 @@ module Idml
         private_class_method :render_fill
 
         def self.render_gradient_fill(canvas, rect, context, box)
-          stops = gradient_stops_for(rect, context)
-          return unless stops&.length&.>=(2)
+          gradient = gradient_for(rect, context)
+          return unless gradient
+          return unless gradient.gradient_stop.length >= 2
+
+          stops = gradient_stops(gradient, context)
+          return unless stops.length >= 2
+
+          shading = if gradient.type == "Radial"
+                      radial_shading(canvas, box, stops)
+                    else
+                      axial_shading(canvas, box, stops)
+                    end
+          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+          canvas.fill_shading(shading)
+        end
+        private_class_method :render_gradient_fill
 
-          shading = canvas.document.shadings.add_axial(
+        def self.axial_shading(canvas, box, stops)
+          canvas.document.shadings.add_axial(
             from: [box[:x], box[:y] + box[:height]],
             to: [box[:x] + box[:width], box[:y]],
             stops: stops,
           )
-          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
-          canvas.fill_shading(shading)
         end
-        private_class_method :render_gradient_fill
+        private_class_method :axial_shading
+
+        def self.radial_shading(canvas, box, stops)
+          cx = box[:x] + (box[:width] / 2.0)
+          cy = box[:y] + (box[:height] / 2.0)
+          radius = [box[:width], box[:height]].max / 2.0
+          canvas.document.shadings.add_radial(
+            from: [cx, cy, 0.0],
+            to: [cx, cy, radius],
+            stops: stops,
+          )
+        end
+        private_class_method :radial_shading
 
-        def self.gradient_stops_for(rect, context)
+        def self.gradient_for(rect, context)
           graphic = context.package&.graphic
           return nil unless graphic
 
-          gradient = graphic.gradient.find do |g|
-            g.self_attr == rect.fill_color
-          end
-          return nil unless gradient
-          return nil unless gradient.gradient_stop.length >= 2
-
-          gradient_stops(gradient, context)
+          graphic.gradient.find { |g| g.self_attr == rect.fill_color }
         end
-        private_class_method :gradient_stops_for
+        private_class_method :gradient_for
 
         def self.gradient_stops(gradient, context)
           gradient.gradient_stop.filter_map do |stop|
@@ -82,23 +94,19 @@ module Idml
         private_class_method :gradient_stops
 
         def self.render_stroke(canvas, rect, context, box)
-          return unless strokeable?(rect)
+          return unless StrokeStyle.strokeable?(rect)
 
           color = context.color_resolver&.resolve(rect.stroke_color)
           return unless color
 
-          canvas.stroke_color(ColorHelper.to_canvas(color))
-          canvas.line_width = rect.stroke_weight
-          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
-          canvas.stroke
+          StrokeStyle.apply(canvas, rect) do
+            canvas.stroke_color(ColorHelper.to_canvas(color))
+            canvas.line_width = rect.stroke_weight
+            canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
+            canvas.stroke
+          end
         end
         private_class_method :render_stroke
-
-        def self.strokeable?(rect)
-          rect.stroke_color &&
-            rect.stroke_color != "Color/None" &&
-            rect.stroke_weight&.positive?
-        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Idml
           return if table.visible == false
           return if table.table_row.empty?
 
-          box = RectangleRenderer.placement_box(table, context.page_height)
+          box = Placement.box(table, context.page_height)
           return unless box
 
           row_count = table.table_row.length