postsvg 0.2.2 → 0.3.0

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

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