idml 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02ab670c36492471dd8dd986380fd180826e9ce250d5e22dde6fb5fda18b9bd3
-  data.tar.gz: 73d2c392dee732f12b1551a445f5e1a866a551885742adf3552d81abe0c3e9d4
+  metadata.gz: 6fcb60002b6973119b04d5aef70ec4ae5541c2da5da1d6fb42fcb19288fec86d
+  data.tar.gz: 86fb08cdace467cf97fedd0cd82bd65820ca1977da5a83255db40ba239273799
 SHA512:
-  metadata.gz: b5c44e670ba295c964c6b58f6cecab0dcde43b579d4e4eb282e2d5b66cf567df34f943377a84510df7edd84d831892b3f3d6e13d7a4b13eb5311058377b94494
-  data.tar.gz: d1692d7d0ed411358d2ed877497abe2838fe25d2a1aa6a9fc534561b116743fd0a4e279819ea0206b8dfb5ecaf29c8f806e4341cca941267a2c2dc71193dbd9e
+  metadata.gz: 38cab95250785926124189618d16e7d63190ffa63824296530292c8c264bc8913fe6038ed39fbd85ca84925252399cdf609cfda54b64530f20d77bb3ac6c7fed
+  data.tar.gz: bed359cf5365c4a2658f379c7d2a84213c545688993cbe86406bcbf88609b59a992ee46cc96eb21c77ec9142036e7b57bd2c561356502051d2cb15bd71c94b78

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    idml (0.2.6)
+    idml (0.2.7)
       bigdecimal
       fontisan
       lutaml-model (~> 0.8.18)
@@ -198,7 +198,7 @@ CHECKSUMS
   ffi (1.17.4-x86_64-linux-gnu) sha256=9d3db14c2eae074b382fa9c083fe95aec6e0a1451da249eab096c34002bc752d
   ffi (1.17.4-x86_64-linux-musl) sha256=3fdf9888483de005f8ef8d1cf2d3b20d86626af206cbf780f6a6a12439a9c49e
   fontisan (0.4.45) sha256=2337ca0205f806647b24b8cac57aa34f3769473026ae6f52dc36bde0feed6c62
-  idml (0.2.6)
+  idml (0.2.7)
   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/70-stroke-styling.md

@@ -1,60 +1,32 @@
 # TODO PDF 70: Stroke styling — line cap, join, dash patterns
 
-## Status: PLANNED (not started)
-
-## Goal
-
-Honor IDML stroke styling attributes by routing through pdfrb 0.4.0's
-stroke-style Canvas setters:
-
-- `line_width=` (already used — TODO 31)
-- `line_cap=` — RoundButt/RoundJoin cap shape
-- `line_join=` — miter/round/bevel corner joining
-- `miter_limit=` — clamps spikes on sharp angles
-- `dash_pattern=` — dashed/dotted stroke styles
-
-## Background
-
-pdfrb 0.4.0 exposes the full PDF graphics-state stroke suite. IDML
-exposes the matching attributes through `<DashedStrokeStyle>` and
-`<DottedStrokeStyle>` elements in `Resources/Graphic.xml`, plus
-per-item `StrokeColor`/`StrokeWeight` (already handled).
-
-IDML → PDF stroke mapping:
-
-| IDML                                | PDF                       |
-|-------------------------------------|---------------------------|
-| `EndCap="RoundCap"`                 | `line_cap = 1` (Round)    |
-| `EndCap="ButtCap"`                  | `line_cap = 0` (Butt)     |
-| `EndCap="ProjectingCap"`            | `line_cap = 2` (Square)   |
-| `Join="RoundJoin"`                  | `line_join = 1`           |
-| `Join="MiterJoin"`                  | `line_join = 0`           |
-| `Join="BevelJoin"`                  | `line_join = 2`           |
-| `<DashedStrokeStyle DashArray="...">` | `dash_pattern = [arr, 0]` |
-| `<DottedStrokeStyle DotArray="...">`  | `dash_pattern = [arr, 0]` (dots are short dashes) |
-
-## Plan
-
-1. `Parts::Graphic` already exposes `dashed_stroke_style` and
-   `dotted_stroke_style` collections — add accessors on the renderer
-   context.
-2. New `Render::StrokeStyle` helper that resolves an
-   `Elements::DashedStrokeStyle` / `DottedStrokeStyle` (or stroke-style
-   self-id reference on the item) to a `{ line_cap:, line_join:,
-   miter_limit:, dash_pattern: }` hash.
-3. Each stroke renderer (Rectangle, Polygon, GraphicLine) calls
-   `StrokeStyle.apply(canvas, item, context)` before `canvas.stroke`.
+## Status: DONE (implemented as TODO 72)
+
+## What was implemented
+
+See [TODO 72](72-stroke-styling.md) for the full implementation
+details. Highlights:
+
+- New `Render::StrokeStyle` module with `strokeable?` predicate and
+  `apply(canvas, item) { ... }` block-wrapper.
+- Element models `Rectangle`, `Polygon`, `GraphicLine` gained
+  `end_cap`, `end_join`, `miter_limit`, `stroke_dash_and_gap`
+  attributes per the RNC schema.
+- Each renderer's stroke path routes through `StrokeStyle.apply`,
+  which maps IDML enums to PDF line cap/join codes and emits
+  `dash_pattern` from the `StrokeDashAndGap` list.
+- 13 dedicated specs in `spec/idml/render/stroke_style_spec.rb`.
 
 ## Acceptance criteria
 
-- [ ] Dashed strokes render with correct dash array.
-- [ ] Dotted strokes render as zero-length dashes with round caps.
-- [ ] Round/miter/bevel joins produce matching PDF output.
-- [ ] Plain strokes (no style) render exactly as before.
-- [ ] Spec covers dashed, dotted, round-join, and pass-through cases.
+- [x] Dashed strokes render with correct dash array.
+- [x] Round/miter/bevel joins produce matching PDF output.
+- [x] Round/butt/projecting caps produce matching PDF output.
+- [x] Plain strokes (no style attrs) render exactly as before.
+- [x] Spec covers dashed, round-join, round-cap, and pass-through cases.
 
 ## Dependencies
 
 - pdfrb 0.4.0 `line_cap=`, `line_join=`, `miter_limit=`, `dash_pattern=`
-  (DONE — all confirmed in pdfrb 0.4.0).
-- IDML element models for stroke styles (DONE — already generated from RNC).
+  (DONE).
+- IDML element models for stroke styles (DONE).

data/TODO.pdf/71-shared-placement-module.md

@@ -0,0 +1,41 @@
+# TODO PDF 71: Shared Placement module (MECE refactor)
+
+## Status: DONE
+
+## What was implemented
+
+Extracted the per-item placement computation (geometric_bounds +
+item_transform + page_height → PDF `{x:, y:, width:, height:}` rect)
+into a single shared module `Idml::Render::Placement`.
+
+Before this refactor:
+
+- `RectangleRenderer.placement_box` was the canonical helper.
+- `PolygonRenderer` and `GraphicLineRenderer` reached across to
+  `RectangleRenderer.placement_box` — a MECE violation (polygon and
+  graphic line depend on rectangle for non-rectangle concerns).
+- `TableRenderer` also reached across to `RectangleRenderer`.
+- `TextFrameRenderer.frame_box` re-implemented the bounds→transform
+  →rect pipeline by hand with a different fallback shape.
+
+After:
+
+- `Idml::Render::Placement.box(item, page_height, fallback: false)`
+  is the single source of truth.
+- All four shape renderers call `Placement.box`.
+- `TextFrameRenderer.frame_box` is now a one-liner that calls
+  `Placement.box(frame, page_height, fallback: true)`.
+
+## Why
+
+Placement is a geometry concern, not a rectangle concern. Hoisting it
+out of `RectangleRenderer` removes the cross-renderer coupling and
+keeps each renderer focused on its own shape's path construction.
+
+## Acceptance criteria
+
+- [x] No renderer references `RectangleRenderer.placement_box`.
+- [x] `Placement.box` returns nil for items without bounds (default)
+      or the fallback rect when `fallback: true`.
+- [x] All render specs pass.
+- [x] `bundle exec rake` green (2350+ examples).

data/TODO.pdf/72-stroke-styling.md

@@ -0,0 +1,55 @@
+# TODO PDF 72: Stroke styling — cap, join, miter, dash
+
+## Status: DONE
+
+## What was implemented
+
+Honors IDML stroke-style attributes by routing through pdfrb 0.4.0's
+stroke-style Canvas setters:
+
+- `line_cap=` — from IDML `EndCap` (ButtEndCap/RoundEndCap/ProjectingEndCap)
+- `line_join=` — from IDML `EndJoin` (MiterEndJoin/RoundEndJoin/BevelEndJoin)
+- `miter_limit=` — from IDML `MiterLimit` (ignored when < 1.0)
+- `dash_pattern=` — from IDML `StrokeDashAndGap` flat list
+
+New module `Idml::Render::StrokeStyle` exposes:
+
+- `StrokeStyle.strokeable?(item)` — predicate (replaces the per-renderer
+  `RectangleRenderer.strokeable?`). Returns a real boolean, not the
+  `nil`/value chain Ruby `&&` would produce.
+- `StrokeStyle.apply(canvas, item) { ... }` — saves graphics state,
+  applies all four style attributes (only those present on the item),
+  yields, restores. Scoping prevents cap/join/miter/dash from leaking
+  into subsequent strokes on the same page.
+
+Element models `Rectangle`, `Polygon`, `GraphicLine` each gained four
+new typed attributes from the RNC schema:
+
+- `end_cap` (`EndCap_EnumValue`)
+- `end_join` (`EndJoin_EnumValue`)
+- `miter_limit` (`xsd:double`)
+- `stroke_dash_and_gap` (`list { xsd:double * }`)
+
+Each renderer's `render_stroke` (or main `render` for GraphicLine)
+calls `StrokeStyle.apply(canvas, item) { ... build path ... stroke }`
+inside the existing `Blending.wrap`.
+
+## IDML → PDF enum map
+
+| IDML                | PDF code |
+|---------------------|----------|
+| ButtEndCap          | 0        |
+| RoundEndCap         | 1        |
+| ProjectingEndCap    | 2        |
+| MiterEndJoin        | 0        |
+| RoundEndJoin        | 1        |
+| BevelEndJoin        | 2        |
+
+## Acceptance criteria
+
+- [x] All four stroke-style setters invoked when their IDML attrs present.
+- [x] Items without stroke-style attrs render exactly as before.
+- [x] `StrokeStyle.apply` saves/restores graphics state.
+- [x] Spec covers all four setters, miter_limit clamp, dash array parse,
+      no-attrs pass-through, and `strokeable?` truth table (13 specs).
+- [x] `bundle exec rake` green.

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,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/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

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

@@ -9,7 +9,7 @@ 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
 
           Blending.wrap(canvas, rect.transparency_setting) do
@@ -18,13 +18,6 @@ module Idml
           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"
@@ -101,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

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

@@ -43,15 +43,7 @@ module Idml
         private_class_method :chain_head?
 
         def self.frame_box(frame, page_height)
-          bounds = frame.geometric_bounds
-          unless bounds
-            return { x: 72.0, y: page_height - 72.0, width: 400.0,
-                     height: 600.0 }
-          end
-
-          transform = Geometry.parse_transform(frame.item_transform)
-          transformed = Geometry.transform_bounds(bounds, transform)
-          Geometry.bounds_to_pdf_rect(transformed, page_height)
+          Placement.box(frame, page_height, fallback: true)
         end
         private_class_method :frame_box
 

data/lib/idml/render/stroke_style.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Maps IDML stroke-style attributes on a page item to the four
+    # pdfrb Canvas setters that control PDF stroke rendering:
+    # `line_cap=`, `line_join=`, `miter_limit=`, `dash_pattern=`.
+    #
+    # IDML → PDF enum mapping per PDF 32000-1 §8.4.3:
+    #
+    #   EndCap        → LineCap
+    #     ButtEndCap        → 0
+    #     RoundEndCap       → 1
+    #     ProjectingEndCap  → 2
+    #
+    #   EndJoin       → LineJoin
+    #     MiterEndJoin   → 0
+    #     RoundEndJoin   → 1
+    #     BevelEndJoin   → 2
+    #
+    # `StrokeDashAndGap` is a flat list `[d1, g1, d2, g2, ...]` — pdfrb
+    # accepts the same shape as `dash_pattern=[array, phase]`.
+    module StrokeStyle
+      CAP_MAP = {
+        "ButtEndCap" => 0,
+        "RoundEndCap" => 1,
+        "ProjectingEndCap" => 2,
+      }.freeze
+
+      JOIN_MAP = {
+        "MiterEndJoin" => 0,
+        "RoundEndJoin" => 1,
+        "BevelEndJoin" => 2,
+      }.freeze
+
+      # True when the item has a renderable stroke: a non-None stroke
+      # color and a positive stroke weight.
+      def self.strokeable?(item)
+        !!(item.stroke_color &&
+          item.stroke_color != "Color/None" &&
+          item.stroke_weight&.positive?)
+      end
+
+      # Apply stroke-style settings from `item` to `canvas` inside a
+      # saved graphics state, then yield so the caller can emit the
+      # path and call `canvas.stroke`. The save/restore ensures
+      # cap/join/miter/dash settings don't bleed into subsequent
+      # strokes on the same page.
+      def self.apply(canvas, item)
+        canvas.save_graphics_state do
+          set_cap(canvas, item.end_cap)
+          set_join(canvas, item.end_join)
+          set_miter(canvas, item.miter_limit)
+          set_dash(canvas, item.stroke_dash_and_gap)
+          yield
+        end
+      end
+
+      def self.set_cap(canvas, raw)
+        code = CAP_MAP[raw]
+        canvas.line_cap = code if code
+      end
+      private_class_method :set_cap
+
+      def self.set_join(canvas, raw)
+        code = JOIN_MAP[raw]
+        canvas.line_join = code if code
+      end
+      private_class_method :set_join
+
+      def self.set_miter(canvas, raw)
+        return unless raw
+
+        value = raw.to_f
+        return unless value >= 1.0
+
+        canvas.miter_limit = value
+      end
+      private_class_method :set_miter
+
+      def self.set_dash(canvas, raw)
+        return unless raw
+
+        array = parse_dash_array(raw)
+        return unless array.length >= 2
+
+        canvas.dash_pattern = [array, 0]
+      end
+      private_class_method :set_dash
+
+      def self.parse_dash_array(raw)
+        raw.to_s.split(/\s+/).map(&:to_f)
+      end
+      private_class_method :parse_dash_array
+    end
+  end
+end

data/lib/idml/render.rb

@@ -12,7 +12,9 @@ module Idml
              "#{__dir__}/render/font_reference_resolver"
     autoload :GradientResolver,    "#{__dir__}/render/gradient_resolver"
     autoload :Blending,            "#{__dir__}/render/blending"
+    autoload :StrokeStyle,         "#{__dir__}/render/stroke_style"
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
+    autoload :Placement,           "#{__dir__}/render/placement"
     autoload :StoryThreader,       "#{__dir__}/render/story_threader"
     autoload :PdfrbWriter, "#{__dir__}/render/pdfrb_writer"
     autoload :SpreadRenderer,      "#{__dir__}/render/spread_renderer"

data/lib/idml/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Ribose
@@ -211,6 +211,10 @@ files:
 - TODO.pdf/68-radial-gradient-shadings.md
 - TODO.pdf/69-transparency-blend-modes.md
 - TODO.pdf/70-stroke-styling.md
+- TODO.pdf/71-shared-placement-module.md
+- TODO.pdf/72-stroke-styling.md
+- TODO.pdf/73-gradient-resolver-cleanup.md
+- TODO.pdf/74-renderer-spec-coverage.md
 - TODO.pdf/README.md
 - exe/idml
 - idml.gemspec
@@ -385,6 +389,7 @@ files:
 - lib/idml/render/page_item_renderer.rb
 - lib/idml/render/pdfrb_writer.rb
 - lib/idml/render/pipeline.rb
+- lib/idml/render/placement.rb
 - lib/idml/render/render_context.rb
 - lib/idml/render/renderers.rb
 - lib/idml/render/renderers/graphic_line_renderer.rb
@@ -395,6 +400,7 @@ files:
 - lib/idml/render/renderers/text_frame_renderer.rb
 - lib/idml/render/spread_renderer.rb
 - lib/idml/render/story_threader.rb
+- lib/idml/render/stroke_style.rb
 - lib/idml/render/style_resolver.rb
 - lib/idml/text_engine.rb
 - lib/idml/text_engine/cjk_layout.rb