postsvg 0.3.0 → 0.3.1

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

@@ -15,8 +15,8 @@ module Postsvg
           cy = element.cy
           if r.to_f.positive?
             context.emitter.emit(Model::Operators::Path::Arc.new(
-              x: cx, y: cy, radius: r, angle1: 0, angle2: 360,
-            ))
+                                   x: cx, y: cy, radius: r, angle1: 0, angle2: 360,
+                                 ))
           end
           emit_paint(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)

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

@@ -17,9 +17,14 @@ module Postsvg
           # Approximate ellipse with scale + arc.
           if rx.to_f.positive? && ry.to_f.positive?
             scale = rx / ry
-            context.emitter.emit(Model::Operators::Transformations::Translate.new(tx: cx, ty: cy))
-            context.emitter.emit(Model::Operators::Transformations::Scale.new(sx: scale, sy: 1))
-            context.emitter.emit(Model::Operators::Path::Arc.new(x: 0, y: 0, radius: ry, angle1: 0, angle2: 360))
+            context.emitter.emit(Model::Operators::Transformations::Translate.new(
+                                   tx: cx, ty: cy,
+                                 ))
+            context.emitter.emit(Model::Operators::Transformations::Scale.new(
+                                   sx: scale, sy: 1,
+                                 ))
+            context.emitter.emit(Model::Operators::Path::Arc.new(x: 0, y: 0,
+                                                                 radius: ry, angle1: 0, angle2: 360))
           end
           emit_paint(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)

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

@@ -11,7 +11,8 @@ module Postsvg
           emit_transform(element, context)
           emit_paint_setup(element, context)
           element.children.each do |child|
-            Postsvg::Translation::PsRenderer::DEFAULT_REGISTRY.translate(child, context)
+            Postsvg::Translation::PsRenderer::DEFAULT_REGISTRY.translate(child,
+                                                                         context)
           end
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
         end

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

@@ -10,9 +10,10 @@ module Postsvg
           # Raster image support is tracked in TODO.roadmap/21-images.md.
           # For now, emit a comment so the serialized PS file has a
           # visible marker of the elided content.
-          href = element.href || "(none)"
+          element.href || "(none)"
           context.emitter.emit(Model::UnknownOperator.new(keyword: "image"))
-          expand_bbox(context, element.x, element.y, element.x + element.width, element.y + element.height)
+          expand_bbox(context, element.x, element.y, element.x + element.width,
+                      element.y + element.height)
         end
       end
     end

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

@@ -11,8 +11,12 @@ module Postsvg
           emit_transform(element, context)
           emit_stroke(element, context)
           context.emitter.emit(Model::Operators::Path::Newpath.new)
-          context.emitter.emit(Model::Operators::Path::Moveto.new(x: element.x1, y: element.y1))
-          context.emitter.emit(Model::Operators::Path::Lineto.new(x: element.x2, y: element.y2))
+          context.emitter.emit(Model::Operators::Path::Moveto.new(
+                                 x: element.x1, y: element.y1,
+                               ))
+          context.emitter.emit(Model::Operators::Path::Lineto.new(
+                                 x: element.x2, y: element.y2,
+                               ))
           context.emitter.emit(Model::Operators::Painting::Stroke.new)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
           expand_bbox(context, element.x1, element.y1, element.x2, element.y2)

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

@@ -9,10 +9,11 @@ module Postsvg
         # getter, so no capability check is needed.
         def self.call(element, context)
           element.children.each do |child|
-            Postsvg::Translation::PsRenderer.default_registry.translate(child, context)
+            Postsvg::Translation::PsRenderer.default_registry.translate(child,
+                                                                        context)
           end
         end
       end
     end
   end
-end
+end

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)
@@ -22,7 +22,8 @@ module Postsvg
 
         # Control-point reflection state for smooth curves. +nil+ when
         # the previous command wasn't a smooth-eligible curve.
-        SmoothState = Struct.new(:control_x, :control_y, :smoothable, keyword_init: true)
+        SmoothState = Struct.new(:control_x, :control_y, :smoothable,
+                                 keyword_init: true)
 
         def self.call(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
@@ -30,7 +31,8 @@ module Postsvg
           context.emitter.emit(Model::Operators::Path::Newpath.new)
 
           state = PathState.new
-          smooth = SmoothState.new(control_x: nil, control_y: nil, smoothable: false)
+          smooth = SmoothState.new(control_x: nil, control_y: nil,
+                                   smoothable: false)
           element.commands.each do |cmd|
             dispatch_command(cmd, state, smooth, context)
           end
@@ -48,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"
@@ -74,7 +76,8 @@ module Postsvg
             context.emitter.emit(Model::Operators::Path::Moveto.new(x: x, y: y))
           else
             state.move_to_rel(x, y)
-            context.emitter.emit(Model::Operators::Path::Rmoveto.new(dx: x, dy: y))
+            context.emitter.emit(Model::Operators::Path::Rmoveto.new(dx: x,
+                                                                     dy: y))
           end
           smooth.smoothable = false
         end
@@ -86,7 +89,8 @@ module Postsvg
             context.emitter.emit(Model::Operators::Path::Lineto.new(x: x, y: y))
           else
             state.line_to_rel(x, y)
-            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: x, dy: y))
+            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: x,
+                                                                     dy: y))
           end
         end
 
@@ -96,18 +100,23 @@ module Postsvg
             if horizontal
               new_x = v
               state.line_to(new_x, state.current_y)
-              context.emitter.emit(Model::Operators::Path::Lineto.new(x: new_x, y: state.current_y))
+              context.emitter.emit(Model::Operators::Path::Lineto.new(x: new_x,
+                                                                      y: state.current_y))
             else
               new_y = v
               state.line_to(state.current_x, new_y)
-              context.emitter.emit(Model::Operators::Path::Lineto.new(x: state.current_x, y: new_y))
+              context.emitter.emit(Model::Operators::Path::Lineto.new(
+                                     x: state.current_x, y: new_y,
+                                   ))
             end
           elsif horizontal
             state.line_to_rel(v, 0)
-            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: v, dy: 0))
+            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: v,
+                                                                     dy: 0))
           else
             state.line_to_rel(0, v)
-            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: 0, dy: v))
+            context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: 0,
+                                                                     dy: v))
           end
         end
 
@@ -116,8 +125,8 @@ module Postsvg
           x1, y1, x2, y2, x3, y3 = adapt_curve_args(args, cmd.opcode, state)
           state.curve_to(x3, y3)
           context.emitter.emit(Model::Operators::Path::Curveto.new(
-            x1: x1, y1: y1, x2: x2, y2: y2, x3: x3, y3: y3,
-          ))
+                                 x1: x1, y1: y1, x2: x2, y2: y2, x3: x3, y3: y3,
+                               ))
           smooth.control_x = x2
           smooth.control_y = y2
           smooth.smoothable = true
@@ -129,14 +138,15 @@ module Postsvg
             x1, y1 = reflect_control(smooth, state)
             state.curve_to(x3, y3)
             context.emitter.emit(Model::Operators::Path::Curveto.new(
-              x1: x1, y1: y1, x2: x2, y2: y2, x3: x3, y3: y3,
-            ))
+                                   x1: x1, y1: y1, x2: x2, y2: y2, x3: x3, y3: y3,
+                                 ))
           else
             dx1, dy1 = reflect_control_rel(smooth, state)
-            state.curve_to_rel(dx2: x2, dy2: y2, dx3: x3, dy3: y3, dx1: dx1, dy1: dy1)
+            state.curve_to_rel(dx2: x2, dy2: y2, dx3: x3, dy3: y3, dx1: dx1,
+                               dy1: dy1)
             context.emitter.emit(Model::Operators::Path::Rcurveto.new(
-              dx1: dx1, dy1: dy1, dx2: x2, dy2: y2, dx3: x3, dy3: y3,
-            ))
+                                   dx1: dx1, dy1: dy1, dx2: x2, dy2: y2, dx3: x3, dy3: y3,
+                                 ))
             x2 = state.current_x - x2
             y2 = state.current_y - y2
           end
@@ -150,15 +160,16 @@ module Postsvg
           qx, qy, x3, y3 = adapt_quadratic_args(args, cmd.opcode, state)
           # Convert quadratic to cubic: c1 = p0 + 2/3*(q-p0),
           # c2 = p3 + 2/3*(q-p3).
-          p0x, p0y = state.current_x, state.current_y
-          c1x = p0x + (2.0 / 3.0) * (qx - p0x)
-          c1y = p0y + (2.0 / 3.0) * (qy - p0y)
-          c2x = x3 + (2.0 / 3.0) * (qx - x3)
-          c2y = y3 + (2.0 / 3.0) * (qy - y3)
+          p0x = state.current_x
+          p0y = state.current_y
+          c1x = p0x + ((2.0 / 3.0) * (qx - p0x))
+          c1y = p0y + ((2.0 / 3.0) * (qy - p0y))
+          c2x = x3 + ((2.0 / 3.0) * (qx - x3))
+          c2y = y3 + ((2.0 / 3.0) * (qy - y3))
           state.curve_to(x3, y3)
           context.emitter.emit(Model::Operators::Path::Curveto.new(
-            x1: c1x, y1: c1y, x2: c2x, y2: c2y, x3: x3, y3: y3,
-          ))
+                                 x1: c1x, y1: c1y, x2: c2x, y2: c2y, x3: x3, y3: y3,
+                               ))
           smooth.control_x = qx
           smooth.control_y = qy
           smooth.smoothable = true
@@ -166,28 +177,27 @@ 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), reflect_y(smooth.control_y, state)]
+              [reflect_x(smooth.control_x, state),
+               reflect_y(smooth.control_y, state)]
             else
               [state.current_x, state.current_y]
             end
-          p0x, p0y = state.current_x, state.current_y
-          c1x = p0x + (2.0 / 3.0) * (qx - p0x)
-          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
+          p0x = state.current_x
+          p0y = state.current_y
+          c1x = p0x + ((2.0 / 3.0) * (qx - p0x))
+          c1y = p0y + ((2.0 / 3.0) * (qy - p0y))
+          c2x = x3 + ((2.0 / 3.0) * (qx - x3))
+          c2y = y3 + ((2.0 / 3.0) * (qy - y3))
+          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,
-          ))
+                                 x1: c1x, y1: c1y, x2: c2x, y2: c2y, x3: state.current_x, y3: state.current_y,
+                               ))
           smooth.control_x = qx
           smooth.control_y = qy
           smooth.smoothable = true
@@ -198,32 +208,43 @@ 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,
               rx: rx, ry: ry, x_axis_rotation: x_axis_rotation,
               large_arc: large_arc_flag != 0, sweep: sweep_flag != 0,
-              x2: x, y2: y,
+              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(
-              x: 0, y: 0, radius: 1.0, angle1: theta1, angle2: theta2,
-            ))
-            context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+                                                                                 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(arc_class.new(
+                                   x: 0, y: 0, radius: 1.0, angle1: theta1, angle2: theta2,
+                                 ))
+            context.emitter.emit(Model::Operators::Transformations::Setmatrix.new(
+                                   matrix: Model::Computed.new(operator_keyword: "currentmatrix"),
+                                 ))
           else
-            context.emitter.emit(Model::Operators::Path::Arc.new(
-              x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
-            ))
+            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 ----
@@ -254,7 +275,8 @@ module Postsvg
         def self.reflect_control(smooth, state)
           return [state.current_x, state.current_y] unless smooth.smoothable
 
-          [reflect_x(smooth.control_x, state), reflect_y(smooth.control_y, state)]
+          [reflect_x(smooth.control_x, state),
+           reflect_y(smooth.control_y, state)]
         end
 
         def self.reflect_control_rel(smooth, state)
@@ -263,11 +285,11 @@ module Postsvg
         end
 
         def self.reflect_x(control_x, state)
-          2 * state.current_x - control_x
+          (2 * state.current_x) - control_x
         end
 
         def self.reflect_y(control_y, state)
-          2 * state.current_y - control_y
+          (2 * state.current_y) - control_y
         end
 
         # Mutable path-tracking state shared across command handlers.

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

@@ -15,9 +15,11 @@ module Postsvg
           points = element.points
           points.each_slice(2).with_index do |(x, y), idx|
             if idx.zero?
-              context.emitter.emit(Model::Operators::Path::Moveto.new(x: x, y: y))
+              context.emitter.emit(Model::Operators::Path::Moveto.new(x: x,
+                                                                      y: y))
             else
-              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x, y: y))
+              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x,
+                                                                      y: y))
             end
           end
           context.emitter.emit(Model::Operators::Path::Closepath.new)

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

@@ -9,17 +9,18 @@ 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|
             if idx.zero?
-              context.emitter.emit(Model::Operators::Path::Moveto.new(x: x, y: y))
+              context.emitter.emit(Model::Operators::Path::Moveto.new(x: x,
+                                                                      y: y))
             else
-              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x, y: y))
+              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x,
+                                                                      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/rect_handler.rb

@@ -10,12 +10,17 @@ module Postsvg
           context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
           emit_transform(element, context)
           context.emitter.emit(Model::Operators::Path::Newpath.new)
-          x, y = element.x, element.y
-          w, h = element.width, element.height
+          x = element.x
+          y = element.y
+          w = element.width
+          h = element.height
           context.emitter.emit(Model::Operators::Path::Moveto.new(x: x, y: y))
-          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: w, dy: 0))
-          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: 0, dy: h))
-          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: -w, dy: 0))
+          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: w,
+                                                                   dy: 0))
+          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: 0,
+                                                                   dy: h))
+          context.emitter.emit(Model::Operators::Path::Rlineto.new(dx: -w,
+                                                                   dy: 0))
           context.emitter.emit(Model::Operators::Path::Closepath.new)
           emit_paint(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)

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

@@ -20,8 +20,8 @@ module Postsvg
         def emit_paint(element, context)
           fill_paint = element.fill
           stroke_paint = element.stroke_paint
-          fill_on = fill_paint && fill_paint.color?
-          stroke_on = stroke_paint && stroke_paint.color?
+          fill_on = fill_paint&.color?
+          stroke_on = stroke_paint&.color?
 
           if fill_on && stroke_on
             emit_fill(element, context)
@@ -52,26 +52,26 @@ module Postsvg
 
         def emit_fill(element, context)
           paint = element.fill
-          return unless paint && paint.color?
+          return unless paint&.color?
 
           color = paint.value
           if color.gray?
             context.emitter.emit(Model::Operators::Color::Setgray.new(gray: color.gray_level))
           else
             context.emitter.emit(Model::Operators::Color::Setrgbcolor.new(
-              red: color.red / 255.0, green: color.green / 255.0, blue: color.blue / 255.0,
-            ))
+                                   red: color.red / 255.0, green: color.green / 255.0, blue: color.blue / 255.0,
+                                 ))
           end
         end
 
         def emit_stroke(element, context)
           paint = element.stroke_paint
-          return unless paint && paint.color?
+          return unless paint&.color?
 
           color = paint.value
           context.emitter.emit(Model::Operators::Color::Setrgbcolor.new(
-            red: color.red / 255.0, green: color.green / 255.0, blue: color.blue / 255.0,
-          ))
+                                 red: color.red / 255.0, green: color.green / 255.0, blue: color.blue / 255.0,
+                               ))
           stroke = element.stroke
           return unless stroke
 
@@ -92,8 +92,8 @@ module Postsvg
 
           transform.matrices.each do |matrix|
             context.emitter.emit(Model::Operators::Transformations::Concat.new(matrix: [
-              matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f,
-            ]))
+                                                                                 matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f
+                                                                               ]))
           end
         end
 
@@ -102,7 +102,7 @@ module Postsvg
           ys = points.each_slice(2).map(&:last)
           return if xs.empty?
 
-          context.expand_bbox!((xs.min..xs.max), (ys.min..ys.max))
+          context.expand_bbox!(xs.min..xs.max, ys.min..ys.max)
         end
       end
     end

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

@@ -16,10 +16,11 @@ module Postsvg
         # Element base class guarantees the +children+ getter.
         def self.descend(element, context)
           element.children.each do |child|
-            Postsvg::Translation::PsRenderer.default_registry.translate(child, context)
+            Postsvg::Translation::PsRenderer.default_registry.translate(child,
+                                                                        context)
           end
         end
       end
     end
   end
-end
+end

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
@@ -21,18 +23,25 @@ module Postsvg
         def self.call(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
           emit_transform(element, context)
-          emit_fill(element, context) if element.fill && element.fill.color?
+          emit_fill(element, context) if element.fill&.color?
 
           font_name = font_name_value(element)
           context.emitter.emit(Model::Operators::Font::Findfont.new(name: font_name))
           context.emitter.emit(Model::Operators::Font::Scalefont.new(
-            font: Model::Computed.new(operator_keyword: "findfont"),
-            size: element.font_size,
-          ))
+                                 font: Model::Computed.new(operator_keyword: "findfont"),
+                                 size: element.font_size,
+                               ))
           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))
+                                 font: Model::Computed.new(operator_keyword: "scalefont"),
+                               ))
+          # 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/handlers.rb

@@ -17,7 +17,8 @@ module Postsvg
       autoload :TextHandler, "postsvg/translation/handlers/text_handler"
       autoload :ImageHandler, "postsvg/translation/handlers/image_handler"
       autoload :DefsHandler, "postsvg/translation/handlers/defs_handler"
-      autoload :ClipPathHandler, "postsvg/translation/handlers/clip_path_handler"
+      autoload :ClipPathHandler,
+               "postsvg/translation/handlers/clip_path_handler"
       autoload :OpenHandler, "postsvg/translation/handlers/open_handler"
       autoload :Shared, "postsvg/translation/handlers/shared"
     end

data/lib/postsvg/translation/ps_renderer.rb

@@ -72,10 +72,12 @@ 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)
+          BoundingBox.new(min_x: 0, min_y: 0, max_x: document.width,
+                          max_y: document.height)
         else
           BoundingBox.empty
         end
@@ -85,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 =
@@ -98,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