postsvg 0.2.2 → 0.3.0

data/lib/postsvg/cli.rb

@@ -8,8 +8,7 @@ module Postsvg
   class CLI < Thor
     package_name "postsvg"
 
-    desc "convert INPUT [OUTPUT]",
-         "Convert PostScript/EPS file to SVG (legacy alias for to-svg)"
+    desc "convert INPUT [OUTPUT]", "Convert PostScript/EPS file to SVG (legacy alias for to-svg)"
     long_desc <<~DESC
       Convert a PostScript (.ps) or Encapsulated PostScript (.eps) file to SVG.
 
@@ -21,8 +20,7 @@ module Postsvg
         $ postsvg convert input.eps > output.svg
     DESC
     def convert(input_path, output_path = nil)
-      handle_input(input_path, output_path, method(:read_ps_to_svg),
-                   direction: "PS/EPS -> SVG")
+      handle_input(input_path, output_path, method(:read_ps_to_svg), direction: "PS/EPS -> SVG")
     end
 
     desc "to-svg INPUT [OUTPUT]", "Convert PostScript/EPS to SVG"
@@ -44,8 +42,7 @@ module Postsvg
         $ postsvg to-ps input.svg > output.ps
     DESC
     def to_ps(input_path, output_path = nil)
-      handle_input(input_path, output_path, method(:read_svg_to_ps),
-                   direction: "SVG -> PS")
+      handle_input(input_path, output_path, method(:read_svg_to_ps), direction: "SVG -> PS")
     end
 
     desc "to-eps INPUT [OUTPUT]", "Convert SVG to Encapsulated PostScript"
@@ -54,12 +51,10 @@ module Postsvg
       suitable for embedding.
     DESC
     def to_eps(input_path, output_path = nil)
-      handle_input(input_path, output_path, method(:read_svg_to_eps),
-                   direction: "SVG -> EPS")
+      handle_input(input_path, output_path, method(:read_svg_to_eps), direction: "SVG -> EPS")
     end
 
-    desc "batch INPUT_DIR [OUTPUT_DIR]",
-         "Convert all PS/EPS/SVG files in a directory"
+    desc "batch INPUT_DIR [OUTPUT_DIR]", "Convert all PS/EPS/SVG files in a directory"
     long_desc <<~DESC
       Auto-detects direction by file extension:
 

data/lib/postsvg/color.rb

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

@@ -0,0 +1,22 @@
+# 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/graphics_context.rb

@@ -60,8 +60,7 @@ module Postsvg
         font_name: overrides.fetch(:font_name, @font_name),
         font_size: overrides.fetch(:font_size, @font_size),
         clip_paths: overrides.fetch(:clip_paths, @clip_paths),
-        last_text_position: overrides.fetch(:last_text_position,
-                                            @last_text_position),
+        last_text_position: overrides.fetch(:last_text_position, @last_text_position),
         fill_rule: overrides.fetch(:fill_rule, @fill_rule),
       )
     end

data/lib/postsvg/matrix.rb

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

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

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

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

@@ -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