postsvg 0.3.0 → 0.3.1

data/lib/postsvg.rb

@@ -1,63 +1,68 @@
 # frozen_string_literal: true
 
+require "postscript"
 require "parslet"
 require "thor"
-require "nokogiri"
+require "leptris"
 
 module Postsvg
   autoload :VERSION, "postsvg/version"
 
-  # Errors
+  # ============================================================
+  # Posts created and managed by the +postscript+ gem.
+  # ============================================================
+  #
+  # `postscript` owns PS source parsing, the typed PS domain model,
+  # and the PS source serializer. The `Postscript` namespace is the
+  # canonical location; the aliases below keep existing user code
+  # working during the transition (deprecated, will be removed at
+  # postsvg 1.0).
+  #
+  # If you maintain postsvg, prefer `Postscript::*` in new code.
+
+  Source       = Postscript::Source
+  Model        = Postscript::Model
+  Serializer   = Postscript::Serializer
+  Matrix       = Postscript::Matrix
+  Color        = Postscript::Color
+  FormatNumber = Postscript::FormatNumber
+
+  ParseError              = Postscript::ParseError
+  LexError                = Postscript::LexError
+  SyntaxError             = Postscript::SyntaxError
+  StackUnderflowError     = Postscript::StackUnderflowError
+  UndefinedOperatorError  = Postscript::UndefinedOperatorError
+  RecursionLimitError     = Postscript::RecursionLimitError
+  RenderError             = Postscript::RenderError
+  SerializeError          = Postscript::SerializeError
+  ExitSignal              = Postscript::ExitSignal
+  QuitSignal              = Postscript::QuitSignal
+
+  # ============================================================
+  # Errors that originate in the SVG side (kept here, not in postscript).
+  # ============================================================
   autoload :Error, "postsvg/errors"
-  autoload :ParseError, "postsvg/errors"
-  autoload :LexError, "postsvg/errors"
-  autoload :SyntaxError, "postsvg/errors"
-  autoload :RenderError, "postsvg/errors"
-  autoload :StackUnderflowError, "postsvg/errors"
-  autoload :UndefinedOperatorError, "postsvg/errors"
-  autoload :RecursionLimitError, "postsvg/errors"
-  autoload :SizeLimitError, "postsvg/errors"
   autoload :TranslationError, "postsvg/errors"
   autoload :UnsupportedElementError, "postsvg/errors"
   autoload :UnresolvedReferenceError, "postsvg/errors"
-  autoload :SerializeError, "postsvg/errors"
-  autoload :ConversionError, "postsvg/errors"
-  autoload :UnsupportedOperatorError, "postsvg/errors"
-  autoload :ExitSignal, "postsvg/errors"
-  autoload :QuitSignal, "postsvg/errors"
 
-  # Foundational value types
-  autoload :FormatNumber, "postsvg/format_number"
-  autoload :Matrix, "postsvg/matrix"
-  autoload :Color, "postsvg/color"
+  # Legacy alias for RenderError (postsvg 0.1 API).
+  ConversionError = RenderError
+  # Legacy alias for UndefinedOperatorError (postsvg 0.1 API).
+  UnsupportedOperatorError = UndefinedOperatorError
 
-  # Source-reading layer (PS source -> Model::Program)
-  autoload :Source, "postsvg/source"
-
-  # PS domain model
-  autoload :Model, "postsvg/model"
-
-  # Graphics state
+  # ============================================================
+  # Rendering / SVG-side types owned by postsvg.
+  # ============================================================
   autoload :GraphicsContext, "postsvg/graphics_context"
   autoload :GraphicsStack, "postsvg/graphics_stack"
   autoload :PathBuilder, "postsvg/path_builder"
-
-  # SVG emission (forward direction)
   autoload :SvgBuilder, "postsvg/svg_builder"
-
-  # Forward direction (PS -> SVG)
   autoload :Options, "postsvg/options"
   autoload :Renderer, "postsvg/renderer"
   autoload :Visitors, "postsvg/visitors"
-
-  # SVG domain model (reverse direction input)
   autoload :Svg, "postsvg/svg"
-
-  # Reverse direction (SVG -> PS)
   autoload :Translation, "postsvg/translation"
-  autoload :Serializer, "postsvg/serializer"
-
-  # CLI
   autoload :CLI, "postsvg/cli"
 
   # Legacy implementations retained on disk for reference. Not on the
@@ -73,7 +78,7 @@ module Postsvg
   class << self
     # PS/EPS source -> SVG string.
     def to_svg(source, **options)
-      program = Source.parse(source)
+      program = Postscript::Source.parse(source)
       Renderer.call(program, Options.new(**options))
     end
 

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: postsvg
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: leptris
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.9.399.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.9.399.0
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: postscript
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -172,55 +186,22 @@ files:
 - docs/troubleshooting.adoc
 - docs/validation.adoc
 - exe/postsvg
+- gemfiles/native-parity/Gemfile
 - lib/postsvg.rb
 - lib/postsvg/cli.rb
-- lib/postsvg/color.rb
 - lib/postsvg/colors.rb
 - lib/postsvg/converter.rb
 - lib/postsvg/errors.rb
-- lib/postsvg/format_number.rb
 - lib/postsvg/graphics_context.rb
 - lib/postsvg/graphics_stack.rb
 - lib/postsvg/graphics_state.rb
 - lib/postsvg/interpreter.rb
-- lib/postsvg/matrix.rb
-- lib/postsvg/model.rb
-- lib/postsvg/model/literals.rb
-- lib/postsvg/model/literals/array.rb
-- lib/postsvg/model/literals/dictionary.rb
-- lib/postsvg/model/literals/hex.rb
-- lib/postsvg/model/literals/name.rb
-- lib/postsvg/model/literals/number.rb
-- lib/postsvg/model/literals/procedure.rb
-- lib/postsvg/model/literals/string.rb
-- lib/postsvg/model/operator.rb
-- lib/postsvg/model/operators.rb
-- lib/postsvg/model/operators/arithmetic.rb
-- lib/postsvg/model/operators/boolean.rb
-- lib/postsvg/model/operators/color.rb
-- lib/postsvg/model/operators/container.rb
-- lib/postsvg/model/operators/control_flow.rb
-- lib/postsvg/model/operators/device.rb
-- lib/postsvg/model/operators/dictionary.rb
-- lib/postsvg/model/operators/font.rb
-- lib/postsvg/model/operators/graphics_state.rb
-- lib/postsvg/model/operators/painting.rb
-- lib/postsvg/model/operators/path.rb
-- lib/postsvg/model/operators/stack.rb
-- lib/postsvg/model/operators/transformations.rb
-- lib/postsvg/model/program.rb
-- lib/postsvg/model/token.rb
 - lib/postsvg/options.rb
 - lib/postsvg/parser.rb
 - lib/postsvg/parser/postscript_parser.rb
 - lib/postsvg/parser/transform.rb
 - lib/postsvg/path_builder.rb
 - lib/postsvg/renderer.rb
-- lib/postsvg/serializer.rb
-- lib/postsvg/source.rb
-- lib/postsvg/source/ast_builder.rb
-- lib/postsvg/source/lexer.rb
-- lib/postsvg/source/operand_stack.rb
 - lib/postsvg/svg.rb
 - lib/postsvg/svg/attribute_parser.rb
 - lib/postsvg/svg/clip_path_registry.rb

data/lib/postsvg/color.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  # Immutable RGB color value object. Use the constructors (+.rgb+,
-  # +.gray+, +.cmyk+, +.parse+) instead of +new+ when constructing from
-  # other color models; they normalize to integer [0, 255] channels.
-  class Color
-    include Comparable
-
-    attr_reader :red, :green, :blue
-
-    def self.clamp_byte(value)
-      Integer === value ? value.clamp(0, 255) : value.to_i.clamp(0, 255)
-    end
-
-    def self.scale_unit_to_byte(value)
-      (value.clamp(0.0, 1.0) * 255.0).round
-    end
-
-    def initialize(red, green, blue)
-      @red = Color.clamp_byte(red)
-      @green = Color.clamp_byte(green)
-      @blue = Color.clamp_byte(blue)
-      freeze
-    end
-
-    # RGB triple in PS-native [0.0, 1.0] floats.
-    def self.rgb(r, g, b)
-      new(scale_unit_to_byte(r), scale_unit_to_byte(g), scale_unit_to_byte(b))
-    end
-
-    # Gray in [0.0, 1.0].
-    def self.gray(level)
-      v = scale_unit_to_byte(level)
-      new(v, v, v)
-    end
-
-    # CMYK in [0.0, 1.0]. Conversion matches PLRM §8.2.4 simplified
-    # formula; not colorimetrically exact.
-    def self.cmyk(c, m, y, k)
-      new(
-        scale_unit_to_byte((1 - c) * (1 - k)),
-        scale_unit_to_byte((1 - m) * (1 - k)),
-        scale_unit_to_byte((1 - y) * (1 - k)),
-      )
-    end
-
-    # Parse CSS / SVG color notations: #rgb, #rrggbb, rgb(r, g, b),
-    # rgb(r g b / a), named colors (X11 subset).
-    def self.parse(text)
-      return text if text.is_a?(Color)
-
-      case text.to_s.downcase
-      when /\A#([0-9a-f]{6})\z/
-        hex = ::Regexp.last_match(1)
-        new(hex[0, 2].to_i(16), hex[2, 2].to_i(16), hex[4, 2].to_i(16))
-      when /\A#([0-9a-f]{3})\z/
-        hex = ::Regexp.last_match(1)
-        new((hex[0] * 2).to_i(16), (hex[1] * 2).to_i(16), (hex[2] * 2).to_i(16))
-      when /\argb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/
-        new(::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i, ::Regexp.last_match(3).to_i)
-      when /\argb\(\s*(\d+)\s+(\d+)\s+(\d+)/
-        new(::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i, ::Regexp.last_match(3).to_i)
-      when "none", "transparent"
-        nil
-      else
-        rgb = NAMED_COLORS[text.to_s]
-        return new(*rgb) if rgb
-
-        raise ArgumentError, "unrecognized color: #{text.inspect}"
-      end
-    end
-
-    def gray?
-      red == green && green == blue
-    end
-
-    def gray_level
-      (red + green + blue) / 765.0
-    end
-
-    def to_rgb_unit
-      [red / 255.0, green / 255.0, blue / 255.0]
-    end
-
-    def to_svg
-      format("#%02x%02x%02x", red, green, blue)
-    end
-
-    def to_ps_rgb
-      to_rgb_unit.map { |c| FormatNumber.call(c) }.join(" ")
-    end
-
-    def to_ps_gray
-      raise ArgumentError, "color is not gray" unless gray?
-
-      FormatNumber.call(gray_level)
-    end
-
-    def <=>(other)
-      return nil unless other.is_a?(Color)
-
-      [red, green, blue] <=> [other.red, other.green, other.blue]
-    end
-
-    def hash
-      [red, green, blue].hash
-    end
-
-    def eql?(other)
-      other.is_a?(Color) && other.red == red && other.green == green && other.blue == blue
-    end
-    alias == eql?
-
-    NAMED_COLORS = {
-      "black" => [0, 0, 0], "white" => [255, 255, 255],
-      "red" => [255, 0, 0], "green" => [0, 128, 0], "blue" => [0, 0, 255],
-      "yellow" => [255, 255, 0], "cyan" => [0, 255, 255],
-      "magenta" => [255, 0, 255], "gray" => [128, 128, 128],
-      "grey" => [128, 128, 128], "silver" => [192, 192, 192],
-      "maroon" => [128, 0, 0], "olive" => [128, 128, 0],
-      "navy" => [0, 0, 128], "purple" => [128, 0, 128],
-      "teal" => [0, 128, 128], "lime" => [0, 255, 0],
-      "aqua" => [0, 255, 255], "fuchsia" => [255, 0, 255],
-      "orange" => [255, 165, 0], "pink" => [255, 192, 203],
-      "brown" => [165, 42, 42],
-    }.freeze
-
-    BLACK = Color.new(0, 0, 0).freeze
-    WHITE = Color.new(255, 255, 255).freeze
-  end
-end

data/lib/postsvg/format_number.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  # Single source of truth for formatting numbers in both directions.
-  #
-  # - Integers print without a trailing ".0".
-  # - Floats print to 4 decimals, trailing zeros stripped.
-  # - -0 normalizes to 0 (so viewBoxes don't read "0 -0 100 100").
-  # - +Inf / -Inf / NaN raise ArgumentError; callers should validate.
-  module FormatNumber
-    module_function
-
-    def call(value)
-      raise ArgumentError, "non-finite number: #{value.inspect}" unless value.finite?
-
-      normalized = value.zero? ? 0.0 : value
-      return normalized.to_i.to_s if normalized == normalized.to_i
-
-      format("%.4f", normalized).sub(/\.?0+$/, "")
-    end
-  end
-end

data/lib/postsvg/matrix.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  # Matrix transformation class for PostScript coordinate transformations
-  # Implements affine transformation matrix [a b c d e f]
-  class Matrix
-    attr_accessor :a, :b, :c, :d, :e, :f
-
-    def initialize(a: 1, b: 0, c: 0, d: 1, e: 0, f: 0)
-      @a = a
-      @b = b
-      @c = c
-      @d = d
-      @e = e
-      @f = f
-    end
-
-    def multiply(matrix)
-      result = Matrix.new
-      result.a = (@a * matrix.a) + (@c * matrix.b)
-      result.b = (@b * matrix.a) + (@d * matrix.b)
-      result.c = (@a * matrix.c) + (@c * matrix.d)
-      result.d = (@b * matrix.c) + (@d * matrix.d)
-      result.e = (@a * matrix.e) + (@c * matrix.f) + @e
-      result.f = (@b * matrix.e) + (@d * matrix.f) + @f
-      result
-    end
-
-    def translate(tx, ty)
-      multiply(Matrix.new(e: tx, f: ty))
-    end
-
-    def scale(sx, sy)
-      multiply(Matrix.new(a: sx, d: sy))
-    end
-
-    def rotate(degrees)
-      radians = degrees * Math::PI / 180.0
-      m = Matrix.new
-      m.a = Math.cos(radians)
-      m.b = Math.sin(radians)
-      m.c = -Math.sin(radians)
-      m.d = Math.cos(radians)
-      multiply(m)
-    end
-
-    def skew_x(angle)
-      radians = angle * Math::PI / 180.0
-      multiply(Matrix.new(c: Math.tan(radians)))
-    end
-
-    def skew_y(angle)
-      radians = angle * Math::PI / 180.0
-      multiply(Matrix.new(b: Math.tan(radians)))
-    end
-
-    def to_transform_string
-      "matrix(#{@a} #{@b} #{@c} #{@d} #{@e} #{@f})"
-    end
-
-    def apply_point(x, y)
-      {
-        x: (x * @a) + (y * @c) + @e,
-        y: (x * @b) + (y * @d) + @f,
-      }
-    end
-
-    def decompose
-      scale_x = Math.hypot(@a, @b)
-      scale_y = ((@a * @d) - (@b * @c)) / scale_x
-
-      rotation = Math.atan2(@b, @a) * (180.0 / Math::PI)
-
-      skew_x = Math.atan2((@a * @c) + (@b * @d), scale_x * scale_x)
-      skew_y = Math.atan2((@a * @b) + (@c * @d), scale_y * scale_y)
-
-      {
-        translate: { x: @e, y: @f },
-        scale: { x: scale_x, y: scale_y },
-        rotate: rotation,
-        skew: {
-          x: skew_x * (180.0 / Math::PI),
-          y: skew_y * (180.0 / Math::PI),
-        },
-      }
-    end
-
-    def invert
-      det = (@a * @d) - (@b * @c)
-      return Matrix.new if det.abs < 1e-10
-
-      inv = Matrix.new
-      inv.a = @d / det
-      inv.b = -@b / det
-      inv.c = -@c / det
-      inv.d = @a / det
-      inv.e = ((@c * @f) - (@d * @e)) / det
-      inv.f = ((@b * @e) - (@a * @f)) / det
-      inv
-    end
-
-    def identity?
-      @a == 1 && @b.zero? && @c.zero? && @d == 1 && @e.zero? && @f.zero?
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  module Model
-    module Literals
-      # Bracketed array literal: +[1 2 3]+. Elements may be any
-      # literal or operator.
-      class ArrayLiteral
-        include Enumerable
-
-        attr_reader :elements
-
-        def initialize(elements = [])
-          @elements = elements.freeze
-          freeze
-        end
-
-        def each(&block)
-          @elements.each(&block)
-        end
-
-        def length = @elements.length
-        def empty? = @elements.empty?
-        def [](idx) = @elements[idx]
-
-        def accept(visitor, ctx)
-          visitor.visit_array(self, ctx)
-        end
-
-        def ==(other)
-          other.is_a?(ArrayLiteral) && other.elements == @elements
-        end
-        alias eql? ==
-
-        def hash
-          @elements.hash
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  module Model
-    module Literals
-      # Inline dictionary literal: +<< /Key (value) /Num 42 >>+.
-      class Dictionary
-        attr_reader :entries
-
-        def initialize(entries = {})
-          @entries = entries.dup.freeze
-          freeze
-        end
-
-        def [](key) = @entries[key]
-        def key?(key) = @entries.key?(key)
-        def each(&block) = @entries.each(&block)
-
-        def accept(visitor, ctx)
-          visitor.visit_dictionary(self, ctx)
-        end
-
-        def ==(other)
-          other.is_a?(Dictionary) && other.entries == @entries
-        end
-        alias eql? ==
-
-        def hash
-          @entries.hash
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Postsvg
-  module Model
-    module Literals
-      # Hex-string literal: +<DEADBEEF>+.
-      class HexLiteral
-        attr_reader :value
-
-        def initialize(value)
-          @value = value.to_s
-          freeze
-        end
-
-        # Raw bytes encoded by the hex literal.
-        def bytes
-          hex = value.delete("^0-9a-fA-F")
-          hex << "0" if hex.length.odd?
-          hex.chars.each_slice(2).map { |pair| pair.join.to_i(16) }.pack("C*")
-        end
-
-        def accept(visitor, ctx)
-          visitor.visit_hex(self, ctx)
-        end
-
-        def ==(other)
-          other.is_a?(HexLiteral) && other.value == value
-        end
-        alias eql? ==
-
-        def hash
-          value.hash
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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