postsvg 0.3.0 → 0.3.1

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.3.0"
+  VERSION = "0.3.1"
 end

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

@@ -12,19 +12,19 @@ module Postsvg
         def visit_add(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << a + b
+          @stack << (a + b)
         end
 
         def visit_sub(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << a - b
+          @stack << (a - b)
         end
 
         def visit_mul(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << a * b
+          @stack << (a * b)
         end
 
         def visit_div(_op, _ctx)
@@ -32,7 +32,7 @@ module Postsvg
           a = pop_runtime_number
           raise RenderError, "division by zero" if divisor.zero?
 
-          @stack << (a.to_f / divisor.to_f)
+          @stack << (a.to_f / divisor)
         end
 
         def visit_idiv(_op, _ctx)
@@ -85,7 +85,7 @@ module Postsvg
         def visit_atan(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << Math.atan2(a.to_f, b.to_f) * (180.0 / Math::PI)
+          @stack << (Math.atan2(a.to_f, b.to_f) * (180.0 / Math::PI))
         end
 
         def visit_cos(_op, _ctx)
@@ -107,7 +107,7 @@ module Postsvg
         def visit_exp(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << a.to_f**b.to_f
+          @stack << (a.to_f**b.to_f)
         end
 
         private

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

@@ -7,22 +7,25 @@ module Postsvg
       # GraphicsContext; the next paint operator reads the new colors.
       module Color
         def visit_setgray(op, _ctx)
-          color = Postsvg::Color.gray(op.gray.to_f)
+          color = Postscript::Color.gray(op.gray.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_setrgbcolor(op, _ctx)
-          color = Postsvg::Color.rgb(op.red.to_f, op.green.to_f, op.blue.to_f)
+          color = Postscript::Color.rgb(op.red.to_f, op.green.to_f,
+                                        op.blue.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_setcmykcolor(op, _ctx)
-          color = Postsvg::Color.cmyk(op.cyan.to_f, op.magenta.to_f, op.yellow.to_f, op.key.to_f)
+          color = Postscript::Color.cmyk(op.cyan.to_f, op.magenta.to_f,
+                                         op.yellow.to_f, op.key.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_sethsbcolor(op, _ctx)
-          color = hsb_to_color(op.hue.to_f, op.saturation.to_f, op.brightness.to_f)
+          color = hsb_to_color(op.hue.to_f, op.saturation.to_f,
+                               op.brightness.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
@@ -45,7 +48,7 @@ module Postsvg
             when 4 then [t, p, v]
             else        [v, p, q]
             end
-          Postsvg::Color.rgb(r, g, b)
+          Postscript::Color.rgb(r, g, b)
         end
       end
     end

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

@@ -13,7 +13,7 @@ module Postsvg
         def normalize_key(key)
           case key
           when Model::Literals::Name then key.value
-          when String then key.to_s.sub(/\A\//, "")
+          when String then key.to_s.delete_prefix("/")
           else key.to_s
           end
         end
@@ -25,7 +25,6 @@ module Postsvg
           when String then node
           when Model::Literals::StringLiteral then node.value
           when Model::Literals::HexLiteral then node.bytes
-          else nil
           end
         end
 

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

@@ -44,25 +44,25 @@ module Postsvg
           @stack << value
         end
 
-        def visit_put(op, _ctx)
+        def visit_put(_op, _ctx)
           # PS put mutates in place. Our value objects are immutable.
           # Marked as a comment in the output so the gap is visible.
           @builder.comment("put: in-place mutation not supported")
         end
 
         def visit_getinterval(op, _ctx)
-          case op.operand
-          when String
-            @stack << op.operand[op.start, op.count]
-          when Array
-            @stack << op.operand[op.start, op.count]
-          when Model::Literals::StringLiteral
-            @stack << op.operand.value[op.start, op.count]
-          when Model::Literals::ArrayLiteral
-            @stack << op.operand.elements[op.start, op.count]
-          else
-            @stack << ""
-          end
+          @stack << case op.operand
+                    when String
+                      op.operand[op.start, op.count]
+                    when Array
+                      op.operand[op.start, op.count]
+                    when Model::Literals::StringLiteral
+                      op.operand.value[op.start, op.count]
+                    when Model::Literals::ArrayLiteral
+                      op.operand.elements[op.start, op.count]
+                    else
+                      ""
+                    end
         end
 
         def visit_putinterval(_op, _ctx)

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

@@ -39,7 +39,7 @@ module Postsvg
           body = @stack.pop
           LOOP_LIMIT.times do
             descend_into_procedure(body)
-          rescue Postsvg::ExitSignal
+          rescue Postscript::ExitSignal
             break
           end
         end
@@ -74,11 +74,11 @@ module Postsvg
         end
 
         def visit_exit(_op, _ctx)
-          raise Postsvg::ExitSignal
+          raise Postscript::ExitSignal
         end
 
         def visit_quit(_op, _ctx)
-          raise Postsvg::QuitSignal
+          raise Postscript::QuitSignal
         end
 
         def visit_exec(_op, _ctx)

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

@@ -72,10 +72,14 @@ module Postsvg
 
         def visit_maxlength(op, _ctx)
           # PS dictionaries can grow dynamically; report current size.
-          case op.operand
-          when Hash then @stack << op.operand.length
-          when Model::Literals::Dictionary then @stack << op.operand.entries.length
-          else @stack << 0
+          @stack << dict_size(op.operand)
+        end
+
+        def dict_size(operand)
+          case operand
+          when Hash then operand.length
+          when Model::Literals::Dictionary then operand.entries.length
+          else 0
           end
         end
 

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

@@ -31,15 +31,26 @@ module Postsvg
         end
 
         def visit_scalefont(op, _ctx)
-          size = op.size.to_i || op.size.to_f
+          size = op.size.to_i
+          consume_numeric_operands(op.size)
           font = @stack.pop
-          base = font.is_a?(FontRef) ? font : FontRef.new(name: "Helvetica", size: nil)
+          base = if font.is_a?(FontRef)
+                   font
+                 else
+                   FontRef.new(name: "Helvetica",
+                               size: nil)
+                 end
           @stack << FontRef.new(name: base.name, size: size.to_f)
         end
 
         def visit_setfont(_op, _ctx)
           font = @stack.pop
-          ref = font.is_a?(FontRef) ? font : FontRef.new(name: "Helvetica", size: 12.0)
+          ref = if font.is_a?(FontRef)
+                  font
+                else
+                  FontRef.new(name: "Helvetica",
+                              size: 12.0)
+                end
           @graphics.update(font_name: ref.name || "Helvetica",
                            font_size: ref.size || 12.0)
         end
@@ -67,7 +78,7 @@ module Postsvg
             y: -screen_pos[:y],
             font_family: @graphics.current.font_name,
             font_size: @graphics.current.font_size,
-            color: color || Postsvg::Color::BLACK,
+            color: color || Postscript::Color::BLACK,
             transform: "scale(1 -1)",
           )
           @path.reset

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)
@@ -23,12 +25,14 @@ module Postsvg
         end
 
         def visit_setlinecap(op, _ctx)
-          name = { 0 => :butt, 1 => :round, 2 => :square }.fetch(op.cap_code, :butt)
+          name = { 0 => :butt, 1 => :round, 2 => :square }.fetch(op.cap_code,
+                                                                 :butt)
           @graphics.update(line_cap: name)
         end
 
         def visit_setlinejoin(op, _ctx)
-          name = { 0 => :miter, 1 => :round, 2 => :bevel }.fetch(op.join_code, :miter)
+          name = { 0 => :miter, 1 => :round, 2 => :bevel }.fetch(op.join_code,
+                                                                 :miter)
           @graphics.update(line_join: name)
         end
 
@@ -44,8 +48,6 @@ module Postsvg
               pattern.map { |v| FormatNumber.call(v.to_f) }.join(" ")
             when Numeric
               FormatNumber.call(pattern.to_f)
-            else
-              nil
             end
           @graphics.update(dash: dash_str)
         end

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
@@ -66,7 +66,7 @@ module Postsvg
             line_cap: ctx.line_cap,
             line_join: ctx.line_join,
             dash: ctx.dash,
-            clip_path_id: clip_path_id,
+            clip_path_id: clip_path_id
           )
         end
 

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

@@ -5,25 +5,29 @@ 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
           base_y = pos ? pos[:y] : 0
-          @graphics.update(last_text_position: { x: base_x + op.dx, y: base_y + op.dy })
+          @graphics.update(last_text_position: { x: base_x + op.dx,
+                                                 y: base_y + op.dy })
         end
 
         def visit_lineto(op, _ctx)
@@ -65,46 +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.move_to(start_x, start_y) if @path.empty?
+          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 = sweep ? (delta.positive? ? 1 : 0) : 0
+        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)