postsvg 0.2.2 → 0.3.0

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

@@ -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
@@ -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
@@ -179,17 +168,15 @@ module Postsvg
           x3, y3 = cmd.args
           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))
+          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
@@ -199,8 +186,8 @@ module Postsvg
             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
@@ -216,7 +203,7 @@ module Postsvg
               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
@@ -224,19 +211,17 @@ module Postsvg
           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::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,
-                                 ))
+              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,
-                                 ))
+              x: 0, y: 0, radius: 1.0, angle1: theta1, angle2: theta2,
+            ))
             context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
           else
             context.emitter.emit(Model::Operators::Path::Arc.new(
-                                   x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
-                                 ))
+              x: cx, y: cy, radius: normalized_rx, angle1: theta1, angle2: theta2,
+            ))
           end
           state.move_to(x, y)
         end
@@ -269,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)
@@ -279,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

@@ -14,11 +14,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::Painting::Stroke.new)

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

@@ -21,19 +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"),
-                               ))
-          context.emitter.emit(Model::Operators::Path::Moveto.new(x: element.x,
-                                                                  y: element.y))
+            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)

data/lib/postsvg/translation/handlers.rb

@@ -17,8 +17,7 @@ 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

@@ -75,8 +75,7 @@ module Postsvg
           llx, lly, urx, ury = document.viewbox
           BoundingBox.new(min_x: llx, min_y: lly, max_x: urx, max_y: ury)
         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

data/lib/postsvg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Postsvg
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 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)
+          @stack << (a.to_f / divisor.to_f)
         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,25 +7,22 @@ module Postsvg
       # GraphicsContext; the next paint operator reads the new colors.
       module Color
         def visit_setgray(op, _ctx)
-          color = Postscript::Color.gray(op.gray.to_f)
+          color = Postsvg::Color.gray(op.gray.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_setrgbcolor(op, _ctx)
-          color = Postscript::Color.rgb(op.red.to_f, op.green.to_f,
-                                        op.blue.to_f)
+          color = Postsvg::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 = Postscript::Color.cmyk(op.cyan.to_f, op.magenta.to_f,
-                                         op.yellow.to_f, op.key.to_f)
+          color = Postsvg::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
 
@@ -48,7 +45,7 @@ module Postsvg
             when 4 then [t, p, v]
             else        [v, p, q]
             end
-          Postscript::Color.rgb(r, g, b)
+          Postsvg::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.delete_prefix("/")
+          when String then key.to_s.sub(/\A\//, "")
           else key.to_s
           end
         end
@@ -25,6 +25,7 @@ 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)
-          @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
+          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
         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 Postscript::ExitSignal
+          rescue Postsvg::ExitSignal
             break
           end
         end
@@ -74,11 +74,11 @@ module Postsvg
         end
 
         def visit_exit(_op, _ctx)
-          raise Postscript::ExitSignal
+          raise Postsvg::ExitSignal
         end
 
         def visit_quit(_op, _ctx)
-          raise Postscript::QuitSignal
+          raise Postsvg::QuitSignal
         end
 
         def visit_exec(_op, _ctx)