postsvg 0.1.0

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/parser/postscript_parser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Postsvg
+  class Parser
+    # Parslet-based PostScript parser
+    class PostscriptParser < Parslet::Parser
+      # Whitespace and comments
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+      rule(:comment) do
+        str("%") >> (str("\n").absent? >> any).repeat >> str("\n").maybe
+      end
+      rule(:whitespace) { (space | comment).repeat }
+      rule(:whitespace?) { whitespace.maybe }
+
+      # Numbers
+      rule(:sign) { match("[+-]") }
+      rule(:digit) { match("[0-9]") }
+      rule(:integer) do
+        (sign.maybe >> digit.repeat(1)).as(:integer)
+      end
+      rule(:float) do
+        (sign.maybe >> digit.repeat(1) >> str(".") >> digit.repeat(1)).as(:float) |
+          (sign.maybe >> str(".") >> digit.repeat(1)).as(:float)
+      end
+      rule(:number) { float | integer }
+
+      # Names (identifiers starting with /)
+      rule(:name_char) { match('[a-zA-Z0-9_\-.]') }
+      rule(:name) do
+        (str("/") >> name_char.repeat(1)).as(:name)
+      end
+
+      # Strings (in parentheses, handling escaped characters)
+      rule(:string_char) do
+        (str("\\") >> any) | (str(")").absent? >> any)
+      end
+      rule(:string) do
+        (str("(") >> string_char.repeat.as(:string) >> str(")"))
+      end
+
+      # Operators and keywords
+      rule(:operator_char) { match("[a-zA-Z0-9]") }
+      rule(:operator) do
+        operator_char.repeat(1).as(:operator)
+      end
+
+      # Arrays
+      rule(:array) do
+        (str("[") >> whitespace? >>
+         value.repeat.as(:array) >>
+         whitespace? >> str("]"))
+      end
+
+      # Procedures (code blocks in curly braces)
+      rule(:procedure) do
+        (str("{") >> whitespace? >>
+         statement.repeat.as(:procedure) >>
+         whitespace? >> str("}"))
+      end
+
+      # Values
+      rule(:value) do
+        whitespace? >> (
+          procedure |
+          array |
+          string |
+          name |
+          number |
+          operator
+        ) >> whitespace?
+      end
+
+      # Statements
+      rule(:statement) { value }
+
+      # Root rule - a PostScript program is a sequence of statements
+      rule(:program) do
+        whitespace? >> statement.repeat.as(:program) >> whitespace?
+      end
+
+      root(:program)
+    end
+  end
+end

data/lib/postsvg/parser/transform.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Postsvg
+  class Parser
+    # Transforms parsed PostScript AST into Ruby data structures
+    class Transform < Parslet::Transform
+      rule(integer: simple(:i)) { i.to_i }
+      rule(float: simple(:f)) { f.to_f }
+      rule(string: simple(:s)) { s.to_s }
+      rule(name: simple(:n)) { { type: :name, value: n.to_s.sub(%r{^/}, "") } }
+      rule(operator: simple(:o)) { { type: :operator, value: o.to_s } }
+      rule(array: sequence(:items)) { { type: :array, value: items } }
+      rule(procedure: subtree(:items)) { { type: :procedure, value: items } }
+      rule(program: subtree(:statements)) do
+        { type: :program, statements: statements }
+      end
+    end
+  end
+end

data/lib/postsvg/parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "parser/postscript_parser"
+require_relative "parser/transform"
+
+module Postsvg
+  # Main parser interface for PostScript/EPS files
+  class Parser
+    def self.parse(ps_content)
+      parser = PostscriptParser.new
+      tree = parser.parse(ps_content)
+      Transform.new.apply(tree)
+    rescue Parslet::ParseFailed => e
+      raise ParseError, "Failed to parse PostScript: #{e.message}"
+    end
+  end
+end

data/lib/postsvg/path_builder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "matrix"
+
+module Postsvg
+  # Builds SVG path strings with optional coordinate transformations
+  class PathBuilder
+    attr_reader :parts
+
+    def initialize
+      @parts = []
+      @use_local_coords = false
+      @ctm = nil
+    end
+
+    def set_transform_mode(use_local, transform = nil)
+      @use_local_coords = use_local
+      @ctm = transform
+    end
+
+    def move_to(x, y)
+      p = transform_point(x, y)
+      @parts << "M #{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def move_to_rel(dx, dy)
+      p = transform_point(dx, dy)
+      @parts << "m #{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def line_to(x, y)
+      p = transform_point(x, y)
+      @parts << "L #{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def line_to_rel(dx, dy)
+      p = transform_point(dx, dy)
+      @parts << "l #{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def curve_to(x1, y1, x2, y2, x, y)
+      p1 = transform_point(x1, y1)
+      p2 = transform_point(x2, y2)
+      p = transform_point(x, y)
+      @parts << "C #{num_fmt(p1[:x])} #{num_fmt(p1[:y])} " \
+                "#{num_fmt(p2[:x])} #{num_fmt(p2[:y])} " \
+                "#{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def curve_to_rel(dx1, dy1, dx2, dy2, dx, dy)
+      p1 = transform_point(dx1, dy1)
+      p2 = transform_point(dx2, dy2)
+      p = transform_point(dx, dy)
+      @parts << "c #{num_fmt(p1[:x])} #{num_fmt(p1[:y])} " \
+                "#{num_fmt(p2[:x])} #{num_fmt(p2[:y])} " \
+                "#{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def ellipse_to(rx, ry, rotation, large_arc, sweep, x, y)
+      p = transform_point(x, y)
+      @parts << "A #{num_fmt(rx)} #{num_fmt(ry)} #{num_fmt(rotation)} " \
+                "#{large_arc} #{sweep} #{num_fmt(p[:x])} #{num_fmt(p[:y])}"
+    end
+
+    def close
+      @parts << "Z"
+    end
+
+    def to_path
+      @parts.join(" ")
+    end
+
+    def length
+      @parts.length
+    end
+
+    def clear
+      @parts = []
+    end
+
+    def reset
+      new_path = PathBuilder.new
+      new_path.set_transform_mode(@use_local_coords, @ctm)
+      new_path
+    end
+
+    private
+
+    def transform_point(x, y)
+      if !@use_local_coords && @ctm
+        @ctm.apply_point(x, y)
+      else
+        { x: x, y: y }
+      end
+    end
+
+    def num_fmt(n)
+      format("%.3f", n).sub(/\.?0+$/, "")
+    end
+  end
+end

data/lib/postsvg/svg_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Generates SVG output from PostScript graphics operations
+  class SvgGenerator
+    def initialize
+      @paths = []
+    end
+
+    def add_path(path, graphics_state, operation)
+      return if path.empty?
+
+      svg_path = {
+        d: build_path_data(path),
+        operation: operation,
+        stroke: graphics_state.stroke_color_hex,
+        fill: graphics_state.fill_color_hex,
+        stroke_width: graphics_state.line_width,
+      }
+
+      @paths << svg_path
+    end
+
+    def generate(width:, height:, viewbox:)
+      svg_parts = []
+      svg_parts << '<?xml version="1.0" encoding="UTF-8"?>'
+      svg_parts << %(<svg xmlns="http://www.w3.org/2000/svg" )
+      svg_parts << %(width="#{width}" height="#{height}" )
+      svg_parts << %(viewBox="#{viewbox}">)
+
+      @paths.each do |path|
+        svg_parts << build_path_element(path)
+      end
+
+      svg_parts << "</svg>"
+      svg_parts.join("\n")
+    end
+
+    private
+
+    def build_path_data(path)
+      path_commands = []
+
+      path.each do |segment|
+        case segment[:type]
+        when :moveto
+          path_commands << "M #{segment[:x]} #{segment[:y]}"
+        when :lineto
+          path_commands << "L #{segment[:x]} #{segment[:y]}"
+        when :curveto
+          path_commands << "C #{segment[:x1]} #{segment[:y1]}, " \
+                           "#{segment[:x2]} #{segment[:y2]}, " \
+                           "#{segment[:x3]} #{segment[:y3]}"
+        when :closepath
+          path_commands << "Z"
+        end
+      end
+
+      path_commands.join(" ")
+    end
+
+    def build_path_element(path)
+      attrs = [%(d="#{path[:d]}")]
+
+      case path[:operation]
+      when :stroke
+        attrs << %(fill="none")
+        attrs << %(stroke="#{path[:stroke]}")
+        attrs << %(stroke-width="#{path[:stroke_width]}")
+      when :fill
+        attrs << %(fill="#{path[:fill]}")
+        attrs << %(stroke="none")
+      end
+
+      %(<path #{attrs.join(' ')} />)
+    end
+  end
+end

data/lib/postsvg/tokenizer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Token structure
+  Token = Struct.new(:type, :value, keyword_init: true)
+
+  # Tokenizes PostScript code into tokens
+  class Tokenizer
+    def self.tokenize(ps_code)
+      # Remove comments
+      ps = ps_code.gsub(/%[^\n\r]*/, " ")
+
+      tokens = []
+      index = 0
+
+      while index < ps.length
+        # Skip whitespace
+        index += 1 while index < ps.length && ps[index].match?(/\s/)
+        break if index >= ps.length
+
+        # Try to match different token types
+        token, new_index = match_token(ps, index)
+        if token
+          tokens << token
+          index = new_index
+        else
+          # Skip invalid character
+          index += 1
+        end
+      end
+
+      tokens
+    end
+
+    def self.match_token(ps, index)
+      # String: (foo) or (a\)b)
+      return match_string(ps, index) if ps[index] == "("
+
+      # Number: 12 .2 3e4
+      if (match = ps[index..].match(/\A-?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][+-]?\d+)?/))
+        return [Token.new(type: "number", value: match[0]),
+                index + match[0].length]
+      end
+
+      # Braces: { }
+      return [Token.new(type: "brace", value: ps[index]), index + 1] if ["{",
+                                                                         "}"].include?(ps[index])
+
+      # Brackets: [ ]
+      return [Token.new(type: "bracket", value: ps[index]), index + 1] if ["[",
+                                                                           "]"].include?(ps[index])
+
+      # Dict markers: << >>
+      return [Token.new(type: "dict", value: ps[index, 2]), index + 2] if [
+        "<<", ">>"
+      ].include?(ps[index, 2])
+
+      # Hex strings: <...>
+      if ps[index] == "<" && ps[index + 1] != "<"
+        return match_hex_string(ps,
+                                index)
+      end
+
+      # Names/Operators: /foo or foo
+      if (match = ps[index..].match(%r{\A/?[A-Za-z_\-.?*][A-Za-z0-9_\-.?*]*}))
+        value = match[0]
+        if value.start_with?("/")
+          return [Token.new(type: "name", value: value[1..]),
+                  index + value.length]
+        end
+
+        return [Token.new(type: "operator", value: value), index + value.length]
+
+      end
+
+      nil
+    end
+
+    def self.match_string(ps, index)
+      result = +""
+      i = index + 1 # Skip opening (
+      depth = 1
+
+      while i < ps.length && depth.positive?
+        case ps[i]
+        when "\\"
+          # Escape sequence
+          i += 1
+          break if i >= ps.length
+
+          case ps[i]
+          when "n" then result << "\n"
+          when "r" then result << "\r"
+          when "t" then result << "\t"
+          when "b" then result << "\b"
+          when "f" then result << "\f"
+          when "(" then result << "("
+          when ")" then result << ")"
+          when "\\" then result << "\\"
+          when " " then result << " "
+          else
+            # Octal: \ddd
+            if ps[i].between?("0", "7")
+              octal = ps[i]
+              i += 1
+              if i < ps.length && ps[i] >= "0" && ps[i] <= "7"
+                octal += ps[i]
+                i += 1
+                if i < ps.length && ps[i] >= "0" && ps[i] <= "7"
+                  octal += ps[i]
+                  i += 1
+                end
+              end
+              code = octal.to_i(8)
+              code = 255 if code > 255
+              result << code.chr
+              i -= 1 # Will be incremented at end of loop
+            else
+              result << ps[i]
+            end
+          end
+        when "("
+          depth += 1
+          result << ps[i]
+        when ")"
+          depth -= 1
+          if depth.zero?
+            return [Token.new(type: "string", value: result),
+                    i + 1]
+          end
+
+          result << ps[i]
+        else
+          result << ps[i]
+        end
+        i += 1
+      end
+
+      [Token.new(type: "string", value: result), i]
+    end
+
+    def self.match_hex_string(ps, index)
+      i = index + 1
+      hex_content = +""
+
+      while i < ps.length && ps[i] != ">"
+        hex_content << ps[i] unless ps[i].match?(/\s/)
+        i += 1
+      end
+
+      # Convert hex to string
+      str = +""
+      (0...hex_content.length).step(2) do |j|
+        byte = hex_content[j, 2]
+        str << byte.to_i(16).chr
+      end
+
+      [Token.new(type: "hexstring", value: str), i + 1]
+    end
+  end
+end

data/lib/postsvg/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Postsvg
+  VERSION = "0.1.0"
+end

data/lib/postsvg.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "postsvg/version"
+require_relative "postsvg/errors"
+require_relative "postsvg/tokenizer"
+require_relative "postsvg/interpreter"
+
+module Postsvg
+  class << self
+    # Convert PostScript content to SVG
+    def convert(ps_content)
+      bbox = extract_bounding_box(ps_content)
+      tokens = Tokenizer.tokenize(ps_content)
+
+      interpreter = Interpreter.new
+      svg_out = interpreter.interpret(tokens, bbox)
+
+      generate_svg(svg_out, bbox)
+    end
+
+    # Convert PostScript file to SVG
+    def convert_file(input_path, output_path = nil)
+      ps_content = File.read(input_path)
+      svg_content = convert(ps_content)
+
+      File.write(output_path, svg_content) if output_path
+
+      svg_content
+    end
+
+    private
+
+    def extract_bounding_box(ps_content)
+      match = ps_content.match(/%%BoundingBox:\s*([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)/)
+      return nil unless match
+
+      {
+        llx: match[1].to_f,
+        lly: match[2].to_f,
+        urx: match[3].to_f,
+        ury: match[4].to_f,
+      }
+    end
+
+    def generate_svg(svg_out, bbox)
+      if bbox
+        width = bbox[:urx] - bbox[:llx]
+        height = bbox[:ury] - bbox[:lly]
+        view_box = "viewBox=\"#{num_fmt(bbox[:llx])} #{num_fmt(bbox[:lly])} #{num_fmt(width)} #{num_fmt(height)}\" " \
+                   "width=\"#{num_fmt(width)}\" height=\"#{num_fmt(height)}\""
+      else
+        width = 1920
+        height = 1080
+        view_box = "viewBox=\"0 0 #{width} #{height}\" width=\"#{width}\" height=\"#{height}\""
+      end
+
+      defs = svg_out[:defs].empty? ? "" : "<defs>\n#{svg_out[:defs].join("\n")}\n</defs>"
+      shapes = svg_out[:element_shapes].join("\n")
+      texts = svg_out[:element_texts].join("\n")
+      body = "<g transform=\"translate(0 #{height}) scale(1 -1)\">\n#{shapes}\n#{texts}</g>"
+
+      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" \
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" #{view_box}>\n" \
+        "#{defs}\n" \
+        "#{body}\n" \
+        "</svg>"
+    end
+
+    def num_fmt(n)
+      # Format number, removing unnecessary decimals
+      if n == n.to_i
+        n.to_i.to_s
+      else
+        format("%.3f", n).sub(/\.?0+$/, "")
+      end
+    end
+  end
+end

data/postsvg.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/postsvg/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "postsvg"
+  spec.version = Postsvg::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Pure Ruby PostScript/EPS to SVG converter"
+  spec.description = <<~HEREDOC
+    Postsvg provides a pure Ruby library for converting PostScript (PS) and
+    Encapsulated PostScript (EPS) files to clean,
+    standards-compliant Scalable Vector Graphics (SVG) format output.
+  HEREDOC
+
+  spec.homepage = "https://github.com/metanorma/postsvg"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/metanorma/postsvg"
+  spec.metadata["changelog_uri"] = "https://github.com/metanorma/postsvg"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "parslet"
+  spec.add_dependency "thor"
+end