postsvg 0.1.0 → 0.3.0

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Graphics state operator handlers: gsave/grestore and the line/
+      # dash attribute setters.
+      module GraphicsState
+        def visit_gsave(_op, _ctx)
+          @graphics.gsave
+        end
+
+        def visit_grestore(_op, _ctx)
+          @graphics.grestore
+        end
+
+        def visit_grestoreall(_op, _ctx)
+          @graphics.grestore while @graphics.depth > 1
+        end
+
+        def visit_setlinewidth(op, _ctx)
+          @graphics.update(stroke_width: op.width.to_f)
+        end
+
+        def visit_setlinecap(op, _ctx)
+          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)
+          @graphics.update(line_join: name)
+        end
+
+        def visit_setmiterlimit(op, _ctx)
+          @graphics.update(miter_limit: op.limit.to_f)
+        end
+
+        def visit_setdash(op, _ctx)
+          pattern = op.pattern
+          dash_str =
+            case pattern
+            when Array
+              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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Painting operator handlers. Each flushes the current path
+      # through the SvgBuilder with the appropriate mode and color,
+      # then resets the path.
+      module Painting
+        def visit_stroke(_op, _ctx)
+          flush_path(:stroke)
+          @path.reset
+        end
+
+        def visit_fill(_op, _ctx)
+          flush_path(:fill)
+          @path.reset
+        end
+
+        def visit_eofill(_op, _ctx)
+          flush_path(:fill)
+          @path.reset
+        end
+
+        def visit_clip(_op, _ctx)
+          return if @path.empty?
+
+          path_d = @path.to_path_d
+          clip_id = @builder.register_clip_path(path_d)
+          @graphics.update(clip_paths: @graphics.current.clip_paths + [clip_id])
+          @path.reset
+        end
+
+        def visit_eoclip(_op, _ctx)
+          visit_clip(nil, nil)
+        end
+
+        private
+
+        # Emit the current path as a <path> element. Takes the current
+        # CTM into account: when the CTM is not identity, wraps in a
+        # <g transform="..."> and pre-decomposes the transform.
+        def flush_path(mode)
+          return if @path.empty?
+
+          d = @path.to_path_d
+          ctx = @graphics.current
+          transform_str = build_transform_string(ctx)
+          clip_id = ctx.clip_paths.last
+
+          if transform_str
+            @builder.open_group(transform: transform_str, clip_path_id: clip_id)
+            emit_path(d, mode, ctx)
+            @builder.close_group
+          else
+            emit_path(d, mode, ctx, clip_path_id: clip_id)
+          end
+        end
+
+        def emit_path(d, mode, ctx, clip_path_id: nil)
+          @builder.path(
+            d: d, mode: mode,
+            color: ctx.fill_color,
+            stroke_color: ctx.stroke_color,
+            stroke_width: ctx.stroke_width,
+            line_cap: ctx.line_cap,
+            line_join: ctx.line_join,
+            dash: ctx.dash,
+            clip_path_id: clip_path_id,
+          )
+        end
+
+        def build_transform_string(ctx)
+          return nil if ctx.ctm.identity?
+
+          decomp = ctx.ctm.decompose
+          parts = []
+          tx = decomp[:translate]
+          parts << "translate(#{FormatNumber.call(tx[:x])} #{FormatNumber.call(tx[:y])})" if tx[:x].abs > 1e-6 || tx[:y].abs > 1e-6
+          parts << "rotate(#{FormatNumber.call(decomp[:rotate])})" if decomp[:rotate].abs > 1e-6
+          sc = decomp[:scale]
+          if (sc[:x] - 1).abs > 1e-6 || (sc[:y] - 1).abs > 1e-6
+            parts << "scale(#{FormatNumber.call(sc[:x])} #{FormatNumber.call(sc[:y])})"
+          end
+          parts.empty? ? nil : parts.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    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.
+      module Path
+        def visit_newpath(_op, _ctx)
+          @path.reset
+        end
+
+        def visit_moveto(op, _ctx)
+          @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.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 })
+        end
+
+        def visit_lineto(op, _ctx)
+          @path.line_to(op.x, op.y)
+        end
+
+        def visit_rlineto(op, _ctx)
+          @path.line_to_rel(op.dx, op.dy)
+        end
+
+        def visit_curveto(op, _ctx)
+          @path.curve_to(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3)
+        end
+
+        def visit_rcurveto(op, _ctx)
+          @path.curve_to_rel(op.dx1, op.dy1, op.dx2, op.dy2, op.dx3, op.dy3)
+        end
+
+        def visit_arc(op, _ctx)
+          append_arc(op.x, op.y, op.radius, op.angle1, op.angle2, sweep: true)
+        end
+
+        def visit_arcn(op, _ctx)
+          append_arc(op.x, op.y, op.radius, op.angle1, op.angle2, sweep: false)
+        end
+
+        def visit_closepath(_op, _ctx)
+          @path.close
+        end
+
+        def visit_currentpoint(_op, _ctx)
+          @stack << @path.current_x
+          @stack << @path.current_y
+        end
+
+        private
+
+        # Convert a PS arc into one or two SVG arc commands. PS arcs
+        # 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:)
+          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?
+          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
+          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
+          else
+            @path.arc_to(r, r, 0, large_arc ? 1 : 0, svg_sweep, end_x, end_y)
+          end
+        end
+
+        def last_command_starts_with?(prefix)
+          return false if @path.commands.empty?
+
+          @path.commands.last.start_with?(prefix)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Stack manipulation operator handlers.
+      module Stack
+        def visit_pop(_op, _ctx)
+          pop_value
+        end
+
+        def visit_exch(_op, _ctx)
+          b = pop_value
+          a = pop_value
+          @stack << b
+          @stack << a
+        end
+
+        def visit_dup(_op, _ctx)
+          @stack << @stack.last
+        end
+
+        def visit_index(op, _ctx)
+          @stack << @stack[-1 - op.index]
+        end
+
+        def visit_roll(op, _ctx)
+          count = op.count
+          positions = op.positions
+          return if count.abs > @stack.length
+
+          slice = @stack.pop(count)
+          rotated = positions.negative? ? slice.rotate(positions) : slice.rotate(-positions)
+          rotated.each { |v| @stack << v }
+        end
+
+        def visit_clear(_op, _ctx)
+          @stack = []
+        end
+
+        def visit_count(_op, _ctx)
+          @stack << @stack.length
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Coordinate transformation operator handlers. Each returns a
+      # new CTM via Matrix composition and updates the GraphicsContext.
+      module Transformations
+        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)
+          new_ctm = @graphics.current.ctm.scale(op.sx.to_f, op.sy.to_f)
+          @graphics.update(ctm: new_ctm)
+        end
+
+        def visit_rotate(op, _ctx)
+          new_ctm = @graphics.current.ctm.rotate(op.angle.to_f)
+          @graphics.update(ctm: new_ctm)
+        end
+
+        def visit_concat(op, _ctx)
+          matrix = matrix_from_operand(op.matrix)
+          return unless matrix
+
+          new_ctm = @graphics.current.ctm.multiply(matrix)
+          @graphics.update(ctm: new_ctm)
+        end
+
+        def visit_matrix(_op, _ctx)
+          @stack << [1, 0, 0, 1, 0, 0]
+        end
+
+        def visit_currentmatrix(_op, _ctx)
+          ctm = @graphics.current.ctm
+          @stack << [ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f]
+        end
+
+        def visit_setmatrix(op, _ctx)
+          matrix = matrix_from_operand(op.matrix)
+          return unless matrix
+
+          @graphics.update(ctm: matrix)
+        end
+
+        def visit_transform(_op, _ctx)
+          # Transform a point by the CTM: x y transform -> x' y'
+          y = pop_number
+          x = pop_number
+          p = @graphics.current.ctm.apply_point(x, y)
+          @stack << p[:x]
+          @stack << p[:y]
+        end
+
+        def visit_dtransform(_op, _ctx)
+          y = pop_number
+          x = pop_number
+          # Delta transform: ignore translation.
+          ctm = @graphics.current.ctm
+          dx = (x * ctm.a) + (y * ctm.c)
+          dy = (x * ctm.b) + (y * ctm.d)
+          @stack << dx
+          @stack << dy
+        end
+
+        def visit_itransform(_op, _ctx)
+          y = pop_number
+          x = pop_number
+          p = @graphics.current.ctm.invert.apply_point(x, y)
+          @stack << p[:x]
+          @stack << p[:y]
+        end
+
+        def visit_idtransform(_op, _ctx)
+          y = pop_number
+          x = pop_number
+          inv = @graphics.current.ctm.invert
+          dx = (x * inv.a) + (y * inv.c)
+          dy = (x * inv.b) + (y * inv.d)
+          @stack << dx
+          @stack << dy
+        end
+
+        private
+
+        def matrix_from_operand(operand)
+          case operand
+          when Matrix then operand
+          when Array
+            return nil unless operand.length == 6
+
+            Matrix.new(a: operand[0], b: operand[1], c: operand[2],
+                       d: operand[3], e: operand[4], f: operand[5])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/visitors/ps_visitor.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    # Walks a Model::Program and emits SVG via a SvgBuilder. Holds a
+    # GraphicsStack (immutable snapshots), an operand stack (for
+    # PostScript execution semantics that aren't expressed directly in
+    # the operator node — e.g. user-defined procedures that call
+    # arithmetic), and a current-path accumulator.
+    #
+    # Dispatch is per-category: a separate module mixed in for each
+    # Model::Operators::* namespace. New operator categories = new
+    # module + include line, not a switch edit.
+    class PsVisitor
+      MAX_RECURSION = 256
+
+      autoload :Stack, "postsvg/visitors/ps_visitor/stack"
+      autoload :Arithmetic, "postsvg/visitors/ps_visitor/arithmetic"
+      autoload :Boolean, "postsvg/visitors/ps_visitor/boolean"
+      autoload :Path, "postsvg/visitors/ps_visitor/path"
+      autoload :Painting, "postsvg/visitors/ps_visitor/painting"
+      autoload :Color, "postsvg/visitors/ps_visitor/color"
+      autoload :GraphicsState, "postsvg/visitors/ps_visitor/graphics_state"
+      autoload :Transformations, "postsvg/visitors/ps_visitor/transformations"
+      autoload :Dictionary, "postsvg/visitors/ps_visitor/dictionary"
+      autoload :ControlFlow, "postsvg/visitors/ps_visitor/control_flow"
+      autoload :Device, "postsvg/visitors/ps_visitor/device"
+      autoload :Font, "postsvg/visitors/ps_visitor/font"
+      autoload :Container, "postsvg/visitors/ps_visitor/container"
+      autoload :Common, "postsvg/visitors/ps_visitor/common"
+
+      attr_reader :graphics, :stack, :path, :builder
+
+      def initialize(builder:, graphics: GraphicsStack.new)
+        @builder = builder
+        @graphics = graphics
+        @stack = [] # operand stack for execution semantics
+        @path = PathState.new
+        @dict_stack = [{}] # runtime dict stack (mirrors PLRM dict stack)
+        @recursion_depth = 0
+      end
+
+      # Public entry: dispatch an operator node. Called from
+      # Model::Operator#accept.
+      def dispatch(method_name, operator, ctx)
+        public_send(method_name, operator, ctx)
+      end
+
+      # Visit a Program body.
+      def visit_program(program)
+        program.body.each do |statement|
+          statement.accept(self, nil)
+        end
+      end
+
+      # Literal visits push themselves onto the operand stack.
+      def visit_number(node, _ctx)
+        @stack << node.value
+      end
+
+      def visit_name(node, _ctx)
+        @stack << node
+      end
+
+      def visit_string_literal(node, _ctx)
+        @stack << node.value
+      end
+
+      def visit_hex(node, _ctx)
+        @stack << node
+      end
+
+      def visit_array(node, _ctx)
+        @stack << node.elements
+      end
+
+      def visit_procedure(node, _ctx)
+        @stack << node
+      end
+
+      def visit_dictionary(node, _ctx)
+        @stack << node
+      end
+
+      # Default: unhandled operator becomes a comment.
+      def visit_unknown(operator, _ctx)
+        @builder.comment("unhandled operator: #{operator.keyword}")
+      end
+
+      # InvokeProcedure: descend into the body with the current state.
+      def visit_invoke_procedure(invocation, _ctx)
+        @recursion_depth += 1
+        if @recursion_depth > MAX_RECURSION
+          raise RecursionLimitError,
+                "procedure #{invocation.name} exceeded recursion limit #{MAX_RECURSION}"
+        end
+
+        invocation.procedure.body.each { |node| node.accept(self, nil) }
+      ensure
+        @recursion_depth -= 1
+      end
+
+      # Helper for popping numbers off the operand stack.
+      def pop_number
+        v = @stack.pop
+        numeric_value(v)
+      end
+
+      def pop_value
+        @stack.pop || Model::Computed.new(operator_keyword: "(missing)")
+      end
+
+      # Path state: list of accumulated path commands and the current
+      # pen position. Kept as a separate inner class so the visitor
+      # body stays focused on dispatch + state mutations, not on path
+      # geometry bookkeeping.
+      class PathState
+        attr_reader :commands, :current_x, :current_y
+
+        def initialize
+          @commands = []
+          @current_x = 0.0
+          @current_y = 0.0
+        end
+
+        def empty?
+          @commands.empty?
+        end
+
+        def move_to(x, y)
+          @commands << "M #{fmt(x)} #{fmt(y)}"
+          @current_x = x.to_f
+          @current_y = y.to_f
+        end
+
+        def move_to_rel(dx, dy)
+          @commands << "m #{fmt(dx)} #{fmt(dy)}"
+          @current_x += dx.to_f
+          @current_y += dy.to_f
+        end
+
+        def line_to(x, y)
+          @commands << "L #{fmt(x)} #{fmt(y)}"
+          @current_x = x.to_f
+          @current_y = y.to_f
+        end
+
+        def line_to_rel(dx, dy)
+          @commands << "l #{fmt(dx)} #{fmt(dy)}"
+          @current_x += dx.to_f
+          @current_y += dy.to_f
+        end
+
+        def curve_to(x1, y1, x2, y2, x3, y3)
+          @commands << "C #{fmt(x1)} #{fmt(y1)} #{fmt(x2)} #{fmt(y2)} #{fmt(x3)} #{fmt(y3)}"
+          @current_x = x3.to_f
+          @current_y = y3.to_f
+        end
+
+        def curve_to_rel(dx1, dy1, dx2, dy2, dx3, dy3)
+          @commands << "c #{fmt(dx1)} #{fmt(dy1)} #{fmt(dx2)} #{fmt(dy2)} #{fmt(dx3)} #{fmt(dy3)}"
+          @current_x += dx3.to_f
+          @current_y += dy3.to_f
+        end
+
+        def arc_to(rx, ry, x_axis_rotation, large_arc, sweep, x, y)
+          @commands << "A #{fmt(rx)} #{fmt(ry)} #{fmt(x_axis_rotation)} " \
+                       "#{large_arc ? 1 : 0} #{sweep ? 1 : 0} #{fmt(x)} #{fmt(y)}"
+          @current_x = x.to_f
+          @current_y = y.to_f
+        end
+
+        def close
+          @commands << "Z"
+        end
+
+        def reset
+          @commands = []
+          @current_x = 0.0
+          @current_y = 0.0
+        end
+
+        def to_path_d
+          @commands.join(" ")
+        end
+
+        def fmt(value)
+          FormatNumber.call(value)
+        end
+      end
+
+      include Stack
+      include Arithmetic
+      include Boolean
+      include Path
+      include Painting
+      include Color
+      include GraphicsState
+      include Transformations
+      include Dictionary
+      include ControlFlow
+      include Device
+      include Font
+      include Container
+      include Common
+    end
+  end
+end

data/lib/postsvg/visitors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Visitor namespace. Each direction (PS->SVG, SVG->PS, future PS->PS)
+  # has its own visitor subclass that consumes Model nodes.
+  module Visitors
+    autoload :PsVisitor, "postsvg/visitors/ps_visitor"
+  end
+end