idml 0.8.8 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad2709aae7d11f8a91843141700ab7882b9b7a196480d7b6077fe4f0b6473d16
-  data.tar.gz: b6fd8d8df9996dabd3fd4ffbfc9fb788930cb3ca04bb6f014ae8b3c9fce5b6af
+  metadata.gz: d58f00746f6afb4233e161dfa9cdeb116d714eed0c238ec543a0f039b4167f0e
+  data.tar.gz: 1a000e34996525fe34cdc441625c9eaa303f121c836ae3f3b07b73c12712abb1
 SHA512:
-  metadata.gz: 20154b884fb1688985cdca3c7a3866e7c55be9059768d4a00eae4058bdd237f3606c964318d224bdd198853bc61a0a9167012b5dc6cc558f4a31537146a45a27
-  data.tar.gz: 7075c7451518b208e6ce17da854fb9954048ed40825287dc87bf4b4543467a0677a277fdf49f124703c353dfc4faf1b770de936d69acf1b0958998887a1cb101
+  metadata.gz: 15001cbf1427dc278c701cd4980b837ff4b015f6c5657eeb5c88c0c8774933934e606439c40fa3c900368ef2959fc1170cd12841a9caadc0c025a199dd18cd68
+  data.tar.gz: 41f45b1b2db245e1dd2d5ef40aa60990fc3c957930b3d16a633974d1f267149e8b2c5cf638b7b3549b4318bf8ea62f378fbb5d0f98ad32d4d50fbce0e3cb9505

data/TODO.pdf/106-page-item-type-coverage.md

@@ -1,12 +1,42 @@
 # TODO PDF 106: Page-item type coverage — Ellipse, Path, EPS, WMF, PICT, HtmlItem
 
-## Status: PARTIAL — Oval and Path elements modeled and rendered
-(registered in RENDERER_MAP, delegate to RectangleRenderer which draws
-the bounding box with fill/stroke). Documents containing Oval or Path
-page items no longer silently skip them. True elliptical rendering
-(bezier anchor/control points) and compound-path drawing are
-refinements. EPS / WMF / PICT / HtmlItem remain out of scope (foreign
-formats).
+## Status: COMPLETE (rendering scope) — implemented 2026-08-17
+
+## What was built (2026-08-17 refinement: true contours)
+
+- `Render::Contour` — draws an item's PathGeometry as true Bézier
+  contours: PathPointType anchors, LeftDirection / RightDirection
+  control handles, ItemTransform applied per point, y flipped into
+  PDF space. One subpath per GeometryPathType (compound paths);
+  closed unless PathOpen="true"; degenerate handles fall back to the
+  anchor. OvalRenderer, PathRenderer, and PolygonRenderer all
+  delegate here — ovals render as real ellipses (rotation preserved
+  through the transform), polygons as their actual outlines, Paths
+  as compound contours. Bounding-box rectangle fallback when an
+  item has no PathGeometry but has geometric_bounds.
+- `Render::ShapePaint` — the single owner of the IDML → PDF paint
+  mapping (solid fill, gradient shading fill, stroke styling, and
+  the PDF paint-op sequencing including fill_stroke on one path).
+  RectangleRenderer now delegates to it; the fill/stroke/gradient
+  logic it previously duplicated across shape renderers lives in
+  one place.
+- Oval/Path modeled + registered in RENDERER_MAP (earlier
+  milestone); Polygon renders contours instead of its bounding box.
+
+## Out of scope (unchanged)
+
+- EPS / WMF / PICT / HtmlItem / Movie / Sound / FormField — foreign
+  or interactive formats, not modeled. Image placement goes through
+  ImageCollector (separate, model-driven path).
+
+## Acceptance criteria
+
+- [x] SpreadObject has `oval` + `path` collections (Ellipse is the
+      Oval element in the schema's naming).
+- [x] OvalRenderer / PathRenderer registered in RENDERER_MAP.
+- [x] True Bézier rendering from PathGeometry anchors + control
+      points (TODO 106 refinement complete).
+- [x] Compound Path objects render with multiple sub-paths.
 
 ## Problem
 

data/lib/idml/render/contour.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Renders a page item's PathGeometry as true Bézier contours on
+    # a pdfrb canvas. Shared by OvalRenderer, PathRenderer, and
+    # PolygonRenderer: every item whose Properties carry a
+    # PathGeometry draws its actual outline — PathPointType anchors
+    # with LeftDirection / RightDirection control handles,
+    # ItemTransform applied, y flipped into PDF space — instead of
+    # its bounding box. Paint op selection (fill / stroke /
+    # gradient) lives in ShapePaint. Items without usable geometry
+    # fall back to the bounding-box rectangle.
+    module Contour
+      # Renders the item's contours with fill/stroke from
+      # ShapePaint. Returns true when painted.
+      def self.render(canvas, context)
+        item = context.item
+        return false if item.visible == false
+
+        paths = geometry_paths(item)
+        return rectangle_fallback(canvas, item, context) if paths.empty?
+
+        ShapePaint.paint(canvas, item, context) do |c|
+          draw_path(c, paths, item.item_transform, context.page_height)
+        end
+      end
+
+      def self.rectangle_fallback(canvas, item, context)
+        box = Placement.box(item, context.page_height)
+        return false unless box
+
+        ShapePaint.paint(canvas, item, context) do |c|
+          c.rectangle(box[:x], box[:y], box[:width], box[:height])
+        end
+      end
+      private_class_method :rectangle_fallback
+
+      # All GeometryPathType children across the item's Properties.
+      def self.geometry_paths(item)
+        item.properties.flat_map do |props|
+          props.path_geometry.flat_map(&:geometry_path_type)
+        end
+      end
+
+      # Constructs the full path on the canvas: one subpath per
+      # GeometryPathType, each starting at its first anchor and
+      # curving through every subsequent anchor via the points'
+      # control handles. Closed paths (PathOpen false or absent)
+      # loop back to the first anchor and close.
+      def self.draw_path(canvas, paths, item_transform, page_height)
+        transform = Geometry.parse_transform(item_transform)
+        paths.each do |path|
+          draw_subpath(canvas, path, transform, page_height)
+        end
+      end
+
+      def self.draw_subpath(canvas, path, transform, page_height)
+        points = path.points
+        return if points.length < 2
+
+        open = path.path_open == true
+        anchors = points.map do |point|
+          pdf_pair(point.anchor, transform, page_height)
+        end
+        canvas.move_to(anchors.first[0], anchors.first[1])
+        draw_segments(canvas, points, anchors, transform, page_height, open)
+        canvas.close_path unless open
+      end
+      private_class_method :draw_subpath
+
+      def self.draw_segments(canvas, points, anchors, transform,
+                             page_height, open)
+        segment_count = open ? points.length - 1 : points.length
+        segment_count.times do |index|
+          from = points[index]
+          to = points[(index + 1) % points.length]
+          c1 = control_point(from, :right_direction, from.anchor,
+                             transform, page_height)
+          c2 = control_point(to, :left_direction, to.anchor,
+                             transform, page_height)
+          to_anchor = anchors[(index + 1) % points.length]
+          canvas.curve_to(c1[0], c1[1], c2[0], c2[1],
+                          to_anchor[0], to_anchor[1])
+        end
+      end
+      private_class_method :draw_segments
+
+      # Control point for one end of a segment: the point's
+      # direction handle when present, else the anchor itself
+      # (degenerate control = straight-ish curve).
+      def self.control_point(point, direction_attr, fallback, transform,
+                             page_height)
+        raw = point.public_send(direction_attr)
+        raw = nil if raw && raw.strip.empty?
+        pdf_pair(raw || fallback, transform, page_height)
+      end
+      private_class_method :control_point
+
+      # Parses an IDML "x y" pair, applies the item transform, and
+      # flips y into PDF space (origin bottom-left).
+      def self.pdf_pair(raw, transform, page_height)
+        x, y = raw.to_s.split(/\s+/).map(&:to_f)
+        tx, ty = Geometry.apply_transform(transform, x, y)
+        [tx, page_height - ty]
+      end
+      private_class_method :pdf_pair
+    end
+  end
+end

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

@@ -3,14 +3,13 @@
 module Idml
   module Render
     module Renderers
-      # Renders an IDML Oval on a Pdfrb::Content::Canvas. Delegates to
-      # RectangleRenderer which draws the bounding box with fill/stroke.
-      # Approximation: a true ellipse would generate bezier anchor and
-      # control points from the PathGeometry; the bounding box renders
-      # the correct extent and colors. See TODO 106 for refinement.
+      # Renders an IDML Oval on a Pdfrb::Content::Canvas as a true
+      # Bézier ellipse from its PathGeometry (which preserves any
+      # rotation in the ItemTransform). Falls back to the
+      # bounding-box rectangle when the item carries no geometry.
       class OvalRenderer
         def self.render(canvas, context)
-          RectangleRenderer.render(canvas, context)
+          Contour.render(canvas, context)
         end
       end
     end

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

@@ -4,14 +4,13 @@ module Idml
   module Render
     module Renderers
       # Renders an IDML Path (standalone compound path) on a
-      # Pdfrb::Content::Canvas. Delegates to RectangleRenderer which
-      # draws the bounding box with fill/stroke. Approximation: a true
-      # compound path would draw each sub-path from the EntirePath
-      # list or PathPoint children; the bounding box renders the
-      # correct extent and colors. See TODO 106 for refinement.
+      # Pdfrb::Content::Canvas as its actual Bézier contours — one
+      # subpath per GeometryPathType, closed or open per PathOpen.
+      # Falls back to the bounding-box rectangle when the item
+      # carries no geometry.
       class PathRenderer
         def self.render(canvas, context)
-          RectangleRenderer.render(canvas, context)
+          Contour.render(canvas, context)
         end
       end
     end

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

@@ -3,46 +3,15 @@
 module Idml
   module Render
     module Renderers
+      # Renders an IDML Polygon on a Pdfrb::Content::Canvas as its
+      # actual Bézier contours from PathGeometry (control handles
+      # default to the anchors, so plain polygons render straight
+      # edges). Falls back to the bounding-box rectangle when the
+      # item carries no geometry.
       class PolygonRenderer
         def self.render(canvas, context)
-          poly = context.item
-          return if poly.visible == false
-
-          box = Placement.box(poly, context.page_height)
-          return unless box
-
-          Blending.wrap(canvas, poly.transparency_setting) do
-            render_fill(canvas, poly, context, box)
-            render_stroke(canvas, poly, context, box)
-          end
-        end
-
-        def self.render_fill(canvas, poly, context, box)
-          return unless poly.fill_color && poly.fill_color != "Color/None"
-
-          color = context.color_resolver&.resolve(poly.fill_color)
-          return unless color
-
-          canvas.fill_color(ColorHelper.to_canvas(color))
-          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
-          canvas.fill
-        end
-        private_class_method :render_fill
-
-        def self.render_stroke(canvas, poly, context, box)
-          return unless StrokeStyle.strokeable?(poly)
-
-          color = context.color_resolver&.resolve(poly.stroke_color)
-          return unless color
-
-          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
+          Contour.render(canvas, context)
         end
-        private_class_method :render_stroke
       end
     end
   end

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

@@ -3,7 +3,9 @@
 module Idml
   module Render
     module Renderers
-      # Renders an IDML Rectangle on a Pdfrb::Content::Canvas.
+      # Renders an IDML Rectangle on a Pdfrb::Content::Canvas: an
+      # axis-aligned rectangle from the item's placement box, with
+      # fill / stroke / gradient painting delegated to ShapePaint.
       class RectangleRenderer
         def self.render(canvas, context)
           rect = context.item
@@ -12,101 +14,10 @@ module Idml
           box = Placement.box(rect, context.page_height)
           return unless box
 
-          Blending.wrap(canvas, rect.transparency_setting) do
-            render_fill(canvas, rect, context, box)
-            render_stroke(canvas, rect, context, box)
+          ShapePaint.paint(canvas, rect, context) do |c|
+            c.rectangle(box[:x], box[:y], box[:width], box[:height])
           end
         end
-
-        def self.render_fill(canvas, rect, context, box)
-          return unless rect.fill_color
-          return if rect.fill_color == "Color/None"
-
-          if GradientResolver.gradient?(rect.fill_color)
-            render_gradient_fill(canvas, rect, context, box)
-            return
-          end
-
-          color = context.color_resolver&.resolve(rect.fill_color)
-          return unless color
-
-          canvas.fill_color(ColorHelper.to_canvas(color))
-          canvas.rectangle(box[:x], box[:y], box[:width], box[:height])
-          canvas.fill
-        end
-        private_class_method :render_fill
-
-        def self.render_gradient_fill(canvas, rect, context, box)
-          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
-
-        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,
-          )
-        end
-        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_for(rect, context)
-          graphic = context.package&.graphic
-          return nil unless graphic
-
-          graphic.gradient.find { |g| g.self_attr == rect.fill_color }
-        end
-        private_class_method :gradient_for
-
-        def self.gradient_stops(gradient, context)
-          gradient.gradient_stop.filter_map do |stop|
-            color = context.color_resolver&.resolve(stop.stop_color)
-            next unless color
-
-            [stop.location || 0.0, ColorHelper.to_canvas(color)]
-          end
-        end
-        private_class_method :gradient_stops
-
-        def self.render_stroke(canvas, rect, context, box)
-          return unless StrokeStyle.strokeable?(rect)
-
-          color = context.color_resolver&.resolve(rect.stroke_color)
-          return unless color
-
-          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
       end
     end
   end

data/lib/idml/render/shape_paint.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Paints a page item's fill and stroke on a pdfrb canvas,
+    # delegating path construction to the caller's block. The
+    # single owner of the IDML → PDF paint mapping — solid fill,
+    # gradient shading fill, stroke styling — shared by every
+    # shape renderer. Callers choose the geometry (axis-aligned
+    # rectangle, Bézier contour); this module chooses the paint
+    # and the PDF paint op sequencing (fill, stroke, or
+    # fill-and-stroke on one path).
+    module ShapePaint
+      # Paints the item. The block receives the canvas and must
+      # construct the current path (move_to/line_to/curve_to/...).
+      # The block may be called more than once (a path is consumed
+      # by each paint op, so fill-then-stroke rebuilds it).
+      # Returns nil when there is nothing to paint; truthy
+      # otherwise.
+      def self.paint(canvas, item, context, &build_path)
+        fill = fill_style(item, context)
+        stroke = stroke_style(item, context)
+        return unless fill || stroke
+
+        Blending.wrap(canvas, item.transparency_setting) do
+          paint_styles(canvas, item, context, fill, stroke, &build_path)
+        end
+      end
+
+      # Returns the fill plan: { kind: :solid, color: } for a
+      # resolved color, { kind: :gradient, gradient:, stops: } for
+      # a fill referencing a Gradient, nil when nothing fillable.
+      def self.fill_style(item, context)
+        return nil unless item.fill_color
+        return nil if item.fill_color == "Color/None"
+
+        if GradientResolver.gradient?(item.fill_color)
+          gradient_fill_style(item, context)
+        else
+          solid_fill_style(item, context)
+        end
+      end
+      private_class_method :fill_style
+
+      def self.gradient_fill_style(item, context)
+        gradient = gradient_for(item, context)
+        return nil unless gradient
+
+        stops = gradient_stops(gradient, context)
+        return nil unless stops.length >= 2
+
+        { kind: :gradient, gradient: gradient, stops: stops }
+      end
+      private_class_method :gradient_fill_style
+
+      def self.solid_fill_style(item, context)
+        color = context.color_resolver&.resolve(item.fill_color)
+        return nil unless color
+
+        { kind: :solid, color: ColorHelper.to_canvas(color) }
+      end
+      private_class_method :solid_fill_style
+
+      def self.stroke_style(item, context)
+        return nil unless StrokeStyle.strokeable?(item)
+
+        color = context.color_resolver&.resolve(item.stroke_color)
+        return nil unless color
+
+        { color: ColorHelper.to_canvas(color) }
+      end
+      private_class_method :stroke_style
+
+      def self.paint_styles(canvas, item, context, fill, stroke, &)
+        if fill && stroke
+          paint_fill_and_stroke(canvas, item, context, fill, stroke,
+                                &)
+        elsif fill
+          paint_fill(canvas, item, context, fill, &)
+        else
+          paint_stroke(canvas, item, stroke, &)
+        end
+      end
+      private_class_method :paint_styles
+
+      def self.paint_fill(canvas, item, context, fill, &)
+        yield(canvas)
+        if fill[:kind] == :gradient
+          canvas.fill_shading(shading_for(canvas, item, context, fill))
+        else
+          canvas.fill_color(fill[:color])
+          canvas.fill
+        end
+      end
+      private_class_method :paint_fill
+
+      def self.paint_stroke(canvas, item, stroke, &)
+        StrokeStyle.apply(canvas, item) do
+          canvas.stroke_color(stroke[:color])
+          canvas.line_width = item.stroke_weight
+          yield(canvas)
+          canvas.stroke
+        end
+      end
+      private_class_method :paint_stroke
+
+      # Fill and stroke on one path where possible (fill_stroke);
+      # a gradient fill consumes the path, so the stroke rebuilds
+      # it afterward.
+      def self.paint_fill_and_stroke(canvas, item, context, fill, stroke,
+                                     &)
+        if fill[:kind] == :gradient
+          paint_fill(canvas, item, context, fill, &)
+          paint_stroke(canvas, item, stroke, &)
+        else
+          yield(canvas)
+          canvas.fill_color(fill[:color])
+          StrokeStyle.apply(canvas, item) do
+            canvas.stroke_color(stroke[:color])
+            canvas.line_width = item.stroke_weight
+            canvas.fill_stroke
+          end
+        end
+      end
+      private_class_method :paint_fill_and_stroke
+
+      def self.shading_for(canvas, item, context, fill)
+        box = Placement.box(item, context.page_height)
+        stops = fill[:stops]
+        if fill[:gradient].type == "Radial"
+          canvas.document.shadings.add_radial(
+            from: radial_center(box, 0.0),
+            to: radial_center(box, [box[:width], box[:height]].max / 2.0),
+            stops: stops,
+          )
+        else
+          canvas.document.shadings.add_axial(
+            from: [box[:x], box[:y] + box[:height]],
+            to: [box[:x] + box[:width], box[:y]],
+            stops: stops,
+          )
+        end
+      end
+      private_class_method :shading_for
+
+      def self.radial_center(box, radius)
+        cx = box[:x] + (box[:width] / 2.0)
+        cy = box[:y] + (box[:height] / 2.0)
+        [cx, cy, radius]
+      end
+      private_class_method :radial_center
+
+      def self.gradient_for(item, context)
+        graphic = context.package&.graphic
+        return nil unless graphic
+
+        graphic.gradient.find { |g| g.self_attr == item.fill_color }
+      end
+      private_class_method :gradient_for
+
+      def self.gradient_stops(gradient, context)
+        gradient.gradient_stop.filter_map do |stop|
+          color = context.color_resolver&.resolve(stop.stop_color)
+          next unless color
+
+          [stop.location || 0.0, ColorHelper.to_canvas(color)]
+        end
+      end
+      private_class_method :gradient_stops
+    end
+  end
+end

data/lib/idml/render.rb

@@ -23,6 +23,8 @@ module Idml
     autoload :ConditionFilter,     "#{__dir__}/render/condition_filter"
     autoload :TextWrapResolver,    "#{__dir__}/render/text_wrap_resolver"
     autoload :Footnote,            "#{__dir__}/render/footnote"
+    autoload :ShapePaint,          "#{__dir__}/render/shape_paint"
+    autoload :Contour,             "#{__dir__}/render/contour"
     autoload :Placement,           "#{__dir__}/render/placement"
     autoload :ImageCollector,      "#{__dir__}/render/image_collector"
     autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.8.9
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-16 00:00:00.000000000 Z
+date: 2026-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -439,6 +439,7 @@ files:
 - lib/idml/render/color_helper.rb
 - lib/idml/render/color_resolver.rb
 - lib/idml/render/condition_filter.rb
+- lib/idml/render/contour.rb
 - lib/idml/render/drop_cap.rb
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/font_setup.rb
@@ -469,6 +470,7 @@ files:
 - lib/idml/render/renderers/rectangle_renderer.rb
 - lib/idml/render/renderers/table_renderer.rb
 - lib/idml/render/renderers/text_frame_renderer.rb
+- lib/idml/render/shape_paint.rb
 - lib/idml/render/spread_renderer.rb
 - lib/idml/render/story_chain_controller.rb
 - lib/idml/render/story_threader.rb