postscript 0.1.0

data/lib/postscript/source/lexer.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Postscript
+  module Source
+    # Comment-aware PS lexer.
+    #
+    # Distinguishes +#+ line comments from +%+ inside string literals,
+    # captures DSC comments (lines beginning with +%%+), and tags every
+    # token with its source position (line, column).
+    #
+    # The legacy Tokenizer stripped comments with a global
+    # +gsub(/%[^\n\r]*/, " ")+ before lexing, which corrupted +%+ chars
+    # inside string literals. This implementation walks the source as a
+    # state machine so +%+ inside (...) or <...> survives.
+    class Lexer
+      attr_reader :source, :position, :line, :column
+
+      def initialize(source)
+        @source = source.to_s
+        @position = 0
+        @line = 1
+        @column = 1
+        @tokens = []
+        @state = :top
+      end
+
+      def tokenize
+        until eos?
+          case @state
+          when :top        then scan_top
+          when :string     then scan_string_body
+          when :hexstring  then scan_hexstring_body
+          when :comment    then scan_comment_body
+          when :dsc        then scan_dsc_body
+          end
+        end
+        @tokens.freeze
+      end
+
+      def self.tokenize(source)
+        new(source).tokenize
+      end
+
+      private
+
+      def eos? = @position >= @source.bytesize
+
+      def peek(offset = 0)
+        @source.getbyte(@position + offset)
+      end
+
+      def advance
+        byte = @source.getbyte(@position)
+        @position += 1
+        if byte == 10 # \n
+          @line += 1
+          @column = 1
+        else
+          @column += 1
+        end
+        byte
+      end
+
+      def scan_top
+        skip_whitespace and return
+        byte = peek
+        return if byte.nil?
+
+        char = byte.chr
+
+        case char
+        when "%"        then start_dsc_or_comment
+        when "("        then start_string
+        when "<"
+          if peek(1) == 60 # <<
+            advance
+            advance
+            emit(:dict_open, "<<")
+          else
+            start_hexstring
+          end
+        when ">"        then maybe_close_dict
+        when "{"        then advance and emit(:proc_open, "{")
+        when "}"        then advance and emit(:proc_close, "}")
+        when "["        then advance and emit(:array_open, "[")
+        when "]"        then advance and emit(:array_close, "]")
+        when "/", "\\"
+          start_name_with_slash(char)
+        else
+          scan_word_or_number
+        end
+      end
+
+      def skip_whitespace
+        consumed = false
+        until eos?
+          byte = peek
+          break unless whitespace_byte?(byte)
+
+          advance
+          consumed = true
+        end
+        consumed
+      end
+
+      def whitespace_byte?(byte)
+        byte && [32, 9, 10, 13, 12, 11, 0].include?(byte)
+      end
+
+      def start_dsc_or_comment
+        advance # consume first %
+        if peek == 37 # second %
+          advance # consume second %
+          @state = :dsc
+        else
+          @state = :comment
+        end
+      end
+
+      def scan_dsc_body
+        start_pos = @position
+        start_line = @line
+        start_col = @column
+        until eos? || @source.getbyte(@position) == 10
+          advance
+        end
+        text = @source.byteslice(start_pos, @position - start_pos)
+        @tokens << Model::Token.new(:dsc, text.chomp, line: start_line, column: start_col)
+        @state = :top
+      end
+
+      def scan_comment_body
+        until eos? || @source.getbyte(@position) == 10
+          advance
+        end
+        @state = :top
+      end
+
+      def start_string
+        start_line = @line
+        start_col = @column
+        advance # consume (
+        @string_start = { line: start_line, column: start_col, bytes: +"" }
+        @string_depth = 1
+        @state = :string
+      end
+
+      def scan_string_body
+        until eos?
+          byte = @source.getbyte(@position)
+          case byte
+          when 92 # backslash
+            advance
+            handle_escape
+          when 40 # (
+            advance
+            @string_depth += 1
+            @string_start[:bytes] << "("
+          when 41 # )
+            advance
+            @string_depth -= 1
+            if @string_depth.zero?
+              emit_string
+              return
+            end
+            @string_start[:bytes] << ")"
+          else
+            advance
+            @string_start[:bytes] << byte.chr
+          end
+        end
+        raise LexError.new("unterminated string literal",
+                           source_position: [@string_start[:line], @string_start[:column]])
+      end
+
+      def handle_escape
+        byte = peek
+        return if byte.nil?
+
+        char = byte.chr
+        replacement =
+          case char
+          when "n"  then "\n"
+          when "r"  then "\r"
+          when "t"  then "\t"
+          when "b"  then "\b"
+          when "f"  then "\f"
+          when "\\" then "\\"
+          when "("  then "("
+          when ")"  then ")"
+          when "0".."7"
+            consume_octal_escape
+          else
+            char
+          end
+        if replacement.is_a?(String)
+          advance
+          @string_start[:bytes] << replacement
+        end
+      end
+
+      def consume_octal_escape
+        digits = +""
+        3.times do
+          byte = peek
+          break unless byte && (byte >= 48 && byte <= 55) # 0..7
+
+          digits << byte.chr
+          advance
+        end
+        code = digits.to_i(8) & 0xFF
+        @string_start[:bytes] << code.chr
+        nil
+      end
+
+      def emit_string
+        @tokens << Model::Token.new(:string, @string_start[:bytes],
+                                    line: @string_start[:line], column: @string_start[:column])
+        @string_start = nil
+        @state = :top
+      end
+
+      def start_hexstring
+        start_line = @line
+        start_col = @column
+        advance # consume <
+        @hex_start = { line: start_line, column: start_col, bytes: +"" }
+        @state = :hexstring
+      end
+
+      def scan_hexstring_body
+        until eos?
+          byte = @source.getbyte(@position)
+          case byte
+          when 62 # >
+            advance
+            emit_hexstring
+            return
+          when 32, 9, 10, 13, 12
+            advance
+          else
+            advance
+            @hex_start[:bytes] << byte.chr
+          end
+        end
+        raise LexError.new("unterminated hex string literal",
+                           source_position: [@hex_start[:line], @hex_start[:column]])
+      end
+
+      def emit_hexstring
+        hex = @hex_start[:bytes].delete("^0-9a-fA-F")
+        @tokens << Model::Token.new(:hexstring, hex,
+                                    line: @hex_start[:line], column: @hex_start[:column])
+        @hex_start = nil
+        @state = :top
+      end
+
+      def maybe_close_dict
+        if peek(1) == 62 # >>
+          advance
+          advance
+          emit(:dict_close, ">>")
+        else
+          # Lone '>' is not a valid token in PS; skip and warn via token.
+          advance
+        end
+      end
+
+      def start_name_with_slash(prefix)
+        start_line = @line
+        start_col = @column
+        advance
+        bytes = +""
+        until eos?
+          byte = peek
+          break if byte.nil? || whitespace_byte?(byte) || delimiter_byte?(byte)
+
+          bytes << byte.chr
+          advance
+        end
+        @tokens << Model::Token.new(:name, bytes, line: start_line, column: start_col, literal: true)
+      end
+
+      def delimiter_byte?(byte)
+        return false unless byte
+
+        char = byte.chr
+        "%()<>{}/[]".include?(char)
+      end
+
+      def scan_word_or_number
+        start_line = @line
+        start_col = @column
+        bytes = +""
+        until eos?
+          byte = peek
+          break if byte.nil? || whitespace_byte?(byte) || delimiter_byte?(byte)
+
+          bytes << byte.chr
+          advance
+        end
+        emit_word(bytes, start_line, start_col)
+      end
+
+      def emit_word(bytes, line, col)
+        type =
+          if NUMBER_RE.match?(bytes)
+            :number
+          else
+            :operator
+          end
+        @tokens << Model::Token.new(type, bytes, line: line, column: col)
+      end
+
+      NUMBER_RE = /\A[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?\z/.freeze
+
+      def emit(type, value)
+        @tokens << Model::Token.new(type, value, line: @line, column: @column)
+      end
+    end
+  end
+end

data/lib/postscript/source/operand_stack.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Postscript
+  module Source
+    # Parse-time operand stack. Wraps an Array with type-aware pops.
+    class OperandStack
+      def initialize
+        @items = []
+      end
+
+      def push(value)
+        @items.push(value)
+        self
+      end
+      alias << push
+
+      def pop
+        return Model::Computed.new(operator_keyword: "(missing)") if @items.empty?
+
+        @items.pop
+      end
+
+      def pop_number(default_on_empty: nil)
+        return default_on_empty if @items.empty? && !default_on_empty.nil?
+
+        value = pop
+        return value.to_f if value.is_a?(Model::Literals::Number)
+        return value.to_f if value.is_a?(Numeric)
+
+        # Parse-time fallback: a Name (e.g. /x defined via def) or a
+        # Computed sentinel (e.g. result of an arithmetic op) cannot
+        # be evaluated to a number yet. Return 0 so the operator
+        # instance can be built; the visitor will re-resolve at
+        # runtime if the program is executed.
+        0.0
+      end
+
+      def peek(offset = 0)
+        @items[-1 - offset]
+      end
+
+      def length
+        @items.length
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def to_a
+        @items.dup
+      end
+    end
+  end
+end

data/lib/postscript/source.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Postscript
+  # Source-reading layer: PS source text -> Model::Program.
+  #
+  # Lexer produces an array of Model::Token; AstBuilder walks tokens and
+  # emits a typed Model::Program. Errors are raised as Postscript::LexError
+  # and Postscript::SyntaxError respectively.
+  module Source
+    autoload :Lexer, "postscript/source/lexer"
+    autoload :AstBuilder, "postscript/source/ast_builder"
+    autoload :OperandStack, "postscript/source/operand_stack"
+
+    module_function
+
+    # One-shot convenience: PS source -> Model::Program.
+    def parse(source)
+      AstBuilder.build(Lexer.tokenize(source))
+    end
+  end
+end

data/lib/postscript/version.rb

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

data/lib/postscript.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Postscript
+  autoload :VERSION, "postscript/version"
+
+  # Errors
+  autoload :Error, "postscript/errors"
+  autoload :ParseError, "postscript/errors"
+  autoload :LexError, "postscript/errors"
+  autoload :SyntaxError, "postscript/errors"
+  autoload :RenderError, "postscript/errors"
+  autoload :StackUnderflowError, "postscript/errors"
+  autoload :UndefinedOperatorError, "postscript/errors"
+  autoload :RecursionLimitError, "postscript/errors"
+  autoload :SizeLimitError, "postscript/errors"
+  autoload :SerializeError, "postscript/errors"
+  autoload :ExitSignal, "postscript/errors"
+  autoload :QuitSignal, "postscript/errors"
+
+  # General-purpose value types
+  autoload :FormatNumber, "postscript/format_number"
+  autoload :Matrix, "postscript/matrix"
+  autoload :Color, "postscript/color"
+
+  # PS source-reading layer
+  autoload :Source, "postscript/source"
+
+  # Typed PS domain model
+  autoload :Model, "postscript/model"
+
+  # PS source serializer
+  autoload :Serializer, "postscript/serializer"
+end

data/postscript.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/postscript/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "postscript"
+  spec.version = Postscript::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Pure Ruby PostScript (PS) / EPS parser, domain model, and serializer"
+  spec.description = <<~HEREDOC
+    Postscript is a pure-Ruby PostScript (PS) / EPS parser, typed
+    domain model, and serializer. It is the lower layer of the
+    postsvg converter and is independently reusable for any tool
+    that needs to read, write, or transform PostScript source.
+  HEREDOC
+
+  spec.homepage = "https://github.com/claricle/postscript"
+  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/claricle/postscript"
+  spec.metadata["changelog_uri"] = "https://github.com/claricle/postscript/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/claricle/postscript/issues"
+  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"]
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: postscript
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Postscript is a pure-Ruby PostScript (PS) / EPS parser, typed
+  domain model, and serializer. It is the lower layer of the
+  postsvg converter and is independently reusable for any tool
+  that needs to read, write, or transform PostScript source.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.adoc
+- Rakefile
+- lib/postscript.rb
+- lib/postscript/color.rb
+- lib/postscript/errors.rb
+- lib/postscript/format_number.rb
+- lib/postscript/matrix.rb
+- lib/postscript/model.rb
+- lib/postscript/model/literals.rb
+- lib/postscript/model/literals/array.rb
+- lib/postscript/model/literals/dictionary.rb
+- lib/postscript/model/literals/hex.rb
+- lib/postscript/model/literals/name.rb
+- lib/postscript/model/literals/number.rb
+- lib/postscript/model/literals/procedure.rb
+- lib/postscript/model/literals/string.rb
+- lib/postscript/model/operator.rb
+- lib/postscript/model/operators.rb
+- lib/postscript/model/operators/arithmetic.rb
+- lib/postscript/model/operators/boolean.rb
+- lib/postscript/model/operators/color.rb
+- lib/postscript/model/operators/container.rb
+- lib/postscript/model/operators/control_flow.rb
+- lib/postscript/model/operators/device.rb
+- lib/postscript/model/operators/dictionary.rb
+- lib/postscript/model/operators/font.rb
+- lib/postscript/model/operators/graphics_state.rb
+- lib/postscript/model/operators/painting.rb
+- lib/postscript/model/operators/path.rb
+- lib/postscript/model/operators/stack.rb
+- lib/postscript/model/operators/transformations.rb
+- lib/postscript/model/program.rb
+- lib/postscript/model/token.rb
+- lib/postscript/serializer.rb
+- lib/postscript/source.rb
+- lib/postscript/source/ast_builder.rb
+- lib/postscript/source/lexer.rb
+- lib/postscript/source/operand_stack.rb
+- lib/postscript/version.rb
+- postscript.gemspec
+homepage: https://github.com/claricle/postscript
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/claricle/postscript
+  source_code_uri: https://github.com/claricle/postscript
+  changelog_uri: https://github.com/claricle/postscript/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/claricle/postscript/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Pure Ruby PostScript (PS) / EPS parser, domain model, and serializer
+test_files: []