postsvg 0.2.2 → 0.3.0

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

@@ -22,7 +22,7 @@ module Postsvg
       {
         eps: @eps, width: @width, height: @height,
         viewbox_override: @viewbox_override, verbose: @verbose,
-        page_size: @page_size
+        page_size: @page_size,
       }
     end
   end

data/lib/postsvg/parser/postscript_parser.rb

@@ -38,7 +38,7 @@ module Postsvg
         (str("\\") >> any) | (str(")").absent? >> any)
       end
       rule(:string) do
-        str("(") >> string_char.repeat.as(:string) >> str(")")
+        (str("(") >> string_char.repeat.as(:string) >> str(")"))
       end
 
       # Operators and keywords
@@ -49,16 +49,16 @@ module Postsvg
 
       # Arrays
       rule(:array) do
-        str("[") >> whitespace? >>
-          value.repeat.as(:array) >>
-          whitespace? >> str("]")
+        (str("[") >> whitespace? >>
+         value.repeat.as(:array) >>
+         whitespace? >> str("]"))
       end
 
       # Procedures (code blocks in curly braces)
       rule(:procedure) do
-        str("{") >> whitespace? >>
-          statement.repeat.as(:procedure) >>
-          whitespace? >> str("}")
+        (str("{") >> whitespace? >>
+         statement.repeat.as(:procedure) >>
+         whitespace? >> str("}"))
       end
 
       # Values

data/lib/postsvg/renderer.rb

@@ -13,10 +13,7 @@ module Postsvg
     attr_reader :program, :options, :builder, :visitor
 
     def initialize(program, options)
-      unless program.is_a?(Model::Program)
-        raise ArgumentError,
-              "program must be a Model::Program"
-      end
+      raise ArgumentError, "program must be a Model::Program" unless program.is_a?(Model::Program)
 
       @program = program
       @options = options
@@ -28,7 +25,7 @@ module Postsvg
       open_svg
       wrap_y_flip do
         visitor.visit_program(program)
-      rescue Postscript::QuitSignal
+      rescue Postsvg::QuitSignal
         # PS +quit+ ends program execution; suppress and finalize SVG.
       end
       builder.close_svg
@@ -65,8 +62,7 @@ module Postsvg
         [viewbox, width, height]
       else
         width, height = options.page_size
-        ["0 0 #{FormatNumber.call(width)} #{FormatNumber.call(height)}", width,
-         height]
+        ["0 0 #{FormatNumber.call(width)} #{FormatNumber.call(height)}", width, height]
       end
     end