postsvg 0.1.0 → 0.3.0

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      # SVG `<polygon>`: like `<polyline>` but the path is closed.
+      # Emits moveto + N×lineto + closepath + paint.
+      class PolygonHandler
+        extend Shared
+
+        def self.call(element, context)
+          context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
+          emit_transform(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))
+            else
+              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x, y: y))
+            end
+          end
+          context.emitter.emit(Model::Operators::Path::Closepath.new)
+          emit_paint(element, context)
+          context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+          xs = points.each_slice(2).map(&:first)
+          ys = points.each_slice(2).map(&:last)
+          expand_bbox(context, xs.min, ys.min, xs.max, ys.max) if xs.any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      class PolylineHandler
+        extend Shared
+
+        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))
+            else
+              context.emitter.emit(Model::Operators::Path::Lineto.new(x: x, y: y))
+            end
+          end
+          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)
+          expand_bbox(context, xs.min, ys.min, xs.max, ys.max) if xs.any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      class RectHandler
+        extend Shared
+
+        def self.call(element, context)
+          context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
+          emit_transform(element, context)
+          context.emitter.emit(Model::Operators::Path::Newpath.new)
+          x, y = element.x, element.y
+          w, h = element.width, element.height
+          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::Closepath.new)
+          emit_paint(element, context)
+          context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+          expand_bbox(context, x, y, x + w, y + h)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      # Helpers shared by every handler. Mixed into each handler
+      # class via +extend Shared+ so handler bodies stay declarative.
+      #
+      # All element classes in Svg::Elements provide +fill+,
+      # +stroke_paint+, +stroke+, and +transform+ getters (returning
+      # nil when not applicable). This module relies on those getters
+      # existing — no +respond_to?+ checks.
+      module Shared
+        # Emit paint setup + paint terminator(s) for an element. When
+        # the element has only fill, emits color + fill. When only
+        # stroke, emits color + stroke. When both, emits a
+        # gsave / setrgbcolor(fill) / fill / grestore /
+        # setrgbcolor(stroke) / stroke sequence so each paint uses
+        # the right color.
+        def emit_paint(element, context)
+          fill_paint = element.fill
+          stroke_paint = element.stroke_paint
+          fill_on = fill_paint && fill_paint.color?
+          stroke_on = stroke_paint && stroke_paint.color?
+
+          if fill_on && stroke_on
+            emit_fill(element, context)
+            context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
+            context.emitter.emit(Model::Operators::Painting::Fill.new)
+            context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+            emit_stroke(element, context)
+            context.emitter.emit(Model::Operators::Painting::Stroke.new)
+          elsif fill_on
+            emit_fill(element, context)
+            context.emitter.emit(Model::Operators::Painting::Fill.new)
+          elsif stroke_on
+            emit_stroke(element, context)
+            context.emitter.emit(Model::Operators::Painting::Stroke.new)
+          else
+            # No explicit paint — fill with current color (default).
+            context.emitter.emit(Model::Operators::Painting::Fill.new)
+          end
+        end
+
+        # Convenience for handlers that want to set up colors without
+        # emitting a paint terminator (e.g. LineHandler which always
+        # strokes).
+        def emit_paint_setup(element, context)
+          emit_fill(element, context)
+          emit_stroke(element, context)
+        end
+
+        def emit_fill(element, context)
+          paint = element.fill
+          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,
+            ))
+          end
+        end
+
+        def emit_stroke(element, context)
+          paint = element.stroke_paint
+          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,
+          ))
+          stroke = element.stroke
+          return unless stroke
+
+          context.emitter.emit(Model::Operators::GraphicsState::Setlinewidth.new(width: stroke.width)) if stroke.width
+          if stroke.linecap
+            code = { butt: 0, round: 1, square: 2 }[stroke.linecap.to_sym]
+            context.emitter.emit(Model::Operators::GraphicsState::Setlinecap.new(cap_code: code)) if code
+          end
+          if stroke.linejoin
+            code = { miter: 0, round: 1, bevel: 2 }[stroke.linejoin.to_sym]
+            context.emitter.emit(Model::Operators::GraphicsState::Setlinejoin.new(join_code: code)) if code
+          end
+        end
+
+        def emit_transform(element, context)
+          transform = element.transform
+          return unless transform && !transform.empty?
+
+          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,
+            ]))
+          end
+        end
+
+        def expand_bbox(context, *points)
+          xs = points.each_slice(2).map(&:first)
+          ys = points.each_slice(2).map(&:last)
+          return if xs.empty?
+
+          context.expand_bbox!((xs.min..xs.max), (ys.min..ys.max))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      class SvgHandler
+        extend Shared
+
+        def self.call(element, context)
+          # SVG root: descend into children. Header / viewBox are
+          # captured by the PsRenderer; no records needed here.
+          descend(element, context)
+        end
+
+        # Walks an element's +children+ using the default registry.
+        # 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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    module Handlers
+      # SVG `<text>`. Emits a complete PS text sequence:
+      #
+      #   /<font-family> findfont
+      #   <font-size> scalefont
+      #   setfont
+      #   <x> <y> moveto
+      #   (text) show
+      #
+      # Real font metrics (kerning, ligatures, glyph substitution) are
+      # tracked in TODO.roadmap/20-font-and-text.md. The shape of the
+      # emitted sequence matches PLRM §5 so PS interpreters that DO
+      # have the named font will render the text correctly.
+      class TextHandler
+        extend Shared
+
+        def self.call(element, context)
+          context.emitter.emit(Model::Operators::GraphicsState::Gsave.new)
+          emit_transform(element, context)
+          emit_fill(element, context) if element.fill && element.fill.color?
+
+          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,
+          ))
+          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))
+          context.emitter.emit(Model::Operators::Font::Show.new(text: element.content.to_s))
+
+          context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)
+          expand_bbox(context,
+                      element.x, element.y,
+                      element.x + (element.content.to_s.length * element.font_size / 2.0),
+                      element.y + element.font_size)
+        end
+
+        # Strip quotes; SVG allows comma-separated fallback list,
+        # take the first family.
+        def self.font_name_value(element)
+          raw = element.font_family.to_s
+          raw = raw.gsub(/["']/, "")
+          raw.split(",").first.to_s.strip
+        end
+        private_class_method :font_name_value
+      end
+    end
+  end
+end

data/lib/postsvg/translation/handlers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    # SVG element handler catalogue. One handler class per supported
+    # SVG element. Each implements +.call(element, context)+.
+    module Handlers
+      autoload :SvgHandler, "postsvg/translation/handlers/svg_handler"
+      autoload :GroupHandler, "postsvg/translation/handlers/group_handler"
+      autoload :PathHandler, "postsvg/translation/handlers/path_handler"
+      autoload :RectHandler, "postsvg/translation/handlers/rect_handler"
+      autoload :CircleHandler, "postsvg/translation/handlers/circle_handler"
+      autoload :EllipseHandler, "postsvg/translation/handlers/ellipse_handler"
+      autoload :LineHandler, "postsvg/translation/handlers/line_handler"
+      autoload :PolylineHandler, "postsvg/translation/handlers/polyline_handler"
+      autoload :PolygonHandler, "postsvg/translation/handlers/polygon_handler"
+      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 :OpenHandler, "postsvg/translation/handlers/open_handler"
+      autoload :Shared, "postsvg/translation/handlers/shared"
+    end
+  end
+end

data/lib/postsvg/translation/ps_renderer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    # Top-level orchestrator: takes an Svg::Document, walks its element
+    # tree via a HandlerRegistry, and produces a Model::Program whose
+    # body the Serializer consumes.
+    class PsRenderer
+      DEFAULT_REGISTRY = HandlerRegistry.new
+      @default_registered = false
+
+      class << self
+        attr_reader :default_registered
+
+        # Idempotent: only registers once. Called automatically by
+        # +default_registry+ before each translate, so callers don't
+        # need to remember to invoke it.
+        def register_default_handlers!
+          return if @default_registered
+
+          DEFAULT_REGISTRY.register(Svg::Elements::Svg, Handlers::SvgHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Group, Handlers::GroupHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Path, Handlers::PathHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Rect, Handlers::RectHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Circle, Handlers::CircleHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Ellipse, Handlers::EllipseHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Line, Handlers::LineHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Polyline, Handlers::PolylineHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Polygon, Handlers::PolygonHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Text, Handlers::TextHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Image, Handlers::ImageHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::Defs, Handlers::DefsHandler)
+          DEFAULT_REGISTRY.register(Svg::Elements::ClipPath, Handlers::ClipPathHandler)
+          DEFAULT_REGISTRY.register(Svg::OpenElement, Handlers::OpenHandler)
+          @default_registered = true
+        end
+
+        # Public accessor: returns the default registry after ensuring
+        # handlers are registered. Use this in handlers instead of
+        # reaching for the constant directly.
+        def default_registry
+          register_default_handlers!
+          DEFAULT_REGISTRY
+        end
+      end
+
+      def self.call(document, eps: false, registry: nil)
+        registry ||= default_registry
+        new(document, eps: eps, registry: registry).call
+      end
+
+      attr_reader :document, :eps, :registry
+
+      def initialize(document, eps:, registry:)
+        @document = document
+        @eps = eps
+        @registry = registry
+      end
+
+      def call
+        emitter = RecordEmitter.new
+        bbox = compute_viewport_bbox
+        context = Context.new(emitter: emitter,
+                              bounding_box: bbox,
+                              clip_path_registry: document.clip_paths,
+                              options: { eps: eps })
+        dispatch(document.root_element, context)
+        build_program(emitter, context)
+      end
+
+      private
+
+      def compute_viewport_bbox
+        if document.viewbox
+          llx, lly, urx, ury = document.viewbox
+          BoundingBox.new(min_x: llx, min_y: lly, max_x: urx, max_y: ury)
+        elsif document.width && document.height
+          BoundingBox.new(min_x: 0, min_y: 0, max_x: document.width, max_y: document.height)
+        else
+          BoundingBox.empty
+        end
+      end
+
+      def dispatch(element, context)
+        registry.translate(element, context)
+      end
+
+      def build_program(emitter, context)
+        bbox = context.bounding_box
+        header_bbox =
+          if bbox.empty?
+            [0, 0, 595, 842] # A4 fallback
+          else
+            bbox.to_a
+          end
+        header = Model::Program::Header.new(
+          bounding_box: header_bbox,
+          epsf: eps,
+          title: "Translated by Postsvg #{::Postsvg::VERSION}",
+        )
+        Model::Program.new(header: header, body: emitter.records)
+      end
+    end
+  end
+end

data/lib/postsvg/translation/record_emitter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Translation
+    # Accumulator of Model::Operator instances that the PsRenderer
+    # builds. Thin wrapper around an array; provides a uniform emit
+    # surface so handlers don't all need to know how the program is
+    # stored.
+    class RecordEmitter
+      attr_reader :records
+
+      def initialize
+        @records = []
+      end
+
+      def emit(record)
+        @records << record
+        self
+      end
+
+      def emit_many(records)
+        records.each { |r| emit(r) }
+        self
+      end
+
+      def length
+        @records.length
+      end
+
+      def to_a
+        @records.dup
+      end
+    end
+  end
+end

data/lib/postsvg/translation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # SVG → PS translation layer. Consumes Svg::* value objects and
+  # produces a Model::Program whose records a Serializer can write to
+  # PS source. The model is the single source of truth: handlers
+  # build records; the serializer consumes them later.
+  module Translation
+    autoload :PsRenderer, "postsvg/translation/ps_renderer"
+    autoload :HandlerRegistry, "postsvg/translation/handler_registry"
+    autoload :Context, "postsvg/translation/context"
+    autoload :RecordEmitter, "postsvg/translation/record_emitter"
+    autoload :Handlers, "postsvg/translation/handlers"
+    autoload :BoundingBox, "postsvg/translation/bounding_box"
+    autoload :ArcConverter, "postsvg/translation/arc_converter"
+  end
+end

data/lib/postsvg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Postsvg
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Visitors
+    class PsVisitor
+      # Arithmetic / math operator handlers. Each pops operands from
+      # the RUNTIME stack (not the AST), computes the result, and
+      # pushes it back. The AST operands are for parse-time stack
+      # shape only; at runtime they may be +Computed+ sentinels
+      # (from chained ops) and must be ignored.
+      module Arithmetic
+        def visit_add(_op, _ctx)
+          b = pop_runtime_number
+          a = pop_runtime_number
+          @stack << a + b
+        end
+
+        def visit_sub(_op, _ctx)
+          b = pop_runtime_number
+          a = pop_runtime_number
+          @stack << a - b
+        end
+
+        def visit_mul(_op, _ctx)
+          b = pop_runtime_number
+          a = pop_runtime_number
+          @stack << a * b
+        end
+
+        def visit_div(_op, _ctx)
+          divisor = pop_runtime_number
+          a = pop_runtime_number
+          raise RenderError, "division by zero" if divisor.zero?
+
+          @stack << (a.to_f / divisor.to_f)
+        end
+
+        def visit_idiv(_op, _ctx)
+          divisor = pop_runtime_number.to_i
+          a = pop_runtime_number.to_i
+          raise RenderError, "division by zero" if divisor.zero?
+
+          @stack << (a / divisor)
+        end
+
+        def visit_mod(_op, _ctx)
+          divisor = pop_runtime_number.to_i
+          a = pop_runtime_number.to_i
+          raise RenderError, "modulo by zero" if divisor.zero?
+
+          @stack << (a % divisor)
+        end
+
+        def visit_neg(_op, _ctx)
+          @stack << -pop_runtime_number
+        end
+
+        def visit_abs(_op, _ctx)
+          @stack << pop_runtime_number.abs
+        end
+
+        def visit_ceiling(_op, _ctx)
+          @stack << pop_runtime_number.to_f.ceil
+        end
+
+        def visit_floor(_op, _ctx)
+          @stack << pop_runtime_number.to_f.floor
+        end
+
+        def visit_round(_op, _ctx)
+          @stack << pop_runtime_number.to_f.round
+        end
+
+        def visit_truncate(_op, _ctx)
+          @stack << pop_runtime_number.to_f.truncate
+        end
+
+        def visit_sqrt(_op, _ctx)
+          operand = pop_runtime_number
+          raise RenderError, "sqrt of negative" if operand.negative?
+
+          @stack << Math.sqrt(operand.to_f)
+        end
+
+        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)
+        end
+
+        def visit_cos(_op, _ctx)
+          @stack << Math.cos(pop_runtime_number.to_f * Math::PI / 180.0)
+        end
+
+        def visit_sin(_op, _ctx)
+          @stack << Math.sin(pop_runtime_number.to_f * Math::PI / 180.0)
+        end
+
+        def visit_ln(_op, _ctx)
+          @stack << Math.log(pop_runtime_number.to_f)
+        end
+
+        def visit_log(_op, _ctx)
+          @stack << Math.log10(pop_runtime_number.to_f)
+        end
+
+        def visit_exp(_op, _ctx)
+          b = pop_runtime_number
+          a = pop_runtime_number
+          @stack << a.to_f**b.to_f
+        end
+
+        private
+
+        # Pop a value off the RUNTIME stack and resolve it to a
+        # number. Names that resolve via the dict stack are followed.
+        # Falls back to 0 for unknown values (mirroring parse-time
+        # tolerance for +Computed+ sentinels).
+        def pop_runtime_number
+          numeric_value(@stack.pop)
+        end
+      end
+    end
+  end
+end