postsvg 0.1.0 → 0.3.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Color
+        class Setgray < Operator
+          register_as "setgray"
+          attr_reader :gray
+          def initialize(gray:)
+            @gray = gray
+            freeze
+          end
+          def self.from_operands(stack)
+            new(gray: stack.pop_number)
+          end
+        end
+
+        class Setrgbcolor < Operator
+          register_as "setrgbcolor"
+          attr_reader :red, :green, :blue
+          def initialize(red:, green:, blue:)
+            @red = red
+            @green = green
+            @blue = blue
+            freeze
+          end
+          def self.from_operands(stack)
+            blue = stack.pop_number
+            green = stack.pop_number
+            red = stack.pop_number
+            new(red: red, green: green, blue: blue)
+          end
+        end
+
+        class Setcmykcolor < Operator
+          register_as "setcmykcolor"
+          attr_reader :cyan, :magenta, :yellow, :key
+          def initialize(cyan:, magenta:, yellow:, key:)
+            @cyan = cyan
+            @magenta = magenta
+            @yellow = yellow
+            @key = key
+            freeze
+          end
+          def self.from_operands(stack)
+            key = stack.pop_number
+            yellow = stack.pop_number
+            magenta = stack.pop_number
+            cyan = stack.pop_number
+            new(cyan: cyan, magenta: magenta, yellow: yellow, key: key)
+          end
+        end
+
+        class Sethsbcolor < Operator
+          register_as "sethsbcolor"
+          attr_reader :hue, :saturation, :brightness
+          def initialize(hue:, saturation:, brightness:)
+            @hue = hue
+            @saturation = saturation
+            @brightness = brightness
+            freeze
+          end
+          def self.from_operands(stack)
+            brightness = stack.pop_number
+            saturation = stack.pop_number
+            hue = stack.pop_number
+            new(hue: hue, saturation: saturation, brightness: brightness)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Container
+        class Length < Operator
+          register_as "length", consumes: 1, produces: 1
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+        end
+
+        class Get < Operator
+          register_as "get", consumes: 2, produces: 1
+          attr_reader :operand, :key
+          def initialize(operand:, key:)
+            @operand = operand
+            @key = key
+            freeze
+          end
+          def self.from_operands(stack)
+            key = stack.pop
+            coll = stack.pop
+            new(operand: coll, key: key)
+          end
+        end
+
+        class Put < Operator
+          register_as "put", consumes: 3, produces: 0
+          attr_reader :operand, :key, :value
+          def initialize(operand:, key:, value:)
+            @operand = operand
+            @key = key
+            @value = value
+            freeze
+          end
+          def self.from_operands(stack)
+            value = stack.pop
+            key = stack.pop
+            coll = stack.pop
+            new(operand: coll, key: key, value: value)
+          end
+        end
+
+        class Getinterval < Operator
+          register_as "getinterval", consumes: 3, produces: 1
+          attr_reader :operand, :start, :count
+          def initialize(operand:, start:, count:)
+            @operand = operand
+            @start = start
+            @count = count
+            freeze
+          end
+          def self.from_operands(stack)
+            count = stack.pop_number.to_i
+            start = stack.pop_number.to_i
+            coll = stack.pop
+            new(operand: coll, start: start, count: count)
+          end
+        end
+
+        class Putinterval < Operator
+          register_as "putinterval", consumes: 3, produces: 0
+          attr_reader :operand, :start, :source
+          def initialize(operand:, start:, source:)
+            @operand = operand
+            @start = start
+            @source = source
+            freeze
+          end
+          def self.from_operands(stack)
+            source = stack.pop
+            start = stack.pop_number.to_i
+            coll = stack.pop
+            new(operand: coll, start: start, source: source)
+          end
+        end
+
+        class Forall < Operator
+          register_as "forall", consumes: 2, produces: 0
+          attr_reader :collection, :body
+          def initialize(collection:, body:)
+            @collection = collection
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            body = stack.pop
+            coll = stack.pop
+            new(collection: coll, body: body)
+          end
+        end
+
+        class Astore < Operator
+          register_as "astore", consumes: 1, produces: 1
+          attr_reader :array, :length
+          def initialize(array:, length:)
+            @array = array
+            @length = length
+            freeze
+          end
+          def self.from_operands(stack)
+            arr = stack.pop
+            length = stack.pop_number.to_i
+            new(array: arr, length: length)
+          end
+        end
+
+        class Search < Operator
+          register_as "search", consumes: 2, produces: 1
+          attr_reader :target, :pattern
+          def initialize(target:, pattern:)
+            @target = target
+            @pattern = pattern
+            freeze
+          end
+          def self.from_operands(stack)
+            pattern = stack.pop
+            target = stack.pop
+            new(target: target, pattern: pattern)
+          end
+        end
+
+        class Anchorsearch < Operator
+          register_as "anchorsearch", consumes: 2, produces: 1
+          attr_reader :target, :pattern
+          def initialize(target:, pattern:)
+            @target = target
+            @pattern = pattern
+            freeze
+          end
+          def self.from_operands(stack)
+            pattern = stack.pop
+            target = stack.pop
+            new(target: target, pattern: pattern)
+          end
+        end
+
+        class Token < Operator
+          register_as "token", consumes: 1, produces: 1
+          attr_reader :target
+          def initialize(target:)
+            @target = target
+            freeze
+          end
+          def self.from_operands(stack)
+            new(target: stack.pop)
+          end
+        end
+
+        class String < Operator
+          register_as "string", consumes: 1, produces: 1
+          attr_reader :count
+          def initialize(count:)
+            @count = count
+            freeze
+          end
+          def self.from_operands(stack)
+            new(count: stack.pop_number.to_i)
+          end
+        end
+
+        class Cvs < Operator
+          register_as "cvs", consumes: 2, produces: 1
+          attr_reader :value, :target
+          def initialize(value:, target:)
+            @value = value
+            @target = target
+            freeze
+          end
+          def self.from_operands(stack)
+            target = stack.pop
+            value = stack.pop
+            new(value: value, target: target)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module ControlFlow
+        class If < Operator
+          register_as "if"
+          attr_reader :condition, :body
+          def initialize(condition:, body:)
+            @condition = condition
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            body = stack.pop
+            condition = stack.pop
+            new(condition: condition, body: body)
+          end
+        end
+
+        class Ifelse < Operator
+          register_as "ifelse"
+          attr_reader :condition, :if_body, :else_body
+          def initialize(condition:, if_body:, else_body:)
+            @condition = condition
+            @if_body = if_body
+            @else_body = else_body
+            freeze
+          end
+          def self.from_operands(stack)
+            else_body = stack.pop
+            if_body = stack.pop
+            condition = stack.pop
+            new(condition: condition, if_body: if_body, else_body: else_body)
+          end
+        end
+
+        class Repeat < Operator
+          register_as "repeat"
+          attr_reader :count, :body
+          def initialize(count:, body:)
+            @count = count
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            body = stack.pop
+            count = stack.pop_number.to_i
+            new(count: count, body: body)
+          end
+        end
+
+        class Loop < Operator
+          register_as "loop"
+          attr_reader :body
+          def initialize(body:)
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            new(body: stack.pop)
+          end
+        end
+
+        class For < Operator
+          register_as "for"
+          attr_reader :initial, :increment, :limit, :body
+          def initialize(initial:, increment:, limit:, body:)
+            @initial = initial
+            @increment = increment
+            @limit = limit
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            body = stack.pop
+            limit = stack.pop_number
+            increment = stack.pop_number
+            initial = stack.pop_number
+            new(initial: initial, increment: increment, limit: limit, body: body)
+          end
+        end
+
+        class Exit < Operator
+          register_as "exit"
+        end
+
+        class Quit < Operator
+          register_as "quit"
+        end
+
+        class Exec < Operator
+          register_as "exec"
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+        end
+
+        class Stopped < Operator
+          register_as "stopped"
+          attr_reader :body
+          def initialize(body:)
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            new(body: stack.pop)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Device
+        class Showpage < Operator
+          register_as "showpage"
+        end
+
+        class Copypage < Operator
+          register_as "copypage"
+        end
+
+        class Nulldevice < Operator
+          register_as "nulldevice"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      # Dictionary-specific operators. Note that +get+, +put+,
+      # +length+, +getinterval+, +putinterval+ live in the +Container+
+      # module because they dispatch on operand type (string, array,
+      # or dictionary) at runtime.
+      module Dictionary
+        class Dict < Operator
+          register_as "dict", consumes: 1, produces: 1
+          def self.from_operands(stack)
+            stack.pop
+            new
+          end
+        end
+
+        class Begin < Operator
+          register_as "begin", consumes: 1, produces: 0
+          def self.from_operands(stack)
+            stack.pop
+            new
+          end
+        end
+
+        class End < Operator
+          register_as "end", consumes: 0, produces: 0
+        end
+
+        class Def < Operator
+          register_as "def", consumes: 2, produces: 0
+          attr_reader :key, :value
+          def initialize(key:, value:)
+            @key = key
+            @value = value
+            freeze
+          end
+          def self.from_operands(stack)
+            value = stack.pop
+            key = stack.pop
+            new(key: key, value: value)
+          end
+        end
+
+        class Load < Operator
+          register_as "load", consumes: 1, produces: 1
+          attr_reader :key
+          def initialize(key:)
+            @key = key
+            freeze
+          end
+          def self.from_operands(stack)
+            new(key: stack.pop)
+          end
+        end
+
+        class Store < Operator
+          register_as "store", consumes: 2, produces: 0
+          attr_reader :key, :value
+          def initialize(key:, value:)
+            @key = key
+            @value = value
+            freeze
+          end
+          def self.from_operands(stack)
+            value = stack.pop
+            key = stack.pop
+            new(key: key, value: value)
+          end
+        end
+
+        class Known < Operator
+          register_as "known", consumes: 2, produces: 1
+          def self.from_operands(stack)
+            key = stack.pop
+            dict = stack.pop
+            new(key: key, dict: dict)
+          end
+          attr_reader :key, :dict
+          def initialize(key:, dict:)
+            @key = key
+            @dict = dict
+            freeze
+          end
+        end
+
+        class Currentdict < Operator
+          register_as "currentdict", consumes: 0, produces: 1
+        end
+
+        class Countdictstack < Operator
+          register_as "countdictstack", consumes: 0, produces: 1
+        end
+
+        class Dictstack < Operator
+          register_as "dictstack", consumes: 1, produces: 1
+          def self.from_operands(stack)
+            stack.pop
+            new
+          end
+        end
+
+        class Maxlength < Operator
+          register_as "maxlength", consumes: 1, produces: 1
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      # Font and text operators. These cover the subset of PLRM §5
+      # needed to round-trip basic SVG `<text>` content; richer
+      # font metrics (kerning, ligatures, glyph substitution) are
+      # tracked in TODO.roadmap/20-font-and-text.md.
+      module Font
+        # Pushes a font dictionary onto the stack by name. +name+ is
+        # the PostScript font name (e.g. "Helvetica"). The visitor
+        # pushes a Font value object.
+        class Findfont < Operator
+          register_as "findfont", consumes: 1, produces: 1
+          attr_reader :name
+          def initialize(name:)
+            @name = name
+            freeze
+          end
+          def self.from_operands(stack)
+            new(name: stack.pop)
+          end
+        end
+
+        # Returns a new font dictionary scaled to the given size.
+        class Scalefont < Operator
+          register_as "scalefont", consumes: 2, produces: 1
+          attr_reader :font, :size
+          def initialize(font:, size:)
+            @font = font
+            @size = size
+            freeze
+          end
+          def self.from_operands(stack)
+            size = stack.pop_number
+            font = stack.pop
+            new(font: font, size: size)
+          end
+        end
+
+        # Installs the font dictionary as the current font.
+        class Setfont < Operator
+          register_as "setfont", consumes: 1, produces: 0
+          attr_reader :font
+          def initialize(font:)
+            @font = font
+            freeze
+          end
+          def self.from_operands(stack)
+            new(font: stack.pop)
+          end
+        end
+
+        # Renders +text+ at the current point using the current font.
+        class Show < Operator
+          register_as "show", consumes: 1, produces: 0
+          attr_reader :text
+          def initialize(text:)
+            @text = text
+            freeze
+          end
+          def self.from_operands(stack)
+            new(text: stack.pop)
+          end
+        end
+
+        # Moves to (x, y) and renders +text+ (PLRM §5.5 xyshow
+        # variant not implemented here).
+        class Xyshow < Operator
+          register_as "xyshow"
+          attr_reader :text, :dx, :dy
+          def initialize(text:, dx:, dy:)
+            @text = text
+            @dx = dx
+            @dy = dy
+            freeze
+          end
+          def self.from_operands(stack)
+            dy = stack.pop
+            dx = stack.pop
+            text = stack.pop
+            new(text: text, dx: dx, dy: dy)
+          end
+        end
+
+        # Returns the width of +text+ under the current font (in
+        # thousandths of a unit, divided by 1000). The visitor
+        # pushes [x, y] onto the stack.
+        class Stringwidth < Operator
+          register_as "stringwidth"
+          attr_reader :text
+          def initialize(text:)
+            @text = text
+            freeze
+          end
+          def self.from_operands(stack)
+            new(text: stack.pop)
+          end
+        end
+
+        # Appends glyph outlines for +text+ to the current path
+        # (PLRM charpath).
+        class Charpath < Operator
+          register_as "charpath"
+          attr_reader :text, :stroke
+          def initialize(text:, stroke:)
+            @text = text
+            @stroke = stroke
+            freeze
+          end
+          def self.from_operands(stack)
+            stroke = stack.pop
+            text = stack.pop
+            new(text: text, stroke: stroke)
+          end
+        end
+      end
+    end
+  end
+end