postsvg 0.1.0 → 0.2.1

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Color operator handlers. Each updates the current
+      # GraphicsContext; the next paint operator reads the new colors.
+      module Color
+        def visit_setgray(op, _ctx)
+          color = Postscript::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)
+          @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)
+          @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)
+          @graphics.update(fill_color: color, stroke_color: color)
+        end
+
+        private
+
+        # HSB to RGB. Standard algorithm.
+        def hsb_to_color(h, s, v)
+          h = h % 1.0
+          i = (h * 6).floor
+          f = (h * 6) - i
+          p = v * (1 - s)
+          q = v * (1 - (f * s))
+          t = v * (1 - ((1 - f) * s))
+          r, g, b =
+            case (i % 6)
+            when 0 then [v, t, p]
+            when 1 then [q, v, p]
+            when 2 then [p, v, t]
+            when 3 then [p, q, v]
+            when 4 then [t, p, v]
+            else        [v, p, q]
+            end
+          Postscript::Color.rgb(r, g, b)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Helpers shared across multiple visitor modules. Mixed into
+      # PsVisitor so every module sees the same helpers without
+      # re-defining them. DRY: previously +normalize_key+ existed
+      # in both Dictionary and Container.
+      module Common
+        # Convert a key from any literal-typed value to the canonical
+        # string form used in dictionary lookups.
+        def normalize_key(key)
+          case key
+          when Model::Literals::Name then key.value
+          when String then key.to_s.delete_prefix("/")
+          else key.to_s
+          end
+        end
+
+        # Coerce a runtime value to its underlying string content
+        # (handles StringLiteral / HexLiteral / plain String).
+        def string_value(node)
+          case node
+          when String then node
+          when Model::Literals::StringLiteral then node.value
+          when Model::Literals::HexLiteral then node.bytes
+          end
+        end
+
+        # Resolve a value to a number, looking up names in the dict
+        # stack when possible. Falls back to 0 for unknown values.
+        def numeric_value(value)
+          case value
+          when Numeric then value
+          when Model::Literals::Number then value.value
+          when Model::Literals::Name
+            entry = lookup_dict(value.value)
+            entry ? numeric_value(entry) : 0
+          when Model::Computed then 0
+          else 0
+          end
+        end
+
+        def lookup_dict(name)
+          @dict_stack.reverse_each do |dict|
+            return dict[name] if dict.key?(name)
+          end
+          nil
+        end
+
+        # PS truthiness: false, nil, and 0 are falsy. Everything else
+        # (including the integer 1 and any non-zero Numeric, plus any
+        # object) is truthy.
+        def truthy?(value)
+          return false if [false, nil].include?(value)
+
+          return value != 0 if value.is_a?(Numeric)
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Operators that operate on any collection (string, array,
+      # dictionary). The visitor dispatches by +is_a?+ on the
+      # operand at runtime.
+      module Container
+        def visit_length(op, _ctx)
+          operand = op.operand
+          value =
+            case operand
+            when String then operand.length
+            when Array then operand.length
+            when Hash then operand.length
+            when Model::Literals::StringLiteral then operand.value.length
+            when Model::Literals::ArrayLiteral then operand.elements.length
+            when Model::Literals::Dictionary then operand.entries.length
+            when Model::Literals::HexLiteral then operand.value.length / 2
+            else 0
+            end
+          @stack << value
+        end
+
+        def visit_get(op, _ctx)
+          operand = op.operand
+          key = op.key
+          value =
+            case operand
+            when Hash
+              operand[normalize_key(key)]
+            when Array
+              operand[key.to_i]
+            when String
+              operand.getbyte(key.to_i)
+            when Model::Literals::Dictionary
+              operand.entries[normalize_key(key)]
+            when Model::Literals::ArrayLiteral
+              operand.elements[key.to_i]
+            when Model::Literals::StringLiteral
+              operand.value.getbyte(key.to_i)
+            end
+          @stack << value
+        end
+
+        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
+        end
+
+        def visit_putinterval(_op, _ctx)
+          @builder.comment("putinterval: in-place mutation not supported")
+        end
+
+        def visit_forall(op, _ctx)
+          return unless op.body.is_a?(Model::Literals::Procedure)
+
+          case op.collection
+          when Array
+            op.collection.each do |item|
+              @stack << item
+              op.body.body.each { |node| node.accept(self, nil) }
+            end
+          when Hash
+            op.collection.each do |key, value|
+              @stack << value
+              @stack << key
+              op.body.body.each { |node| node.accept(self, nil) }
+            end
+          when String
+            op.collection.each_byte do |byte|
+              @stack << byte
+              op.body.body.each { |node| node.accept(self, nil) }
+            end
+          end
+        end
+
+        def visit_astore(op, _ctx)
+          # astore pops N items and builds an array. The parser
+          # already gave us the array via from_operands; just push
+          # it back. The original semantics (`arr astore` arr is on
+          # bottom, n items on top) are preserved.
+          @stack << (op.array.is_a?(Array) ? op.array : [])
+        end
+
+        def visit_search(op, _ctx)
+          haystack = string_value(op.target)
+          needle = string_value(op.pattern)
+          if haystack && needle && (idx = haystack.index(needle))
+            post = haystack[(idx + needle.length)..]
+            @stack << post
+            @stack << needle
+            @stack << haystack[0, idx]
+            @stack << true
+          else
+            @stack << haystack
+            @stack << false
+          end
+        end
+
+        def visit_anchorsearch(op, _ctx)
+          haystack = string_value(op.target)
+          needle = string_value(op.pattern)
+          if haystack && needle && haystack.start_with?(needle)
+            @stack << haystack[needle.length..]
+            @stack << needle
+            @stack << true
+          else
+            @stack << haystack
+            @stack << false
+          end
+        end
+
+        def visit_token(op, _ctx)
+          text = string_value(op.target)
+          return @stack << false unless text
+
+          # PS token splits on whitespace and parses the next token.
+          if (match = text.match(/\A\s*(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/))
+            @stack << match[1].to_f
+            @stack << text[match[0].length..]
+            @stack << true
+          else
+            @stack << false
+          end
+        end
+
+        def visit_string(op, _ctx)
+          @stack << ("\0" * op.count.to_i)
+        end
+
+        def visit_cvs(op, _ctx)
+          text =
+            case op.value
+            when Numeric then op.value.to_s
+            when String then op.value
+            when Model::Literals::StringLiteral then op.value.value
+            when Model::Literals::Name then op.value.value
+            else op.value.to_s
+            end
+          @stack << text
+        end
+        # normalize_key and string_value are provided by PsVisitor::Common.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Control flow operator handlers. Each pops operands from the
+      # RUNTIME stack (not the AST), so chained execution behaves
+      # correctly. Bodies are +Procedure+ values that +descend_into_procedure+
+      # walks in the current visitor context.
+      module ControlFlow
+        LOOP_LIMIT = 10_000
+
+        def visit_if(_op, _ctx)
+          body = @stack.pop
+          condition = @stack.pop
+          return unless truthy?(condition)
+
+          descend_into_procedure(body)
+        end
+
+        def visit_ifelse(_op, _ctx)
+          else_body = @stack.pop
+          if_body = @stack.pop
+          condition = @stack.pop
+          if truthy?(condition)
+            descend_into_procedure(if_body)
+          else
+            descend_into_procedure(else_body)
+          end
+        end
+
+        def visit_repeat(_op, _ctx)
+          body = @stack.pop
+          count = pop_runtime_number.to_i.clamp(0, LOOP_LIMIT)
+          count.times { descend_into_procedure(body) }
+        end
+
+        def visit_loop(_op, _ctx)
+          body = @stack.pop
+          LOOP_LIMIT.times do
+            descend_into_procedure(body)
+          rescue Postscript::ExitSignal
+            break
+          end
+        end
+
+        def visit_for(_op, _ctx)
+          body = @stack.pop
+          limit = pop_runtime_number.to_f
+          increment = pop_runtime_number.to_f
+          initial = pop_runtime_number.to_f
+          iterations = 0
+          if increment.positive?
+            value = initial
+            while value <= limit
+              @stack << value
+              descend_into_procedure(body)
+              value += increment
+              iterations += 1
+              break if iterations > LOOP_LIMIT
+            end
+          elsif increment.negative?
+            value = initial
+            while value >= limit
+              @stack << value
+              descend_into_procedure(body)
+              value += increment
+              iterations += 1
+              break if iterations > LOOP_LIMIT
+            end
+          else
+            raise RenderError, "for: zero increment"
+          end
+        end
+
+        def visit_exit(_op, _ctx)
+          raise Postscript::ExitSignal
+        end
+
+        def visit_quit(_op, _ctx)
+          raise Postscript::QuitSignal
+        end
+
+        def visit_exec(_op, _ctx)
+          operand = @stack.pop
+          case operand
+          when Model::Literals::Procedure
+            descend_into_procedure(operand)
+          else
+            @stack << operand
+          end
+        end
+
+        def visit_stopped(_op, _ctx)
+          body = @stack.pop
+          descend_into_procedure(body)
+          @stack << false
+        end
+
+        def descend_into_procedure(procedure)
+          return unless procedure.is_a?(Model::Literals::Procedure)
+
+          procedure.body.each { |node| node.accept(self, nil) }
+        end
+        # truthy? and pop_runtime_number are provided by Common /
+        # Arithmetic respectively.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Device / page operator handlers. In a single-page SVG render
+      # these are largely no-ops; they exist so programs that end
+      # with +showpage+ parse cleanly.
+      module Device
+        def visit_showpage(_op, _ctx)
+          # No-op: SVG is single-page; the renderer finalises on close.
+        end
+
+        def visit_copypage(_op, _ctx); end
+
+        def visit_nulldevice(_op, _ctx); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Dictionary operator handlers (dict-specific only). Generic
+      # collection operators (get / put / length / getinterval /
+      # putinterval) live in the +Container+ module because they
+      # dispatch on operand type at runtime.
+      module Dictionary
+        # The base PsVisitor class initializes +@dict_stack+ as a
+        # single-element array (the global dictionary). Modules assume
+        # it exists; they do not re-initialize.
+
+        def visit_dict(_op, _ctx)
+          @stack << {}
+        end
+
+        def visit_begin(_op, _ctx)
+          value = @stack.pop
+          @dict_stack << (value.is_a?(Hash) ? value : {})
+        end
+
+        def visit_end(_op, _ctx)
+          @dict_stack.pop if @dict_stack.length > 1
+        end
+
+        def visit_def(op, _ctx)
+          key = normalize_key(op.key)
+          @dict_stack.last[key] = op.value
+        end
+
+        def visit_load(op, _ctx)
+          key = normalize_key(op.key)
+          @dict_stack.reverse_each do |dict|
+            if dict.key?(key)
+              @stack << dict[key]
+              return
+            end
+          end
+          raise UndefinedOperatorError, "no value bound to /#{key}"
+        end
+
+        def visit_store(op, _ctx)
+          key = normalize_key(op.key)
+          @dict_stack.reverse_each do |dict|
+            if dict.key?(key)
+              dict[key] = op.value
+              return
+            end
+          end
+          @dict_stack.last[key] = op.value
+        end
+
+        def visit_known(op, _ctx)
+          key = normalize_key(op.key)
+          dict = op.dict.is_a?(Hash) ? op.dict : {}
+          @stack << dict.key?(key)
+        end
+
+        def visit_currentdict(_op, _ctx)
+          @stack << @dict_stack.last
+        end
+
+        def visit_countdictstack(_op, _ctx)
+          @stack << @dict_stack.length
+        end
+
+        def visit_dictstack(_op, _ctx)
+          @stack << @dict_stack.dup
+        end
+
+        def visit_maxlength(op, _ctx)
+          # PS dictionaries can grow dynamically; report current size.
+          @stack << dict_size(op.operand)
+        end
+
+        def dict_size(operand)
+          case operand
+          when Hash then operand.length
+          when Model::Literals::Dictionary then operand.entries.length
+          else 0
+          end
+        end
+
+        def dict_stack
+          @dict_stack ||= [{}]
+        end
+        # normalize_key is provided by PsVisitor::Common.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Font and text operator handlers. Each pops from the RUNTIME
+      # stack (not the AST) so chained font setup works:
+      #
+      #   /Helvetica findfont 18 scalefont setfont
+      #
+      # pushes a FontRef after findfont, scales it after scalefont,
+      # installs it after setfont.
+      module Font
+        # Tracks the current font for later +show+. The visitor
+        # pushes FontRef value objects onto the stack.
+        FontRef = Struct.new(:name, :size, keyword_init: true) do
+          def initialize(name:, size:)
+            super
+            freeze
+          end
+        end
+
+        def visit_findfont(op, _ctx)
+          name =
+            case op.name
+            when Model::Literals::Name then op.name.value
+            when Model::Literals::StringLiteral then op.name.value
+            else op.name.to_s
+            end
+          @stack << FontRef.new(name: name, size: nil)
+        end
+
+        def visit_scalefont(op, _ctx)
+          size = op.size.to_i
+          font = @stack.pop
+          base = if font.is_a?(FontRef)
+                   font
+                 else
+                   FontRef.new(name: "Helvetica",
+                               size: nil)
+                 end
+          @stack << FontRef.new(name: base.name, size: size.to_f)
+        end
+
+        def visit_setfont(_op, _ctx)
+          font = @stack.pop
+          ref = if font.is_a?(FontRef)
+                  font
+                else
+                  FontRef.new(name: "Helvetica",
+                              size: 12.0)
+                end
+          @graphics.update(font_name: ref.name || "Helvetica",
+                           font_size: ref.size || 12.0)
+        end
+
+        def visit_show(_op, _ctx)
+          text = @stack.pop
+          text_str =
+            case text
+            when Model::Literals::StringLiteral then text.value
+            when String then text
+            else text.to_s
+            end
+          pos = @graphics.current.last_text_position
+          return unless pos
+
+          ctm = @graphics.current.ctm
+          screen_pos = ctm.apply_point(pos[:x], pos[:y])
+          color = @graphics.current.fill_color
+          # SVG y is inverted relative to PS — the Y-flip wrapper
+          # group already flips the whole body, so we emit a
+          # scale(1 -1) per <text> to undo the flip for text only.
+          @builder.text(
+            content: text_str,
+            x: screen_pos[:x],
+            y: -screen_pos[:y],
+            font_family: @graphics.current.font_name,
+            font_size: @graphics.current.font_size,
+            color: color || Postscript::Color::BLACK,
+            transform: "scale(1 -1)",
+          )
+          @path.reset
+          @graphics.update(last_text_position: nil)
+        end
+
+        def visit_xyshow(_op, _ctx)
+          @builder.comment("xyshow: not yet implemented")
+        end
+
+        def visit_stringwidth(_op, _ctx)
+          # Without real font metrics, push zero advance.
+          @stack << 0
+          @stack << 0
+        end
+
+        def visit_charpath(_op, _ctx)
+          @builder.comment("charpath: requires font metrics")
+        end
+      end
+    end
+  end
+end

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)
+            end
+          @graphics.update(dash: dash_str)
+        end
+      end
+    end
+  end
+end