postsvg 0.1.0 → 0.3.0

data/lib/postsvg/model/operators/graphics_state.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module GraphicsState
+        class Gsave < Operator
+          register_as "gsave"
+        end
+
+        class Grestore < Operator
+          register_as "grestore"
+        end
+
+        class Grestoreall < Operator
+          register_as "grestoreall"
+        end
+
+        class Setlinewidth < Operator
+          register_as "setlinewidth"
+          attr_reader :width
+          def initialize(width:)
+            @width = width
+            freeze
+          end
+          def self.from_operands(stack)
+            new(width: stack.pop_number)
+          end
+        end
+
+        class Setlinecap < Operator
+          register_as "setlinecap"
+          attr_reader :cap_code
+          def initialize(cap_code:)
+            @cap_code = cap_code.to_i
+            freeze
+          end
+          def self.from_operands(stack)
+            new(cap_code: stack.pop_number.to_i)
+          end
+        end
+
+        class Setlinejoin < Operator
+          register_as "setlinejoin"
+          attr_reader :join_code
+          def initialize(join_code:)
+            @join_code = join_code.to_i
+            freeze
+          end
+          def self.from_operands(stack)
+            new(join_code: stack.pop_number.to_i)
+          end
+        end
+
+        class Setmiterlimit < Operator
+          register_as "setmiterlimit"
+          attr_reader :limit
+          def initialize(limit:)
+            @limit = limit
+            freeze
+          end
+          def self.from_operands(stack)
+            new(limit: stack.pop_number)
+          end
+        end
+
+        class Setdash < Operator
+          register_as "setdash"
+          attr_reader :pattern, :offset
+          def initialize(pattern:, offset:)
+            @pattern = pattern
+            @offset = offset
+            freeze
+          end
+          def self.from_operands(stack)
+            offset = stack.pop_number
+            pattern = stack.pop
+            new(pattern: pattern, offset: offset)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/painting.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Painting
+        class Stroke < Operator
+          register_as "stroke", consumes: 0, produces: 0
+        end
+
+        class Fill < Operator
+          register_as "fill", consumes: 0, produces: 0
+        end
+
+        class Eofill < Operator
+          register_as "eofill", consumes: 0, produces: 0
+        end
+
+        class Clip < Operator
+          register_as "clip", consumes: 0, produces: 0
+        end
+
+        class Eoclip < Operator
+          register_as "eoclip", consumes: 0, produces: 0
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/path.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Path
+        class Newpath < Operator
+          register_as "newpath"
+        end
+
+        class Moveto < Operator
+          register_as "moveto"
+          attr_reader :x, :y
+          def initialize(x:, y:)
+            @x = x
+            @y = y
+            freeze
+          end
+          def self.from_operands(stack)
+            y = stack.pop_number
+            x = stack.pop_number
+            new(x: x, y: y)
+          end
+        end
+
+        class Rmoveto < Operator
+          register_as "rmoveto"
+          attr_reader :dx, :dy
+          def initialize(dx:, dy:)
+            @dx = dx
+            @dy = dy
+            freeze
+          end
+          def self.from_operands(stack)
+            dy = stack.pop_number
+            dx = stack.pop_number
+            new(dx: dx, dy: dy)
+          end
+        end
+
+        class Lineto < Operator
+          register_as "lineto"
+          attr_reader :x, :y
+          def initialize(x:, y:)
+            @x = x
+            @y = y
+            freeze
+          end
+          def self.from_operands(stack)
+            y = stack.pop_number
+            x = stack.pop_number
+            new(x: x, y: y)
+          end
+        end
+
+        class Rlineto < Operator
+          register_as "rlineto"
+          attr_reader :dx, :dy
+          def initialize(dx:, dy:)
+            @dx = dx
+            @dy = dy
+            freeze
+          end
+          def self.from_operands(stack)
+            dy = stack.pop_number
+            dx = stack.pop_number
+            new(dx: dx, dy: dy)
+          end
+        end
+
+        class Curveto < Operator
+          register_as "curveto"
+          attr_reader :x1, :y1, :x2, :y2, :x3, :y3
+          def initialize(x1:, y1:, x2:, y2:, x3:, y3:)
+            @x1 = x1
+            @y1 = y1
+            @x2 = x2
+            @y2 = y2
+            @x3 = x3
+            @y3 = y3
+            freeze
+          end
+          def self.from_operands(stack)
+            y3 = stack.pop_number
+            x3 = stack.pop_number
+            y2 = stack.pop_number
+            x2 = stack.pop_number
+            y1 = stack.pop_number
+            x1 = stack.pop_number
+            new(x1: x1, y1: y1, x2: x2, y2: y2, x3: x3, y3: y3)
+          end
+        end
+
+        class Rcurveto < Operator
+          register_as "rcurveto"
+          attr_reader :dx1, :dy1, :dx2, :dy2, :dx3, :dy3
+          def initialize(dx1:, dy1:, dx2:, dy2:, dx3:, dy3:)
+            @dx1 = dx1
+            @dy1 = dy1
+            @dx2 = dx2
+            @dy2 = dy2
+            @dx3 = dx3
+            @dy3 = dy3
+            freeze
+          end
+          def self.from_operands(stack)
+            dy3 = stack.pop_number
+            dx3 = stack.pop_number
+            dy2 = stack.pop_number
+            dx2 = stack.pop_number
+            dy1 = stack.pop_number
+            dx1 = stack.pop_number
+            new(dx1: dx1, dy1: dy1, dx2: dx2, dy2: dy2, dx3: dx3, dy3: dy3)
+          end
+        end
+
+        class Arc < Operator
+          register_as "arc"
+          attr_reader :x, :y, :radius, :angle1, :angle2
+          def initialize(x:, y:, radius:, angle1:, angle2:)
+            @x = x
+            @y = y
+            @radius = radius
+            @angle1 = angle1
+            @angle2 = angle2
+            freeze
+          end
+          def self.from_operands(stack)
+            angle2 = stack.pop_number
+            angle1 = stack.pop_number
+            radius = stack.pop_number
+            y = stack.pop_number
+            x = stack.pop_number
+            new(x: x, y: y, radius: radius, angle1: angle1, angle2: angle2)
+          end
+        end
+
+        class Arcn < Operator
+          register_as "arcn"
+          attr_reader :x, :y, :radius, :angle1, :angle2
+          def initialize(x:, y:, radius:, angle1:, angle2:)
+            @x = x
+            @y = y
+            @radius = radius
+            @angle1 = angle1
+            @angle2 = angle2
+            freeze
+          end
+          def self.from_operands(stack)
+            angle2 = stack.pop_number
+            angle1 = stack.pop_number
+            radius = stack.pop_number
+            y = stack.pop_number
+            x = stack.pop_number
+            new(x: x, y: y, radius: radius, angle1: angle1, angle2: angle2)
+          end
+        end
+
+        class Closepath < Operator
+          register_as "closepath"
+        end
+
+        class Currentpoint < Operator
+          register_as "currentpoint"
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/stack.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Stack
+        class Pop < Operator
+          register_as "pop", consumes: 1, produces: 0
+
+          def self.from_operands(stack)
+            stack.pop
+            new
+          end
+        end
+
+        class Exch < Operator
+          register_as "exch", consumes: 2, produces: 2
+
+          def self.from_operands(stack)
+            stack.pop
+            stack.pop
+            new
+          end
+        end
+
+        class Dup < Operator
+          register_as "dup", consumes: 1, produces: 2
+
+          def self.from_operands(stack)
+            stack.pop
+            new
+          end
+        end
+
+        class Index < Operator
+          register_as "index", consumes: 1, produces: 1
+          attr_reader :index
+          def initialize(index:)
+            @index = index
+            freeze
+          end
+          def self.from_operands(stack)
+            new(index: stack.pop_number.to_i)
+          end
+        end
+
+        class Roll < Operator
+          register_as "roll", consumes: 2, produces: 0
+          attr_reader :count, :positions
+          def initialize(count:, positions:)
+            @count = count
+            @positions = positions
+            freeze
+          end
+          def self.from_operands(stack)
+            positions = stack.pop_number.to_i
+            count = stack.pop_number.to_i
+            new(count: count, positions: positions)
+          end
+        end
+
+        class Clear < Operator
+          register_as "clear", consumes: 0, produces: 0
+        end
+
+        class Count < Operator
+          register_as "count", consumes: 0, produces: 1
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/transformations.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Transformations
+        class Translate < Operator
+          register_as "translate"
+          attr_reader :tx, :ty
+          def initialize(tx:, ty:)
+            @tx = tx
+            @ty = ty
+            freeze
+          end
+          def self.from_operands(stack)
+            ty = stack.pop_number
+            tx = stack.pop_number
+            new(tx: tx, ty: ty)
+          end
+        end
+
+        class Scale < Operator
+          register_as "scale"
+          attr_reader :sx, :sy
+          def initialize(sx:, sy:)
+            @sx = sx
+            @sy = sy
+            freeze
+          end
+          def self.from_operands(stack)
+            sy = stack.pop_number
+            sx = stack.pop_number
+            new(sx: sx, sy: sy)
+          end
+        end
+
+        class Rotate < Operator
+          register_as "rotate"
+          attr_reader :angle
+          def initialize(angle:)
+            @angle = angle
+            freeze
+          end
+          def self.from_operands(stack)
+            new(angle: stack.pop_number)
+          end
+        end
+
+        class Concat < Operator
+          register_as "concat"
+          attr_reader :matrix
+          def initialize(matrix:)
+            @matrix = matrix
+            freeze
+          end
+          def self.from_operands(stack)
+            new(matrix: stack.pop)
+          end
+        end
+
+        class Matrix < Operator
+          register_as "matrix"
+        end
+
+        class Currentmatrix < Operator
+          register_as "currentmatrix"
+        end
+
+        class Setmatrix < Operator
+          register_as "setmatrix"
+          attr_reader :matrix
+          def initialize(matrix:)
+            @matrix = matrix
+            freeze
+          end
+          def self.from_operands(stack)
+            new(matrix: stack.pop)
+          end
+        end
+
+        class Transform < Operator
+          register_as "transform"
+          def self.from_operands(stack); end
+        end
+
+        class Dtransform < Operator
+          register_as "dtransform"
+          def self.from_operands(stack); end
+        end
+
+        class Itransform < Operator
+          register_as "itransform"
+          def self.from_operands(stack); end
+        end
+
+        class Idtransform < Operator
+          register_as "idtransform"
+          def self.from_operands(stack); end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    # PS operator catalogue. Each subclass of Model::Operator registers
+    # itself under its keyword. The parser looks keywords up here to
+    # decide which class to instantiate.
+    #
+    # Categories (mirrors PLRM chapter structure):
+    # - Stack, Arithmetic, Boolean, Path, Painting, Color,
+    #   GraphicsState, Transformations, Dictionary, ControlFlow, Device
+    module Operators
+      autoload :Stack, "postsvg/model/operators/stack"
+      autoload :Arithmetic, "postsvg/model/operators/arithmetic"
+      autoload :Boolean, "postsvg/model/operators/boolean"
+      autoload :Path, "postsvg/model/operators/path"
+      autoload :Painting, "postsvg/model/operators/painting"
+      autoload :Color, "postsvg/model/operators/color"
+      autoload :GraphicsState, "postsvg/model/operators/graphics_state"
+      autoload :Transformations, "postsvg/model/operators/transformations"
+      autoload :Dictionary, "postsvg/model/operators/dictionary"
+      autoload :ControlFlow, "postsvg/model/operators/control_flow"
+      autoload :Device, "postsvg/model/operators/device"
+      autoload :Font, "postsvg/model/operators/font"
+      autoload :Container, "postsvg/model/operators/container"
+
+      @registry = {}
+      @visit_names = {}
+
+      class << self
+        # @api private Used by Operator subclasses at load time.
+        def register(keyword, klass)
+          @registry[keyword] = klass
+        end
+
+        # Lookup by PS keyword. Returns nil for unknown keywords.
+        def [](keyword)
+          @registry[keyword]
+        end
+
+        def registered?(keyword)
+          @registry.key?(keyword)
+        end
+
+        def keywords
+          @registry.keys
+        end
+
+        # Force-load every operator category so the registry is fully
+        # populated. Call this once before relying on [+].
+        def load_all!
+          constants.each { |c| const_get(c) }
+        end
+      end
+    end
+
+    # Wrapper for operator tokens with no registered class. Carries
+    # the original keyword so the visitor can emit a comment / warn.
+    class UnknownOperator < Operator
+      attr_reader :keyword
+
+      def initialize(keyword:)
+        @keyword = keyword
+        freeze
+      end
+
+      def visit_name = "unknown"
+
+      def self.from_operands(_stack); end
+    end
+
+    # A bare name reference resolved to a user-defined procedure via
+    # +def+. The renderer descends into +procedure+ with the current
+    # context, mirroring how PostScript executes the procedure body.
+    class InvokeProcedure < Operator
+      attr_reader :name, :procedure
+
+      def initialize(name:, procedure:)
+        @name = name
+        @procedure = procedure
+        freeze
+      end
+
+      def visit_name = "invoke_procedure"
+
+      def keyword = name.to_s
+    end
+  end
+end

data/lib/postsvg/model/program.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    # Top-level program node. Carries DSC header (BoundingBox, Title,
+    # etc.) and the body — an ordered list of statements, each either a
+    # literal (Number/Name/String/Array/Procedure/Dictionary) or an
+    # Operator instance.
+    class Program
+      attr_reader :header, :body
+
+      def initialize(header: Header.new, body: [])
+        @header = header
+        @body = body
+        freeze
+      end
+
+      def with(header: nil, body: nil)
+        Program.new(header: header || @header, body: body || @body)
+      end
+
+      def append(statement)
+        Program.new(header: @header, body: @body + [statement])
+      end
+
+      def concat(statements)
+        Program.new(header: @header, body: @body + statements)
+      end
+
+      # DSC header: structured document structuring comments.
+      class Header
+        attr_reader :bounding_box, :hires_bounding_box, :title, :creator,
+                    :creation_date, :pages, :page_count, :epsf,
+                    :language_level, :custom
+
+        def initialize(bounding_box: nil, hires_bounding_box: nil, title: nil,
+                       creator: nil, creation_date: nil, pages: nil,
+                       page_count: nil, epsf: false, language_level: nil,
+                       custom: {})
+          @bounding_box = bounding_box
+          @hires_bounding_box = hires_bounding_box
+          @title = title
+          @creator = creator
+          @creation_date = creation_date
+          @pages = pages
+          @page_count = page_count
+          @epsf = epsf
+          @language_level = language_level
+          @custom = custom.dup.freeze
+          freeze
+        end
+
+        def with(**overrides)
+          Header.new(**to_h.merge(overrides))
+        end
+
+        def to_h
+          {
+            bounding_box: bounding_box, hires_bounding_box: hires_bounding_box,
+            title: title, creator: creator, creation_date: creation_date,
+            pages: pages, page_count: page_count, epsf: epsf,
+            language_level: language_level, custom: custom,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/token.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    # Lexical token. Type is one of:
+    # +:number+, +:operator+, +:name+, +:string+, +:hexstring+,
+    # +:proc_open+, +:proc_close+, +:array_open+, +:array_close+,
+    # +:dict_open+, +:dict_close+, +:dsc+.
+    #
+    # +literal+ is true when a +:name+ was written with a leading slash
+    # (i.e. it is a literal name, not an operator-style name reference).
+    class Token
+      attr_reader :type, :value, :line, :column, :literal
+
+      def initialize(type, value, line: nil, column: nil, literal: false)
+        @type = type
+        @value = value
+        @line = line
+        @column = column
+        @literal = literal
+        freeze
+      end
+
+      def position
+        [line, column]
+      end
+
+      def ==(other)
+        other.is_a?(Token) &&
+          other.type == @type &&
+          other.value == @value &&
+          other.line == @line &&
+          other.column == @column &&
+          other.literal == @literal
+      end
+      alias eql? ==
+
+      def hash
+        [@type, @value, @line, @column, @literal].hash
+      end
+    end
+  end
+end

data/lib/postsvg/model.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # PS domain model. Every value object that participates in the AST
+  # or in round-trip is a Model::* class. The lexer emits Model::Token;
+  # the parser emits Model::Program; the renderer / serializer consume
+  # Model::Program.
+  module Model
+    autoload :Token, "postsvg/model/token"
+    autoload :Program, "postsvg/model/program"
+    autoload :Literals, "postsvg/model/literals"
+    autoload :Operator, "postsvg/model/operator"
+    autoload :UnknownOperator, "postsvg/model/operator"
+    autoload :InvokeProcedure, "postsvg/model/operator"
+    autoload :Operators, "postsvg/model/operators"
+  end
+end

data/lib/postsvg/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Shared options for both directions. Frozen on construction.
+  class Options
+    attr_reader :eps, :width, :height, :viewbox_override, :verbose, :page_size
+
+    DEFAULT_PAGE_SIZE = [595, 842].freeze # A4 in PostScript points
+
+    def initialize(eps: false, width: nil, height: nil, viewbox_override: nil,
+                   verbose: false, page_size: nil)
+      @eps = eps
+      @width = width
+      @height = height
+      @viewbox_override = viewbox_override
+      @verbose = verbose
+      @page_size = page_size || DEFAULT_PAGE_SIZE
+      freeze
+    end
+
+    def to_h
+      {
+        eps: @eps, width: @width, height: @height,
+        viewbox_override: @viewbox_override, verbose: @verbose,
+        page_size: @page_size,
+      }
+    end
+  end
+end