idml 0.2.6 → 0.2.8

data/TODO.pdf/75-pdf-metadata-from-xmp.md

@@ -0,0 +1,103 @@
+# TODO PDF 75: PDF metadata enrichment from IDML XMP
+
+## Status: BLOCKED (Lutaml XMP namespace parsing)
+
+## Goal
+
+Pull IDML document metadata from `META-INF/metadata.xml` (XMP packet)
+into the PDF Info dictionary via `PdfrbWriter#set_info`:
+
+- `dc:title` → PDF `/Title`
+- `dc:creator` → PDF `/Author`
+- `dc:description` → PDF `/Subject`
+- `dc:subject` → PDF `/Keywords`
+- `xmp:CreatorTool` → PDF `/Creator`
+- `xmp:CreateDate` → PDF `/CreationDate`
+- `xmp:ModifyDate` → PDF `/ModDate`
+
+## Blocker
+
+`META-INF/metadata.xml` is an XMP packet — RDF/XML with multiple XML
+namespaces (`dc:`, `xmp:`, `pdf:`, `xmpMM:`, `stFnt:`, etc.). Parsing
+it with `lutaml-model` requires namespace-aware element mapping.
+
+Lutaml 0.8.19's namespace API is in flux:
+
+- `namespace "..."` with a URI string raises
+  `String namespace URIs are not supported. Define an XmlNamespace
+  class instead.`
+- `namespace: Lutaml::Xml::XmlNamespace.new(uri, prefix)` raises
+  a `NoMethodError` inside `process_mapping`.
+- `map_element "dc:format"` (prefix in name) is silently ignored —
+  local-name lookup strips the prefix.
+- `prefix: "dc"` is ignored when there is no `namespace:` on the
+  mapping.
+
+The CLAUDE.md rule "no `Lutaml::Xml::Document.parse`" rules out
+falling back to a generic XmlDocument traversal. We must use a typed
+model.
+
+## Path forward
+
+Wait for Lutaml to stabilise its namespace API, then add a typed
+`Idml::Parts::XmpMetadata` model that maps each XMP field to a Ruby
+attribute. Pipeline reads `META-INF/metadata.xml`, calls
+`XmpMetadata.from_xml`, and threads the resulting attributes through
+`PdfrbWriter#set_info`.
+
+When the blocker clears, the implementation looks like:
+
+```ruby
+module Idml
+  module Parts
+    class XmpMetadata < Lutaml::Model::Serializable
+      attribute :title, :string
+      attribute :author, :string
+      attribute :subject, :string
+      attribute :keywords, :string
+      attribute :creator_tool, :string
+      attribute :create_date, :string
+      attribute :modify_date, :string
+
+      xml do
+        root "Description"
+        # …namespace-aware mappings once Lutaml supports them…
+      end
+    end
+  end
+end
+
+# In Pipeline:
+if @package.has_part?("META-INF/metadata.xml")
+  xmp = Idml::Parts::XmpMetadata.from_xml(
+    @package.read_part("META-INF/metadata.xml"),
+  )
+  writer.set_info(
+    Title: xmp.title,
+    Author: xmp.author,
+    Subject: xmp.subject,
+    Keywords: xmp.keywords,
+    Creator: xmp.creator_tool,
+    CreationDate: pdf_date(xmp.create_date),
+    ModDate: pdf_date(xmp.modify_date),
+  )
+end
+```
+
+## Acceptance criteria (after blocker clears)
+
+- [ ] Pipeline reads `META-INF/metadata.xml` when present.
+- [ ] `XmpMetadata` typed model parses dc:title/creator/description/
+      subject plus xmp:CreatorTool/CreateDate/ModifyDate.
+- [ ] Pipeline passes the parsed fields to `PdfrbWriter#set_info`.
+- [ ] Existing Producer/CreationDate defaults still apply when XMP
+      or individual fields are absent.
+- [ ] Spec covers a synthetic XMP packet with all fields populated,
+      plus the no-metadata fallback.
+
+## Dependencies
+
+- Lutaml namespace API stable enough that
+  `map_element "format", namespace: <XmlNamespace>` works without
+  raising. Tracked at the Lutaml migration guide referenced in the
+  error message: `docs/_guides/xml-namespaces.adoc`.

data/TODO.pdf/76-tagged-pdf-structure.md

@@ -0,0 +1,92 @@
+# TODO PDF 76: Tagged PDF structure tree
+
+## Status: PLANNED (design only)
+
+## Goal
+
+Emit a tagged-PDF structure tree (PDF/UA-1, PDF 1.7 §14.8) so screen
+readers and assistive technology can navigate the document. Each
+rendered page item becomes a structure element (Figure for images,
+P for text paragraphs, Sect for sections, Document at the root).
+
+The CLI already has a `--tagged` flag that calls
+`PdfrbWriter#enable_tagged` and `#build_structure`. Today these calls
+produce an empty `/StructTreeRoot`. This TODO populates the tree.
+
+## Background
+
+PDF structure elements form a tree rooted at `/StructTreeRoot`:
+
+```
+Document
+├── Part (per spread)
+│   ├── Sect (per page)
+│   │   ├── Figure (per Image)
+│   │   ├── P (per TextFrame paragraph)
+│   │   ├── Path (per shape)
+│   │   └── Sect (per Group, recursively)
+```
+
+Each element carries:
+- `/S` — structure type (Figure, P, Sect, etc.)
+- `/P` — parent element reference
+- `/K` — kids (mcid integers or child element refs)
+- `/Pg` — page reference (for leaf elements with mcid)
+- `/Alt` — alternate description (e.g. image alt text)
+- `/Lang` — language override
+
+Marked-content operators `BMC`/`EMC` (or `BDC`/`EMC` with property
+list) wrap content in the content stream, carrying an MCID that
+links back to the structure element.
+
+pdfrb 0.4.0 exposes:
+- `Pdfrb::Content::Canvas#tagged(tag, mcid: nil, **props, &block)` —
+  emits `BDC`/`EMC` with property list.
+- `Pdfrb::Content::Canvas#artifact(type = nil, &block)` — wraps
+  content as a PDF/UA artifact (header/footer/decoration).
+- `Pdfrb::Document::Structure#add_element(type, text:, alt:, page:,
+  mcid:)` — registers a structure element.
+
+## Plan
+
+1. **MCID allocation**: Each renderer requests an MCID from a
+   per-page counter (kept in `RenderContext`) before drawing its
+   item. The MCID goes into the `tagged` call wrapping the draw.
+2. **Structure element registration**: After the canvas draw, the
+   renderer calls `writer.add_structure_element(type, page_index:,
+   mcid:, text:, alt:)` to register the structure element.
+3. **Renderer mapping**: Each renderer maps its item to a structure
+   type:
+   - `RectangleRenderer`/`PolygonRenderer` with `ContentType="GraphicType"`
+     and an image child → `Figure` with `Alt` from IDML `<Image Alt="...">`.
+   - `RectangleRenderer`/`PolygonRenderer` without image → `Path` (or
+     `Sect` if the item is a container).
+   - `TextFrameRenderer` → `P` (one per paragraph run).
+   - `GroupRenderer` → `Sect` (wraps its children's elements).
+   - `TableRenderer` → `Table`, `TR`, `TH`, `TD` per row/cell.
+4. **Artifact marking**: Page furniture (master-spread items,
+   non-content decorations) is wrapped in `artifact(:background)`.
+5. **Pipeline threading**: Pipeline passes a `structure: true` flag
+   through `RenderContext`. Renderers only emit structure when the
+   flag is set.
+6. **Build**: Pipeline calls `writer.build_structure` at the end —
+   this stitches the per-element registrations into a `/StructTreeRoot`.
+
+## Acceptance criteria
+
+- [ ] `idml render --tagged sample.idml -o out.pdf` produces a PDF
+      whose `/StructTreeRoot` has a non-empty `/K` array.
+- [ ] Each visible page item maps to a structure element with the
+      right type (Figure, P, Path, Sect, Table).
+- [ ] `pdfinfo out.pdf` (or equivalent) reports `Tagged: yes`.
+- [ ] Spec renders a fixture and asserts presence of structure
+      elements matching the rendered items.
+- [ ] Items filtered out by `LayerFilter` do not get structure
+      entries.
+
+## Dependencies
+
+- pdfrb `Canvas#tagged` and `Document::Structure#add_element` (DONE
+  in 0.4.0).
+- Per-page MCID counter — small addition to `RenderContext`.
+- Per-renderer structure-type mapping table.

data/TODO.pdf/77-pdfa-xmp-output-intent.md

@@ -0,0 +1,74 @@
+# TODO PDF 77: PDF/A XMP metadata and output intent
+
+## Status: PLANNED (design only)
+
+## Goal
+
+Emit PDF/A-compliant XMP metadata so the rendered PDF passes
+veraPDF/A validation. PDF/A requires:
+
+1. An XMP metadata stream on the Catalog (`/Metadata`).
+2. The XMP must include:
+   - `pdfaid:part` — PDF/A version part number (e.g. `2`).
+   - `pdfaid:conformance` — `A`, `B`, or `U`.
+   - `dc:format` = `application/pdf`.
+3. An `/OutputIntent` referencing an ICC profile (sRGB for PDF/A-2).
+4. No unreferenced fonts, embedded fonts subsetted, no JPEG-in-JPEG,
+   etc. (TODOs 52, 53 cover most of this).
+
+The CLI's `--pdf-a` flag already sets `compliance: :pdfa2a` on the
+Pipeline. Today this is treated as a hint but produces no PDF/A-
+specific output. This TODO implements the actual XMP + output
+intent emission.
+
+## Background
+
+pdfrb 0.4.0 ships the primitives:
+
+- `Pdfrb::XMP::Packet` — assembles an XMP packet from Dublin Core,
+  PDF, XMP Basic, and XMP Rights schemas.
+- `Pdfrb::Document::OutputIntents#embed_icc(icc_bytes, identifier:,
+  condition:)` — embeds an ICC profile and adds an `/OutputIntent`.
+- `Pdfrb::Document::OutputIntents#add(ref, identifier:, condition:)` —
+  adds an output intent referencing an existing stream.
+
+pdfrb's `XMP::Schemas` only covers Dublin Core + PDF + XMP Basic +
+XMP Rights. The PDF/A `pdfaid:` namespace is not yet modelled, so
+extending the packet requires either:
+
+1. Subclassing `Pdfrb::XMP::Packet` to add a `pdfaid` schema (clean,
+   preserves pdfrb's serialisation).
+2. Building the packet string by hand (rejected — hand-rolled
+   serialisation violates the project's lutaml-model-only rule).
+
+## Plan
+
+1. Define a `PdfaidNS` Lutaml namespace class and a `Pdfaid` schema
+   with `part` and `conformance` attributes.
+2. Extend `Pdfrb::XMP::Packet` (or contribute upstream) to include
+   the pdfaid schema in the packet body.
+3. Bundle an sRGB ICC profile (or accept a user-supplied path).
+4. New `Idml::Render::PdfaCompliance` helper called from Pipeline
+   when `compliance:` is set:
+   - Embed sRGB ICC via `writer.document.output_intents.embed_icc(...)`.
+   - Build the XMP packet with pdfaid:part=2, pdfaid:conformance=A.
+   - Attach the packet to the Catalog as `/Metadata`.
+5. Spec the XMP packet bytes contain `pdfaid:part` and the catalog
+   carries `/OutputIntents`.
+
+## Acceptance criteria
+
+- [ ] `idml render --pdf-a sample.idml -o out.pdf` produces a PDF
+      with `/OutputIntents` referencing an sRGB ICC profile.
+- [ ] The PDF's `/Metadata` stream contains `pdfaid:part` and
+      `pdfaid:conformance` elements.
+- [ ] `veraPDF --flavour 2a out.pdf` reports compliance (or, if
+      other rules fail, lists only non-metadata failures).
+- [ ] Spec covers XMP assembly and ICC embedding.
+
+## Dependencies
+
+- pdfrb 0.4.0 `XMP::Packet`, `OutputIntents` (DONE).
+- A pdfaid schema model in pdfrb or in `Idml::Render::XmpExtensions`.
+- An sRGB ICC profile asset.
+- TODO 75 (Lutaml XMP) — same blocker.

data/lib/idml/cli.rb

@@ -67,6 +67,8 @@ module Idml
                           desc: "Produce PDF/A-2a compliant output"
     method_option :tagged, type: :boolean, default: false,
                            desc: "Produce tagged PDF (PDF/UA)"
+    method_option :no_subset, type: :boolean, default: false,
+                              desc: "Skip font subsetting (larger PDF)"
     method_option :verbose, aliases: "-v", type: :boolean, default: false,
                             desc: "Print progress"
     def render(path)
@@ -97,6 +99,7 @@ module Idml
         font_search_paths: font_search_paths,
         compliance: options[:pdf_a] ? :pdfa2a : nil,
         tagged: options[:tagged],
+        subset_fonts: !options[:no_subset],
       }
     end
 

data/lib/idml/elements/graphic_line.rb

@@ -10,6 +10,10 @@ 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
@@ -22,6 +26,10 @@ 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

data/lib/idml/elements/polygon.rb

@@ -12,6 +12,10 @@ 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
@@ -27,6 +31,10 @@ 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

data/lib/idml/elements/rectangle.rb

@@ -15,6 +15,10 @@ 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
@@ -33,6 +37,10 @@ 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

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/pdfrb_writer.rb

@@ -6,14 +6,26 @@ module Idml
     # Delegates all PDF assembly to pdfrb (no hand-rolled PDF code).
     # The adapter provides a consistent interface for the Pipeline
     # (add_page → returns Canvas, add_image → name, register_font → name,
-    # set_info, add_bookmark) while letting pdfrb handle xref, trailer,
-    # object streams, and operator emission.
+    # set_info, add_bookmark, subset_fonts!) while letting pdfrb handle
+    # xref, trailer, object streams, and operator emission.
     class PdfrbWriter
       DEFAULT_WIDTH = 612
       DEFAULT_HEIGHT = 792
 
+      META_SETTERS = {
+        Title: :title=,
+        Author: :author=,
+        Subject: :subject=,
+        Keywords: :keywords=,
+        Creator: :creator=,
+        Producer: :producer=,
+        CreationDate: :creationdate=,
+        ModDate: :moddate=,
+      }.freeze
+
       def initialize
         @document = Pdfrb::Document.new
+        @image_cache = {}
       end
 
       def add_page(width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT)
@@ -39,20 +51,25 @@ module Idml
         meta = @document.metadata
         hash.each do |key, value|
           setter = META_SETTERS[key.to_sym]
-          meta.public_send(setter, value.to_s) if setter
+          next unless setter
+
+          meta.public_send(setter, value.to_s)
         end
       end
 
+      def subset_fonts!
+        @document.fonts.subset_fonts!
+      end
+
       def write(path)
         @document.write(path)
       end
 
       def image_name_for(uri)
-        @image_cache&.key?(uri) ? @image_cache[uri] : nil
+        @image_cache[uri]
       end
 
       def register_image_name(uri, name)
-        @image_cache ||= {}
         @image_cache[uri] = name
       end
 
@@ -72,17 +89,6 @@ module Idml
       def document
         @document
       end
-
-      META_SETTERS = {
-        Title: :title=,
-        Author: :author=,
-        Subject: :subject=,
-        Keywords: :keywords=,
-        Creator: :creator=,
-        Producer: :producer=,
-        CreationDate: :creationdate=,
-        ModDate: :moddate=,
-      }.freeze
     end
   end
 end

data/lib/idml/render/pipeline.rb

@@ -10,12 +10,13 @@ module Idml
       DEFAULT_HEIGHT = 792
 
       def initialize(package, output_path, font_search_paths = nil,
-                     compliance: nil, tagged: false)
+                     compliance: nil, tagged: false, subset_fonts: true)
         @package = package
         @output_path = output_path
         @font_resolver = build_font_resolver(font_search_paths)
         @compliance = compliance
         @tagged = tagged
+        @subset_fonts = subset_fonts
       end
 
       def call
@@ -33,6 +34,7 @@ module Idml
         end
 
         writer.build_structure if @tagged
+        writer.subset_fonts! if @subset_fonts
         writer.write(@output_path)
         @output_path
       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
 
           Blending.wrap(canvas, line.transparency_setting) 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
+            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,7 +8,7 @@ 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
 
           Blending.wrap(canvas, poly.transparency_setting) do
@@ -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