postsvg 0.1.0 → 0.3.0

data/lib/postsvg/model/literals/name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Literals
+      # A PostScript name. +literal:+ distinguishes +/foo+ (literal,
+      # pushed onto the stack) from +foo+ (executable, looked up and
+      # executed).
+      class Name
+        attr_reader :value, :literal
+
+        def initialize(value, literal: false)
+          @value = value.to_s
+          @literal = literal
+          freeze
+        end
+
+        def literal? = literal
+        def executable? = !literal
+
+        def to_s
+          @value
+        end
+
+        def accept(visitor, ctx)
+          visitor.visit_name(self, ctx)
+        end
+
+        def ==(other)
+          other.is_a?(Name) && other.value == value && other.literal == literal
+        end
+        alias eql? ==
+
+        def hash
+          [value, literal].hash
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/literals/number.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Literals
+      # A PostScript numeric literal. Stored as a Ruby Numeric so
+      # arithmetic Just Works; class carries the original source
+      # representation choice (int vs float) when known.
+      class Number
+        attr_reader :value
+
+        def initialize(value)
+          @value = value.is_a?(Numeric) ? value : Float(value)
+          freeze
+        end
+
+        def to_i = value.to_i
+        def to_f = value.to_f
+        def integer? = value.is_a?(Integer)
+
+        def accept(visitor, ctx)
+          visitor.visit_number(self, ctx)
+        end
+
+        def ==(other)
+          other.is_a?(Number) && other.value == value
+        end
+        alias eql? ==
+
+        def hash
+          value.hash
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/literals/procedure.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Literals
+      # Procedure body: +{ ... }+. Carries the inner token stream as a
+      # list of literal/operator nodes. Procedures are not executed by
+      # the parser; the renderer descends into them on InvokeProcedure.
+      class Procedure
+        include Enumerable
+
+        attr_reader :body
+
+        def initialize(body = [])
+          @body = body.freeze
+          freeze
+        end
+
+        def each(&block)
+          @body.each(&block)
+        end
+
+        def length = @body.length
+        def empty? = @body.empty?
+
+        def accept(visitor, ctx)
+          visitor.visit_procedure(self, ctx)
+        end
+
+        def ==(other)
+          other.is_a?(Procedure) && other.body == @body
+        end
+        alias eql? ==
+
+        def hash
+          @body.hash
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/literals/string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Literals
+      # Parenthesized string literal: +(foo bar baz)+.
+      class StringLiteral
+        attr_reader :value
+
+        def initialize(value)
+          @value = value.to_s
+          freeze
+        end
+
+        def accept(visitor, ctx)
+          visitor.visit_string_literal(self, ctx)
+        end
+
+        def ==(other)
+          other.is_a?(StringLiteral) && other.value == value
+        end
+        alias eql? ==
+
+        def hash
+          value.hash
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/literals.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    # PS literal value objects. Each is immutable, has value equality,
+    # and knows how to (a) emit itself to a serializer and (b) be
+    # visited by a renderer. They never carry executable behaviour —
+    # they are data.
+    module Literals
+      autoload :Number, "postsvg/model/literals/number"
+      autoload :Name, "postsvg/model/literals/name"
+      autoload :StringLiteral, "postsvg/model/literals/string"
+      autoload :HexLiteral, "postsvg/model/literals/hex"
+      autoload :ArrayLiteral, "postsvg/model/literals/array"
+      autoload :Procedure, "postsvg/model/literals/procedure"
+      autoload :Dictionary, "postsvg/model/literals/dictionary"
+    end
+  end
+end

data/lib/postsvg/model/operator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    # Common base for every PS operator. Subclasses live under
+    # Model::Operators::* grouped by PLRM chapter.
+    #
+    # Each operator declares:
+    # - +keyword+ (the PS source token, e.g. "moveto")
+    # - typed operand fields via +attr_reader+
+    # - +self.from_operands(stack)+ that pops operands and returns a new
+    #   frozen instance
+    # - +self.visit_name+ (defaults to the keyword)
+    # - +self.consumes+ / +self.produces+ (stack-arity, for parser
+    #   placeholders)
+    #
+    # The visitor calls +operator.accept(visitor, ctx)+ which routes to
+    # +visitor.visit_<visit_name>(operator, ctx)+ via +public_send+.
+    class Operator
+      class << self
+        # Register this class under +keyword+ in the global Registry.
+        # Called at the bottom of each subclass definition.
+        def register_as(keyword, consumes: 0, produces: 0)
+          Operators.register(keyword, self)
+          define_method(:keyword) { keyword }
+          define_method(:visit_name) { keyword }
+          @consumes = consumes
+          @produces = produces
+        end
+
+        attr_reader :consumes, :produces
+
+        # Default: a no-op factory that pops nothing. Subclasses
+        # override to consume operands off the parse stack.
+        def from_operands(_stack)
+          new
+        end
+      end
+
+      def accept(visitor, ctx)
+        visitor.dispatch(:"visit_#{visit_name}", self, ctx)
+      end
+
+      def operator? = true
+    end
+
+    # Sentinel value the parser pushes onto the operand stack when an
+    # operator's runtime result is unknown at parse time (e.g. the
+    # output of +findfont+, +add+, +dup+). Carries no semantic value;
+    # its purpose is to keep the parse-stack shape in sync with the
+    # runtime stack so chained operators parse cleanly.
+    class Computed < ::Struct.new(:operator_keyword, keyword_init: true)
+      def to_s
+        "<computed:#{operator_keyword}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Arithmetic
+        BINARY_DEFAULT = { consumes: 2, produces: 1 }.freeze
+        UNARY_DEFAULT = { consumes: 1, produces: 1 }.freeze
+
+        class Add < Operator
+          register_as "add", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Sub < Operator
+          register_as "sub", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Mul < Operator
+          register_as "mul", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Div < Operator
+          register_as "div", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Idiv < Operator
+          register_as "idiv", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number.to_i
+            a = stack.pop_number.to_i
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Mod < Operator
+          register_as "mod", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number.to_i
+            a = stack.pop_number.to_i
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Neg < Operator
+          register_as "neg", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Abs < Operator
+          register_as "abs", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Ceiling < Operator
+          register_as "ceiling", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Floor < Operator
+          register_as "floor", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Round < Operator
+          register_as "round", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Truncate < Operator
+          register_as "truncate", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Sqrt < Operator
+          register_as "sqrt", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Atan < Operator
+          register_as "atan", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Cos < Operator
+          register_as "cos", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Sin < Operator
+          register_as "sin", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Ln < Operator
+          register_as "ln", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Log < Operator
+          register_as "log", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Exp < Operator
+          register_as "exp", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Boolean
+        # PS boolean literals. They look like operator tokens but
+        # push constant Boolean values. Modeled as zero-arity
+        # operators so the parser/registry handle them naturally.
+        class True < Operator
+          register_as "true", consumes: 0, produces: 1
+        end
+
+        class False < Operator
+          register_as "false", consumes: 0, produces: 1
+        end
+
+        class Eq < Operator
+          register_as "eq"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Ne < Operator
+          register_as "ne"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Gt < Operator
+          register_as "gt"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Ge < Operator
+          register_as "ge"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Lt < Operator
+          register_as "lt"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Le < Operator
+          register_as "le"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class And < Operator
+          register_as "and"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Or < Operator
+          register_as "or"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Xor < Operator
+          register_as "xor"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Not < Operator
+          register_as "not"
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+        end
+
+        class Bitshift < Operator
+          register_as "bitshift"
+          def self.from_operands(stack)
+            shift = stack.pop_number.to_i
+            value = stack.pop_number.to_i
+            new(operand: value, shift: shift)
+          end
+          attr_reader :operand, :shift
+          def initialize(operand:, shift:)
+            @operand = operand
+            @shift = shift
+            freeze
+          end
+        end
+      end
+    end
+  end
+end