postsvg 0.2.3 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0de930d655e83ae56095a0a297a654f9d5fbf68e394e0bf133f4f6a0851ca8a6
-  data.tar.gz: d6a2f211f000b43a0ad4b6ff95ed86400b2a2869d25fd0c56394658927bf7c13
+  metadata.gz: 5f7f5030dcfb8b5b1f0cc990113f3e01c4dcd361f4c2adba3be90c887bddcd14
+  data.tar.gz: 8adfa25722485014bc085b0b04967da252c987ebd55535cae1e203a3ea847241
 SHA512:
-  metadata.gz: 447ab36ac29c352d4356f41eaabce61c941abc223726fdbee7f6ae0f6a878ac41a297b16f392cf3b0fb1e50d17b1917e5376f6d88de79667490829d0cd64b077
-  data.tar.gz: 2c851d97ddae78e810c21efee254a0d52f8b89a9bbab871feb5c09436f854a9847841e4bb8483335b091d432c172dec855bcab30cdd4bcb3a06d64098595ef14
+  metadata.gz: 1387c2ac6841339ed6fe3c7f3027b6be26acca97e7cc3cc1c1b5a391113e2088c2ebc384f483993def51b0330a9d59afb07e10c4e9b39113875348203f257fbb
+  data.tar.gz: 68b2738560bd07c41688418463ca2f989004ae8cdab533a65774b241245d34d8868f2f5ae2b46b743d076ed5c5e17db2842b485f259fb4bce1b196fc121ad7bf

data/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What this is
 
-`postsvg` is a pure-Ruby bidirectional converter between PostScript/EPS and SVG. Both directions are implemented in the 0.2.x line; the SVg→PS direction is newer. The PS side uses a hand-written lexer + stack-machine interpreter; the SVG side uses Nokogiri. There is no Ghostscript, Inkscape, or other external renderer.
+`postsvg` is a pure-Ruby bidirectional converter between PostScript/EPS and SVG. Both directions are implemented in the 0.2.x line; the SVg→PS direction is newer. The PS side uses a hand-written lexer + stack-machine interpreter; the SVG side uses leptris. There is no Ghostscript, Inkscape, or other external renderer.
 
 Code architecture mirrors `emfsvg`: a typed `Model::Program` value object is the single source of truth, with a Renderer / Visitor visiting it to emit SVG, and a Serializer walking it to emit PS.
 
@@ -27,6 +27,30 @@ bundle exec ruby exe/postsvg batch     INPUT_DIR         [OUTPUT_DIR]
 bundle exec ruby exe/postsvg version
 ```
 
+## Round-trip contract
+
+The `round_trip` tag selects the model comparison, SVG summary comparison,
+and byte-pinned emitted-PostScript golden checks:
+
+```bash
+bundle exec rspec --tag round_trip
+bundle exec rake round_trip:regenerate_goldens
+```
+
+These specs also run in the normal CI suite. The regeneration task rewrites
+the `.ps.golden` beside every SVG listed in
+`spec/fixtures/round_trip/manifest.yml`. Regenerate only for intentional output
+changes, inspect the diffs, and include them in a reviewed PR; never edit
+goldens by hand.
+
+Manifest `known_gap` and `non_goal` markers are **strict pending**, scoped to
+the `model` or `svg` leg. They do not skip comparisons: an unexpected pass
+fails the suite and requires reviewing/removing the marker. `known_gap`
+identifies a bug requiring follow-up; `non_goal` records intentional loss
+(currently gradient paint flattening). Unmarked legs must pass, and golden
+checks apply even to marked fixtures. See the README Round-trip section for
+the supported subset, comparison precision and parser-callable parity hook.
+
 ## Architecture
 
 ```
@@ -54,7 +78,7 @@ PS/EPS bytes ──▶│ Postsvg::Lexer       │
                 │                 │
                 ▼                 │
         SVG string               │
-                │ Nokogiri       │
+                │ leptris        │
                 ▼                 │
       ┌─────────────────┐         │
       │ Postsvg::       │         │
@@ -163,7 +187,7 @@ Errors: `Postsvg::ParseError`, `LexError`, `SyntaxError`, `RenderError`, `StackU
 
 ## Dependencies
 
-- `parslet`, `thor`, `nokogiri`, `lutaml/canon` (dev only, for XML matcher in integration specs) — see `Gemfile`.
+- `parslet`, `thor`, `leptris`, `lutaml/canon` (dev only, for XML matcher in integration specs) — see `Gemfile`.
 
 ## Limitations
 

data/Gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "canon"
-gem "leptris", "~> 1.9.362"
+gem "leptris", ">= 1.9.399.0"
 gem "rake"
 gem "rspec"
 gem "rubocop"

data/README.adoc

@@ -225,8 +225,9 @@ equivalent PS `arc` operator.
 
 === Round-trip
 
-The same `Model::Program` value object sits behind both directions, so
-round-trip is a function composition:
+The round-trip contract covers a pinned SVG corpus, with per-fixture
+expectations in link:spec/fixtures/round_trip/manifest.yml[manifest.yml].
+The conversion is a function composition:
 
 [source,ruby]
 ----
@@ -236,10 +237,67 @@ original_svg = File.read("input.svg")
 ps = Postsvg.to_ps(original_svg)
 round_tripped_svg = Postsvg.to_svg(ps)
 
-# round_tripped_svg preserves the geometry of original_svg for the
-# supported subset of SVG elements.
 ----
 
+The gate checks two legs independently:
+
+* *Normalized model diff*: `RoundTrip::Harness` compares the program built
+  from SVG with the program parsed from its serialized PostScript. The
+  normalizer compares operators and operand values, rounding floats to the
+  serializer's four decimal places.
+* *SVG summary diff*: `RoundTrip::SvgSummary` compares the original SVG with
+  the returned SVG as painted geometry in document coordinates. It checks
+  fill, stroke, stroke width, line caps and joins, transforms, and text
+  content, position, font family and size. Numbers are rounded to two decimal
+  places; equivalent shape/path spellings and the renderer's Y-flip wrapper
+  are normalized. This is not a byte-for-byte SVG or pixel-rendering test.
+
+Covered families are shapes (rectangles, polygons, polylines, line and curve
+paths), line strokes, arcs (circles, ellipses and path arcs), gray/RGB fills,
+combined fill and stroke, stroke styles, text, transforms (translation,
+rotation, matrices and nested groups), and gradients. Coverage does not mean
+every family preserves everything: the manifest records known SVG-leg gaps
+for polyline fill, path arcs and matrix shear. Text checks do not promise font
+metrics or glyph fidelity. Features outside the corpus are not guaranteed by
+this gate.
+
+The manifest is authoritative for exceptions on each leg. `known_gap` marks
+a bug; `non_goal` marks intentional loss. Linear and radial gradient `url()`
+paint is intentionally flattened to a plain fill (currently black), so gradient
+preservation is a non-goal even though the model leg passes. Both markers are
+strict pending: the comparison still runs, and an unexpected pass fails so
+the marker must be reviewed and removed when appropriate.
+
+The `round_trip` spec tag selects the contract and emitted-PostScript golden
+checks, which also run in the normal CI spec suite. Every manifest fixture has
+a byte-pinned `.ps.golden`; even marked fixtures must match their golden.
+For an intentional output change, regenerate with:
+
+[source,sh]
+----
+bundle exec rake round_trip:regenerate_goldens
+----
+
+Review the resulting diffs and submit them with the change in a reviewed PR.
+Do not edit goldens by hand or regenerate them merely to silence a regression.
+
+For `postscript#4` parser parity, the test-support hook
+`RoundTrip::Harness.call(svg, parser: candidate_parser)` accepts a callable
+that receives serialized PS source and returns a compatible program. It
+defaults to `Postscript::Source.parse` and returns an empty diff on a match,
+or indexed expected/actual normalized records on a mismatch. This lets a
+candidate parser reuse the same model contract without changing the public
+conversion API.
+
+The model contract also runs every manifest fixture with
+`Postscript::Source.parse(source, engine: :native)`, comparing normalized
+programs against both Ruby parsing and the emitted model. Run it with
+`bundle exec rspec spec/postsvg/round_trip_contract_spec.rb --tag native`.
+When the installed postscript lacks the native API or its optional parsanol
+native engine is unavailable, examples skip with an explicit reason. These
+skips do not establish native parity; see
+`spec/fixtures/round_trip/README.adoc` for prerequisites and marker behavior.
+
 == Command-line interface
 
 [[cli]]

data/Rakefile

@@ -3,12 +3,29 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 require "rubocop/rake_task"
+require "yaml"
 
 RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
 
+namespace :round_trip do
+  desc "Regenerate pinned PostScript output for the round-trip corpus"
+  task :regenerate_goldens do
+    require "postsvg"
+
+    root = File.expand_path("spec/fixtures/round_trip", __dir__)
+    manifest = YAML.safe_load_file(File.join(root, "manifest.yml"))
+
+    manifest.fetch("fixtures").each do |entry|
+      svg_path = File.join(root, entry.fetch("file"))
+      golden_path = svg_path.sub(/\.svg\z/, ".ps.golden")
+      File.binwrite(golden_path, Postsvg.to_ps(File.read(svg_path)))
+    end
+  end
+end
+
 # Link checking tasks
 namespace :check do
   desc "Check internal documentation links only (recommended for CI)"

data/gemfiles/native-parity/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+eval_gemfile "../../Gemfile"
+
+# Drop this CI-only overlay once postscript releases NativeEngine and
+# parsanol/parsanol-ruby#354 ships a fix for previously baked grammars.
+gem "parsanol", "1.3.109"
+gem "postscript", git: "https://github.com/claricle/postscript.git", branch: "main"

data/lib/postsvg/interpreter.rb

@@ -334,9 +334,8 @@ module Postsvg
     end
 
     def flush_path(mode)
-      # rubocop:disable Style/ZeroLengthPredicate
+      # rubocop:disable-next Style/ZeroLengthPredicate
       return if @path.length.zero?
-      # rubocop:enable Style/ZeroLengthPredicate
 
       d = @path.to_path
       path_str = emit_svg_path(d, @g_state, mode)

data/lib/postsvg/translation/arc_converter.rb

@@ -11,7 +11,7 @@ module Postsvg
 
       module_function
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
+      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
       def endpoint_to_center(x1:, y1:, rx:, ry:, x_axis_rotation:,
                              large_arc:, sweep:, x2:, y2:)
         rx = rx.abs
@@ -70,7 +70,6 @@ module Postsvg
 
         [cx, cy, rx, ry, phi, theta1 * 180.0 / Math::PI, theta2 * 180.0 / Math::PI]
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
 
       def angle_between(ux, uy, vx, vy)
         len = vector_length(ux, uy, vx, vy)

data/lib/postsvg/translation/handlers/path_handler.rb

@@ -9,8 +9,8 @@ module Postsvg
       #
       # - M/m moveto (relative repeats as l)
       # - L/l lineto
-      # - H/h vertical line
-      # - V/v horizontal line
+      # - H/h horizontal line
+      # - V/v vertical line
       # - C/c cubic bezier
       # - S/s smooth cubic (reflects previous control point)
       # - Q/q quadratic bezier (converted to cubic)
@@ -50,7 +50,7 @@ module Postsvg
           when "H", "h"
             handle_hv(cmd, state, context, horizontal: cmd.opcode.upcase == "H")
           when "V", "v"
-            handle_hv(cmd, state, context, horizontal: cmd.opcode.upcase == "V")
+            handle_hv(cmd, state, context, horizontal: false)
           when "C", "c"
             handle_cubic(cmd, state, smooth, context)
           when "S", "s"
@@ -177,6 +177,10 @@ module Postsvg
 
         def self.handle_smooth_quadratic(cmd, state, smooth, context)
           x3, y3 = cmd.args
+          if cmd.opcode == "t"
+            x3 += state.current_x
+            y3 += state.current_y
+          end
           qx, qy =
             if smooth.smoothable
               [reflect_x(smooth.control_x, state),
@@ -190,14 +194,7 @@ module Postsvg
           c1y = p0y + ((2.0 / 3.0) * (qy - p0y))
           c2x = x3 + ((2.0 / 3.0) * (qx - x3))
           c2y = y3 + ((2.0 / 3.0) * (qy - y3))
-          if cmd.opcode == "T"
-            state.curve_to(x3, y3)
-          else
-            state.curve_to_rel(x3 - p0x, y3 - p0y) # treat as rel target
-            # Re-anchor to absolute target for emission below.
-            state.current_x = p0x + x3
-            state.current_y = p0y + y3
-          end
+          state.curve_to(x3, y3)
           context.emitter.emit(Model::Operators::Path::Curveto.new(
                                  x1: c1x, y1: c1y, x2: c2x, y2: c2y, x3: state.current_x, y3: state.current_y,
                                ))
@@ -211,6 +208,13 @@ module Postsvg
         # W3C-endorsed endpoint-to-center conversion.
         def self.handle_arc(cmd, state, context)
           rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, x, y = cmd.args
+          if cmd.opcode == "a"
+            x += state.current_x
+            y += state.current_y
+          end
+          # SVG omits arcs whose endpoints coincide.
+          return if [x, y] == [state.current_x, state.current_y]
+
           cx, cy, normalized_rx, normalized_ry, psi, theta1, theta2 =
             Postsvg::Translation::ArcConverter.endpoint_to_center(
               x1: state.current_x, y1: state.current_y,
@@ -218,27 +222,29 @@ module Postsvg
               large_arc: large_arc_flag != 0, sweep: sweep_flag != 0,
               x2: x, y2: y
             )
-          # Emit arc with center, radius, angle range. For elliptical
-          # arcs (rx != ry or non-zero rotation), emit scale/rotate
-          # transforms around the arc.
+          # Restore only the CTM: grestore would discard the appended arc.
+          arc_class = sweep_flag.zero? ? Model::Operators::Path::Arcn : Model::Operators::Path::Arc
           if x_axis_rotation.abs > 1e-6 || (rx - ry).abs > 1e-6
-            context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
+            context.emitter.emit(Model::Operators::Transformations::Matrix.new)
+            context.emitter.emit(Model::Operators::Transformations::Currentmatrix.new)
             context.emitter.emit(Model::Operators::Transformations::Concat.new(matrix: [
                                                                                  Math.cos(psi), Math.sin(psi), -Math.sin(psi), Math.cos(psi), cx, cy
                                                                                ]))
             context.emitter.emit(Model::Operators::Transformations::Scale.new(
                                    sx: normalized_rx, sy: normalized_ry,
                                  ))
-            context.emitter.emit(Model::Operators::Path::Arc.new(
+            context.emitter.emit(arc_class.new(
                                    x: 0, y: 0, radius: 1.0, angle1: theta1, angle2: theta2,
                                  ))
-            context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+            context.emitter.emit(Model::Operators::Transformations::Setmatrix.new(
+                                   matrix: Model::Computed.new(operator_keyword: "currentmatrix"),
+                                 ))
           else
-            context.emitter.emit(Model::Operators::Path::Arc.new(
+            context.emitter.emit(arc_class.new(
                                    x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
                                  ))
           end
-          state.move_to(x, y)
+          state.line_to(x, y)
         end
 
         # ---- helpers ----

data/lib/postsvg/translation/handlers/polyline_handler.rb

@@ -9,7 +9,6 @@ module Postsvg
         def self.call(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
           emit_transform(element, context)
-          emit_stroke(element, context)
           context.emitter.emit(Model::Operators::Path::Newpath.new)
           points = element.points
           points.each_slice(2).with_index do |(x, y), idx|
@@ -21,7 +20,7 @@ module Postsvg
                                                                       y: y))
             end
           end
-          context.emitter.emit(Model::Operators::Painting::Stroke.new)
+          emit_paint(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
           xs = points.each_slice(2).map(&:first)
           ys = points.each_slice(2).map(&:last)

data/lib/postsvg/translation/handlers/text_handler.rb

@@ -8,7 +8,9 @@ module Postsvg
       #   /<font-family> findfont
       #   <font-size> scalefont
       #   setfont
-      #   <x> <y> moveto
+      #   <x> <y> translate
+      #   1 -1 scale
+      #   0 0 moveto
       #   (text) show
       #
       # Real font metrics (kerning, ligatures, glyph substitution) are
@@ -32,8 +34,14 @@ module Postsvg
           context.emitter.emit(Model::Operators::Font::Setfont.new(
                                  font: Model::Computed.new(operator_keyword: "scalefont"),
                                ))
-          context.emitter.emit(Model::Operators::Path::Moveto.new(x: element.x,
-                                                                  y: element.y))
+          # The document transform converts SVG's downward y axis to PS.
+          # Restore upward font space around the baseline without undoing
+          # the authored text/group transforms or moving the anchor.
+          context.emitter.emit(Model::Operators::Transformations::Translate.new(
+                                 tx: element.x, ty: element.y,
+                               ))
+          context.emitter.emit(Model::Operators::Transformations::Scale.new(sx: 1, sy: -1))
+          context.emitter.emit(Model::Operators::Path::Moveto.new(x: 0, y: 0))
           context.emitter.emit(Model::Operators::Font::Show.new(text: element.content.to_s))
 
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)

data/lib/postsvg/translation/ps_renderer.rb

@@ -72,8 +72,9 @@ module Postsvg
 
       def compute_viewport_bbox
         if document.viewbox
-          llx, lly, urx, ury = document.viewbox
-          BoundingBox.new(min_x: llx, min_y: lly, max_x: urx, max_y: ury)
+          x, y, width, height = document.viewbox
+          BoundingBox.new(min_x: x, min_y: y, max_x: x + width,
+                          max_y: y + height)
         elsif document.width && document.height
           BoundingBox.new(min_x: 0, min_y: 0, max_x: document.width,
                           max_y: document.height)
@@ -86,6 +87,17 @@ module Postsvg
         registry.translate(element, context)
       end
 
+      # SVG's y axis points down; PostScript's points up. Convert once at
+      # the document boundary, before any authored element transforms.
+      def coordinate_conversion(bbox)
+        emitter = RecordEmitter.new
+        emitter.emit(Model::Operators::Transformations::Translate.new(
+                       tx: 0, ty: bbox[3] - bbox[1],
+                     ))
+        emitter.emit(Model::Operators::Transformations::Scale.new(sx: 1, sy: -1))
+        emitter.records
+      end
+
       def build_program(emitter, context)
         bbox = context.bounding_box
         header_bbox =
@@ -99,7 +111,8 @@ module Postsvg
           epsf: eps,
           title: "Translated by Postsvg #{::Postsvg::VERSION}",
         )
-        Model::Program.new(header: header, body: emitter.records)
+        Model::Program.new(header: header,
+                           body: coordinate_conversion(header_bbox) + emitter.records)
       end
     end
   end

data/lib/postsvg/translation/record_emitter.rb

@@ -7,6 +7,54 @@ module Postsvg
     # surface so handlers don't all need to know how the program is
     # stored.
     class RecordEmitter
+      NUMBER_OPERANDS = lambda do |record|
+        record.operand_values.map { |value| Model::Literals::Number.new(value) }
+      end
+      NO_OPERANDS = ->(_record) { [] }
+
+      OPERAND_BUILDERS = {
+        Model::Operators::Color::Setgray => NUMBER_OPERANDS,
+        Model::Operators::Color::Setrgbcolor => NUMBER_OPERANDS,
+        Model::Operators::GraphicsState::Setlinewidth => NUMBER_OPERANDS,
+        Model::Operators::Path::Moveto => NUMBER_OPERANDS,
+        Model::Operators::Path::Rmoveto => lambda do |record|
+          [Model::Literals::Number.new(record.dx), Model::Literals::Number.new(record.dy)]
+        end,
+        Model::Operators::Path::Lineto => NUMBER_OPERANDS,
+        Model::Operators::Path::Rlineto => NUMBER_OPERANDS,
+        Model::Operators::Path::Curveto => NUMBER_OPERANDS,
+        Model::Operators::Path::Rcurveto => NUMBER_OPERANDS,
+        Model::Operators::Path::Arc => NUMBER_OPERANDS,
+        Model::Operators::Path::Arcn => NUMBER_OPERANDS,
+        Model::Operators::Transformations::Translate => NUMBER_OPERANDS,
+        Model::Operators::Transformations::Scale => NUMBER_OPERANDS,
+        Model::Operators::Font::Findfont => lambda do |record|
+          # findfont accepts strings as well as names; whitespace must not
+          # split a family name into separate PostScript tokens.
+          if record.name.match?(/\s/)
+            [Model::Literals::StringLiteral.new(record.name)]
+          else
+            [Model::Literals::Name.new(record.name, literal: true)]
+          end
+        end,
+        Model::Operators::Font::Scalefont => lambda do |record|
+          [Model::Literals::Number.new(record.size)]
+        end,
+        Model::Operators::Font::Show => lambda do |record|
+          [Model::Literals::StringLiteral.new(record.text)]
+        end,
+        Model::Operators::GraphicsState::Setlinecap => lambda do |record|
+          [Model::Literals::Number.new(record.cap_code)]
+        end,
+        Model::Operators::GraphicsState::Setlinejoin => lambda do |record|
+          [Model::Literals::Number.new(record.join_code)]
+        end,
+        Model::Operators::Transformations::Concat => lambda do |record|
+          elements = record.matrix.map { |value| Model::Literals::Number.new(value) }
+          [Model::Literals::ArrayLiteral.new(elements)]
+        end,
+      }.freeze
+
       attr_reader :records
 
       def initialize
@@ -14,6 +62,12 @@ module Postsvg
       end
 
       def emit(record)
+        # Operators built by the svg -> ps handlers carry their
+        # operands as attributes; the serializer writes keywords only
+        # and expects the operands as separate literal statements
+        # ahead of the keyword (the shape the PS parse path produces).
+        # Splice them in so the record stream round-trips.
+        @records.concat(OPERAND_BUILDERS.fetch(record.class, NO_OPERANDS).call(record))
         @records << record
         self
       end

data/lib/postsvg/version.rb

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

data/lib/postsvg/visitors/ps_visitor/font.rb

@@ -32,6 +32,7 @@ module Postsvg
 
         def visit_scalefont(op, _ctx)
           size = op.size.to_i
+          consume_numeric_operands(op.size)
           font = @stack.pop
           base = if font.is_a?(FontRef)
                    font

data/lib/postsvg/visitors/ps_visitor/graphics_state.rb

@@ -7,15 +7,17 @@ module Postsvg
       # dash attribute setters.
       module GraphicsState
         def visit_gsave(_op, _ctx)
+          @saved_paths << @path.dup
           @graphics.gsave
         end
 
         def visit_grestore(_op, _ctx)
+          @path = @saved_paths.pop if @graphics.depth > 1 && !@saved_paths.empty?
           @graphics.grestore
         end
 
         def visit_grestoreall(_op, _ctx)
-          @graphics.grestore while @graphics.depth > 1
+          visit_grestore(nil, nil) while @graphics.depth > 1
         end
 
         def visit_setlinewidth(op, _ctx)

data/lib/postsvg/visitors/ps_visitor/painting.rb

@@ -25,7 +25,7 @@ module Postsvg
         def visit_clip(_op, _ctx)
           return if @path.empty?
 
-          path_d = @path.to_path_d
+          path_d = @path.to_path_d(@graphics.current.ctm)
           clip_id = @builder.register_clip_path(path_d)
           @graphics.update(clip_paths: @graphics.current.clip_paths + [clip_id])
           @path.reset
@@ -43,7 +43,7 @@ module Postsvg
         def flush_path(mode)
           return if @path.empty?
 
-          d = @path.to_path_d
+          d = @path.to_path_d(@graphics.current.ctm)
           ctx = @graphics.current
           transform_str = build_transform_string(ctx)
           clip_id = ctx.clip_paths.last

data/lib/postsvg/visitors/ps_visitor/path.rb

@@ -5,20 +5,23 @@ module Postsvg
     class PsVisitor
       # Path construction operator handlers. Each appends a command to
       # +@path+ (PathState). CTM-aware: when the current CTM is not
-      # identity, the renderer will wrap emitted paths in a
-      # <g transform=>. Points are stored in user-space coordinates;
-      # the visitor delegates to the SvgBuilder for transform emission.
+      # identity, the renderer wraps painted paths in a <g transform=>.
+      # Arcs retain their construction CTM and are mapped into the paint CTM
+      # at emission, whether or not the temporary transform was restored.
+      # Other mid-path CTM changes retain the existing paint-time behavior.
       module Path
         def visit_newpath(_op, _ctx)
           @path.reset
         end
 
         def visit_moveto(op, _ctx)
+          @path.matrix ||= @graphics.current.ctm
           @path.move_to(op.x, op.y)
           @graphics.update(last_text_position: { x: op.x, y: op.y })
         end
 
         def visit_rmoveto(op, _ctx)
+          @path.matrix ||= @graphics.current.ctm
           @path.move_to_rel(op.dx, op.dy)
           pos = @graphics.current.last_text_position
           base_x = pos ? pos[:x] : 0
@@ -66,50 +69,61 @@ module Postsvg
         # are parametrised by center, radius, angle range. SVG arcs
         # are parametrised by endpoint, radii, large-arc/sweep flags.
         def append_arc(cx, cy, radius, angle1, angle2, sweep:)
+          consume_numeric_operands(cx, cy, radius, angle1, angle2)
           r = radius.abs
           return if r.zero?
 
-          start_rad = angle1 * Math::PI / 180.0
-          start_x = cx + (r * Math.cos(start_rad))
-          start_y = cy + (r * Math.sin(start_rad))
-          end_rad = angle2 * Math::PI / 180.0
-          end_x = cx + (r * Math.cos(end_rad))
-          end_y = cy + (r * Math.sin(end_rad))
-
-          # If the current path is empty, the arc implicitly starts
-          # with a moveto to its starting point.
-          if (@path.empty? || last_command_starts_with?("M")) && @path.empty?
-            @path.move_to(start_x, start_y)
+          construction_matrix = @graphics.current.ctm
+          @path.matrix ||= construction_matrix
+          point_matrix = @path.matrix.invert.multiply(construction_matrix)
+          end_x, end_y = arc_point(point_matrix, cx, cy, r, angle2)
+          starts_path = @path.empty?
+          command = lambda do |paint_matrix|
+            matrix = paint_matrix.invert.multiply(construction_matrix)
+            render_arc(cx, cy, r, angle1, angle2, sweep: sweep,
+                       matrix: matrix, starts_path: starts_path)
           end
+          @path.append_deferred(command, end_x, end_y)
+        end
 
-          delta = (angle2 - angle1) % 360
-          delta += 360 if delta.negative?
-          large_arc = delta > 180
-
-          # SVG sweep flag is 1 when the arc is drawn clockwise.
-          svg_sweep = if sweep
-                        delta.positive? ? 1 : 0
-                      else
-                        0
-                      end
+        def render_arc(cx, cy, radius, angle1, angle2, sweep:, matrix:, starts_path:)
+          path = PathState.new
+          start_x, start_y = arc_point(matrix, cx, cy, radius, angle1)
+          end_x, end_y = arc_point(matrix, cx, cy, radius, angle2)
+          path.move_to(start_x, start_y) if starts_path
+          delta = sweep ? (angle2 - angle1) % 360 : (angle1 - angle2) % 360
+          rx, ry, rotation = arc_radii(matrix, radius)
+          reflected = ((matrix.a * matrix.d) - (matrix.b * matrix.c)).negative?
+          svg_sweep = sweep != reflected
           if delta.abs < 1e-6
-            # Full circle: emit two arcs.
-            mid_angle = angle1 + 180
-            mid_rad = mid_angle * Math::PI / 180.0
-            mid_x = cx + (r * Math.cos(mid_rad))
-            mid_y = cy + (r * Math.sin(mid_rad))
-            @path.arc_to(r, r, 0, 0, svg_sweep, mid_x, mid_y)
-            @path.arc_to(r, r, 0, 0, svg_sweep, start_x, start_y)
-            @path.close
+            # Full circles need two arcs; retain the corpus's large-arc spelling.
+            mid_x, mid_y = arc_point(matrix, cx, cy, radius, angle1 + 180)
+            path.arc_to(rx, ry, rotation, true, svg_sweep, mid_x, mid_y)
+            path.arc_to(rx, ry, rotation, true, svg_sweep, start_x, start_y)
+            path.close
           else
-            @path.arc_to(r, r, 0, large_arc ? 1 : 0, svg_sweep, end_x, end_y)
+            path.arc_to(rx, ry, rotation, delta > 180, svg_sweep, end_x, end_y)
           end
+          path.to_path_d
         end
 
-        def last_command_starts_with?(prefix)
-          return false if @path.commands.empty?
+        def arc_point(matrix, cx, cy, radius, angle)
+          radians = angle * Math::PI / 180.0
+          matrix.apply_point(cx + (radius * Math.cos(radians)),
+                             cy + (radius * Math.sin(radians))).values_at(:x, :y)
+        end
 
-          @path.commands.last.start_with?(prefix)
+        # Singular values give the ellipse radii even when its frame is rotated
+        # or sheared. The principal eigenvector gives its SVG axis rotation.
+        def arc_radii(matrix, radius)
+          xx = (matrix.a**2) + (matrix.c**2)
+          xy = (matrix.a * matrix.b) + (matrix.c * matrix.d)
+          yy = (matrix.b**2) + (matrix.d**2)
+          root = Math.hypot(xx - yy, 2 * xy)
+          rx = radius * Math.sqrt([(xx + yy + root) / 2, 0].max)
+          ry = radius * Math.sqrt([(xx + yy - root) / 2, 0].max)
+          rotation = root < 1e-12 ? 0.0 : Math.atan2(2 * xy, xx - yy) * 90 / Math::PI
+          [rx, ry, rotation]
         end
       end
     end

data/lib/postsvg/visitors/ps_visitor/transformations.rb

@@ -6,12 +6,19 @@ module Postsvg
       # Coordinate transformation operator handlers. Each returns a
       # new CTM via Matrix composition and updates the GraphicsContext.
       module Transformations
+        # A matrix this visitor produced (`matrix`, `currentmatrix`). The
+        # runtime stack also holds values nothing popped (`def` operands,
+        # unresolved names, path operands), so only these are trusted as a
+        # matrix the parser could not see.
+        class StackMatrix < Array; end
+
         def visit_translate(op, _ctx)
           new_ctm = @graphics.current.ctm.translate(op.tx.to_f, op.ty.to_f)
           @graphics.update(ctm: new_ctm)
         end
 
         def visit_scale(op, _ctx)
+          consume_numeric_operands(op.sx, op.sy)
           new_ctm = @graphics.current.ctm.scale(op.sx.to_f, op.sy.to_f)
           @graphics.update(ctm: new_ctm)
         end
@@ -22,7 +29,7 @@ module Postsvg
         end
 
         def visit_concat(op, _ctx)
-          matrix = matrix_from_operand(op.matrix)
+          matrix = matrix_from_operand(matrix_operand(op))
           return unless matrix
 
           new_ctm = @graphics.current.ctm.multiply(matrix)
@@ -30,16 +37,17 @@ module Postsvg
         end
 
         def visit_matrix(_op, _ctx)
-          @stack << [1, 0, 0, 1, 0, 0]
+          @stack << StackMatrix[1, 0, 0, 1, 0, 0]
         end
 
         def visit_currentmatrix(_op, _ctx)
+          @stack.pop if @stack.last.is_a?(StackMatrix)
           ctm = @graphics.current.ctm
-          @stack << [ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f]
+          @stack << StackMatrix[ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f]
         end
 
         def visit_setmatrix(op, _ctx)
-          matrix = matrix_from_operand(op.matrix)
+          matrix = matrix_from_operand(matrix_operand(op))
           return unless matrix
 
           @graphics.update(ctm: matrix)
@@ -85,16 +93,46 @@ module Postsvg
 
         private
 
+        # Parsed literal operands remain on the visitor stack. Consume only
+        # an exact numeric suffix, leaving directly constructed operators alone.
+        def consume_numeric_operands(*values)
+          @stack.pop(values.length) if @stack.last(values.length) == values
+        end
+
+        # A literal matrix was also pushed by visit_array; consume that copy
+        # so a later operator does not apply it again. A computed matrix is
+        # taken from the stack only when this visitor produced it.
+        def matrix_operand(op)
+          unless op.matrix.is_a?(Model::Computed)
+            @stack.pop if literal_on_stack?(op.matrix)
+            return op.matrix
+          end
+
+          @stack.pop if @stack.last.is_a?(StackMatrix)
+        end
+
+        def literal_on_stack?(matrix)
+          matrix.is_a?(Model::Literals::ArrayLiteral) && @stack.last.equal?(matrix.elements)
+        end
+
+        # Arrays on the runtime stack hold either plain numbers or parsed
+        # Number literals. Anything other than six numbers is not a matrix.
         def matrix_from_operand(operand)
           case operand
           when Matrix then operand
+          when Model::Literals::ArrayLiteral then matrix_from_operand(operand.elements)
           when Array
-            return nil unless operand.length == 6
+            numbers = operand.map { |element| matrix_number(element) }
+            return nil unless numbers.length == 6 && numbers.all?
 
-            Matrix.new(a: operand[0], b: operand[1], c: operand[2],
-                       d: operand[3], e: operand[4], f: operand[5])
+            Matrix.new(a: numbers[0], b: numbers[1], c: numbers[2],
+                       d: numbers[3], e: numbers[4], f: numbers[5])
           end
         end
+
+        def matrix_number(element)
+          numeric_value(element) if element.is_a?(Numeric) || element.is_a?(Model::Literals::Number)
+        end
       end
     end
   end

data/lib/postsvg/visitors/ps_visitor.rb

@@ -36,6 +36,7 @@ module Postsvg
         @graphics = graphics
         @stack = [] # operand stack for execution semantics
         @path = PathState.new
+        @saved_paths = []
         @dict_stack = [{}] # runtime dict stack (mirrors PLRM dict stack)
         @recursion_depth = 0
       end
@@ -116,6 +117,7 @@ module Postsvg
       # geometry bookkeeping.
       class PathState
         attr_reader :commands, :current_x, :current_y
+        attr_accessor :matrix
 
         def initialize
           @commands = []
@@ -127,6 +129,11 @@ module Postsvg
           @commands.empty?
         end
 
+        def initialize_copy(other)
+          super
+          @commands = other.commands.map(&:dup)
+        end
+
         def move_to(x, y)
           @commands << "M #{fmt(x)} #{fmt(y)}"
           @current_x = x.to_f
@@ -170,18 +177,27 @@ module Postsvg
           @current_y = y.to_f
         end
 
+        def append_deferred(command, x, y)
+          @commands << command
+          @current_x = x
+          @current_y = y
+        end
+
         def close
           @commands << "Z"
         end
 
         def reset
+          @matrix = nil
           @commands = []
           @current_x = 0.0
           @current_y = 0.0
         end
 
-        def to_path_d
-          @commands.join(" ")
+        def to_path_d(paint_matrix = @matrix || Matrix.new)
+          @commands.map do |command|
+            command.is_a?(Proc) ? command.call(paint_matrix) : command
+          end.join(" ")
         end
 
         def fmt(value)

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: postsvg
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: leptris
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.362
+        version: 1.9.399.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.362
+        version: 1.9.399.0
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +186,7 @@ files:
 - docs/troubleshooting.adoc
 - docs/validation.adoc
 - exe/postsvg
+- gemfiles/native-parity/Gemfile
 - lib/postsvg.rb
 - lib/postsvg/cli.rb
 - lib/postsvg/colors.rb