postsvg 0.2.6 → 0.3.0

data/lib/postsvg/translation/arc_converter.rb

@@ -11,7 +11,7 @@ module Postsvg
 
       module_function
 
-      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
+      # rubocop:disable 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
@@ -26,8 +26,8 @@ module Postsvg
         # Step 1: rotate and scale (x1,y1) into the unit-circle frame.
         dx = (x1 - x2) / 2.0
         dy = (y1 - y2) / 2.0
-        x1p = (cos_phi * dx) + (sin_phi * dy)
-        y1p = (-sin_phi * dx) + (cos_phi * dy)
+        x1p =  cos_phi * dx + sin_phi * dy
+        y1p = -sin_phi * dx + cos_phi * dy
 
         # Ensure radii are large enough; if not, scale them up.
         rx_sq = rx * rx
@@ -44,17 +44,17 @@ module Postsvg
         end
 
         # Step 2: compute center (cx', cy') in the rotated frame.
-        sign = large_arc == sweep ? -1 : 1
-        num = (rx_sq * ry_sq) - (rx_sq * y1p_sq) - (ry_sq * x1p_sq)
-        den = (rx_sq * y1p_sq) + (ry_sq * x1p_sq)
+        sign = (large_arc == sweep) ? -1 : 1
+        num = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq
+        den = rx_sq * y1p_sq + ry_sq * x1p_sq
         den = EPSILON if den.abs < EPSILON
         coef = sign * Math.sqrt([num / den, 0.0].max)
         cxp =  coef * (rx * y1p) / ry
         cyp = -coef * (ry * x1p) / rx
 
         # Step 3: rotate (cx', cy') back into original frame.
-        cx = (cos_phi * cxp) - (sin_phi * cyp) + ((x1 + x2) / 2.0)
-        cy = (sin_phi * cxp) + (cos_phi * cyp) + ((y1 + y2) / 2.0)
+        cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2.0
+        cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2.0
 
         # Step 4: compute angles.
         ux = (x1p - cxp) / rx
@@ -70,25 +70,16 @@ 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)
+        dot = ux * vx + uy * vy
+        len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy))
         return 0.0 if len < EPSILON
 
-        cos_val = (dot_product(ux, uy, vx, vy) / len).clamp(-1.0, 1.0)
-        cross_sign(ux, uy, vx, vy) * Math.acos(cos_val)
-      end
-
-      def vector_length(ux, uy, vx, vy)
-        Math.sqrt(((ux * ux) + (uy * uy)) * ((vx * vx) + (vy * vy)))
-      end
-
-      def dot_product(ux, uy, vx, vy)
-        (ux * vx) + (uy * vy)
-      end
-
-      def cross_sign(ux, uy, vx, vy)
-        ((ux * vy) - (uy * vx)).negative? ? -1.0 : 1.0
+        cos_val = (dot / len).clamp(-1.0, 1.0)
+        sign = (ux * vy - uy * vx).negative? ? -1.0 : 1.0
+        sign * Math.acos(cos_val)
       end
     end
   end

data/lib/postsvg/translation/bounding_box.rb

@@ -27,14 +27,11 @@ module Postsvg
       def expand(x_range, y_range)
         return self if x_range.nil? || y_range.nil?
 
-        new_min_x = [(empty? ? x_range.begin : @min_x),
-                     x_range.begin].compact.min
+        new_min_x = [(empty? ? x_range.begin : @min_x), x_range.begin].compact.min
         new_max_x = [(empty? ? x_range.end : @max_x), x_range.end].compact.max
-        new_min_y = [(empty? ? y_range.begin : @min_y),
-                     y_range.begin].compact.min
+        new_min_y = [(empty? ? y_range.begin : @min_y), y_range.begin].compact.min
         new_max_y = [(empty? ? y_range.end : @max_y), y_range.end].compact.max
-        BoundingBox.new(min_x: new_min_x, min_y: new_min_y, max_x: new_max_x,
-                        max_y: new_max_y)
+        BoundingBox.new(min_x: new_min_x, min_y: new_min_y, max_x: new_max_x, max_y: new_max_y)
       end
 
       def to_a
@@ -54,7 +51,7 @@ module Postsvg
 
         "%s %s %s %s" % [
           FormatNumber.call(@min_x), FormatNumber.call(@min_y),
-          FormatNumber.call(@max_x), FormatNumber.call(@max_y)
+          FormatNumber.call(@max_x), FormatNumber.call(@max_y),
         ]
       end
     end

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,14 +17,9 @@ 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,8 +11,7 @@ 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,10 +10,9 @@ 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.
-          element.href || "(none)"
+          href = 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,12 +11,8 @@ 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,11 +9,10 @@ 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 horizontal line
-      # - V/v vertical line
+      # - H/h vertical line
+      # - V/v horizontal line
       # - C/c cubic bezier
       # - S/s smooth cubic (reflects previous control point)
       # - Q/q quadratic bezier (converted to cubic)
@@ -22,8 +22,7 @@ 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)
@@ -31,8 +30,7 @@ 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
@@ -50,7 +48,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: false)
+            handle_hv(cmd, state, context, horizontal: cmd.opcode.upcase == "V")
           when "C", "c"
             handle_cubic(cmd, state, smooth, context)
           when "S", "s"
@@ -76,8 +74,7 @@ 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
@@ -89,8 +86,7 @@ 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
 
@@ -100,23 +96,18 @@ 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
 
@@ -125,8 +116,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
@@ -138,15 +129,14 @@ 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
@@ -160,16 +150,15 @@ 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 = 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))
+          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)
           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
@@ -177,27 +166,28 @@ 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 = 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)
+          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
           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
@@ -208,43 +198,32 @@ 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,
             )
-          # Restore only the CTM: grestore would discard the appended arc.
-          arc_class = sweep_flag.zero? ? Model::Operators::Path::Arcn : Model::Operators::Path::Arc
+          # Emit arc with center, radius, angle range. For elliptical
+          # arcs (rx != ry or non-zero rotation), emit scale/rotate
+          # transforms around the arc.
           if x_axis_rotation.abs > 1e-6 || (rx - ry).abs > 1e-6
-            context.emitter.emit(Model::Operators::Transformations::Matrix.new)
-            context.emitter.emit(Model::Operators::Transformations::Currentmatrix.new)
+            context.emitter.emit(Model::Operators::GraphicsState::Gsave.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(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"),
-                                 ))
+              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)
           else
-            context.emitter.emit(arc_class.new(
-                                   x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
-                                 ))
+            context.emitter.emit(Model::Operators::Path::Arc.new(
+              x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
+            ))
           end
-          state.line_to(x, y)
+          state.move_to(x, y)
         end
 
         # ---- helpers ----
@@ -275,8 +254,7 @@ 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)
@@ -285,11 +263,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,11 +15,9 @@ 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,18 +9,17 @@ 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
-          emit_paint(element, context)
+          context.emitter.emit(Model::Operators::Painting::Stroke.new)
           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,17 +10,12 @@ module Postsvg
           context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
           emit_transform(element, context)
           context.emitter.emit(Model::Operators::Path::Newpath.new)
-          x = element.x
-          y = element.y
-          w = element.width
-          h = element.height
+          x, y = element.x, element.y
+          w, h = element.width, 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&.color?
-          stroke_on = stroke_paint&.color?
+          fill_on = fill_paint && fill_paint.color?
+          stroke_on = stroke_paint && 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&.color?
+          return unless paint && 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&.color?
+          return unless paint && 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,11 +16,10 @@ 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,9 +8,7 @@ module Postsvg
       #   /<font-family> findfont
       #   <font-size> scalefont
       #   setfont
-      #   <x> <y> translate
-      #   1 -1 scale
-      #   0 0 moveto
+      #   <x> <y> moveto
       #   (text) show
       #
       # Real font metrics (kerning, ligatures, glyph substitution) are
@@ -23,25 +21,18 @@ 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&.color?
+          emit_fill(element, context) if element.fill && 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"),
-                               ))
-          # 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))
+            font: Model::Computed.new(operator_keyword: "scalefont"),
+          ))
+          context.emitter.emit(Model::Operators::Path::Moveto.new(x: element.x, y: element.y))
           context.emitter.emit(Model::Operators::Font::Show.new(text: element.content.to_s))
 
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)