postscript 0.1.0 → 0.2.0

data/lib/postscript/serializer.rb

@@ -19,7 +19,10 @@ module Postscript
     attr_reader :program, :eps, :creator
 
     def initialize(program, eps:, creator:)
-      raise ArgumentError, "program must be a Model::Program" unless program.is_a?(Model::Program)
+      unless program.is_a?(Model::Program)
+        raise ArgumentError,
+              "program must be a Model::Program"
+      end
 
       @program = program
       @eps = eps
@@ -30,11 +33,17 @@ module Postscript
       buffer = String.new(capacity: 4096)
       emit_header(buffer)
       emit_body(buffer)
-      buffer << "showpage\n"
+      buffer << "showpage\n" unless body_has_showpage?
       buffer << "%%EOF\n"
       buffer
     end
 
+    # Returns true if the program body already contains a +showpage+
+    # operator, so the serializer doesn't append a duplicate.
+    def body_has_showpage?
+      program.body.any? { |s| s.is_a?(Model::Operators::Device::Showpage) }
+    end
+
     # All methods below this point are public. They are intentionally
     # exposed (prefixed +emit_+) so dispatch can reach them via
     # +method_defined?+ without +respond_to?+.
@@ -45,11 +54,17 @@ module Postscript
       buffer << "%%Creator: #{creator}\n"
       bbox = program.header.bounding_box
       if bbox && !bbox.empty?
-        buffer << "%%BoundingBox: " << bbox.map { |v| FormatNumber.call(v) }.join(" ") << "\n"
+        buffer << "%%BoundingBox: " << bbox.map { |v|
+          FormatNumber.call(v)
+        }.join(" ") << "\n"
       end
-      if program.header.title
-        buffer << "%%Title: #{program.header.title}\n"
+      hires = program.header.hires_bounding_box
+      if hires && !hires.empty?
+        buffer << "%%HiResBoundingBox: " << hires.map { |v|
+          FormatNumber.call(v)
+        }.join(" ") << "\n"
       end
+      buffer << "%%Title: #{program.header.title}\n" if program.header.title
       buffer << "%%LanguageLevel: #{DEFAULT_LANGUAGE_LEVEL}\n"
       buffer << "%%EndComments\n"
     end
@@ -73,7 +88,10 @@ module Postscript
         buffer << "<" << statement.value << ">\n"
       when Model::Literals::ArrayLiteral
         buffer << "[ "
-        statement.elements.each { |e| emit_inline(e, buffer); buffer << " " }
+        statement.elements.each do |e|
+          emit_inline(e, buffer)
+          buffer << " "
+        end
         buffer << "]\n"
       when Model::Literals::Procedure
         buffer << "{\n"
@@ -106,220 +124,22 @@ module Postscript
       end
     end
 
-    # Dispatch table: emit_<keyword>. Falls back to the generic
-    # operand+keyword form when no specific method exists.
+    # Dispatch: just emit the keyword. Operands are already in the
+    # program body as separate literal statements (added by the
+    # AstBuilder). This keeps round-trip idempotent: serialized
+    # output re-parses to an identical AST.
     def emit_operator(operator, buffer)
-      method = :"emit_#{operator.visit_name}"
-      if self.class.public_method_defined?(method)
-        public_send(method, operator, buffer)
-      else
-        emit_generic_operator(operator, buffer)
-      end
-    end
-
-    def emit_generic_operator(operator, buffer)
       buffer << operator.keyword << "\n"
     end
 
     # Path
-    def emit_moveto(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} moveto\n"
-    end
-
-    def emit_rmoveto(op, buf)
-      buf << "#{FormatNumber.call(op.dx)} #{FormatNumber.call(op.dy)} rmoveto\n"
-    end
-
-    def emit_lineto(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} lineto\n"
-    end
-
-    def emit_rlineto(op, buf)
-      buf << "#{FormatNumber.call(op.dx)} #{FormatNumber.call(op.dy)} rlineto\n"
-    end
-
-    def emit_curveto(op, buf)
-      buf << "#{FormatNumber.call(op.x1)} #{FormatNumber.call(op.y1)} " \
-            "#{FormatNumber.call(op.x2)} #{FormatNumber.call(op.y2)} " \
-            "#{FormatNumber.call(op.x3)} #{FormatNumber.call(op.y3)} curveto\n"
-    end
-
-    def emit_rcurveto(op, buf)
-      buf << "#{FormatNumber.call(op.dx1)} #{FormatNumber.call(op.dy1)} " \
-            "#{FormatNumber.call(op.dx2)} #{FormatNumber.call(op.dy2)} " \
-            "#{FormatNumber.call(op.dx3)} #{FormatNumber.call(op.dy3)} rcurveto\n"
-    end
-
-    def emit_arc(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} " \
-            "#{FormatNumber.call(op.radius)} " \
-            "#{FormatNumber.call(op.angle1)} #{FormatNumber.call(op.angle2)} arc\n"
-    end
-
-    def emit_arcn(op, buf)
-      buf << "#{FormatNumber.call(op.x)} #{FormatNumber.call(op.y)} " \
-            "#{FormatNumber.call(op.radius)} " \
-            "#{FormatNumber.call(op.angle1)} #{FormatNumber.call(op.angle2)} arcn\n"
-    end
-
-    def emit_closepath(_op, buf)
-      buf << "closepath\n"
-    end
-
-    def emit_newpath(_op, buf)
-      buf << "newpath\n"
-    end
-
-    # Painting
-    def emit_stroke(_op, buf) = buf << "stroke\n"
-    def emit_fill(_op, buf) = buf << "fill\n"
-    def emit_eofill(_op, buf) = buf << "eofill\n"
-    def emit_clip(_op, buf) = buf << "clip\n"
-    def emit_eoclip(_op, buf) = buf << "eoclip\n"
-
-    # Color
-    def emit_setrgbcolor(op, buf)
-      buf << "#{FormatNumber.call(op.red)} #{FormatNumber.call(op.green)} #{FormatNumber.call(op.blue)} setrgbcolor\n"
-    end
-
-    def emit_setgray(op, buf)
-      buf << "#{FormatNumber.call(op.gray)} setgray\n"
-    end
-
-    def emit_setcmykcolor(op, buf)
-      buf << "#{FormatNumber.call(op.cyan)} #{FormatNumber.call(op.magenta)} " \
-            "#{FormatNumber.call(op.yellow)} #{FormatNumber.call(op.key)} setcmykcolor\n"
-    end
-
-    def emit_sethsbcolor(op, buf)
-      buf << "#{FormatNumber.call(op.hue)} #{FormatNumber.call(op.saturation)} " \
-            "#{FormatNumber.call(op.brightness)} sethsbcolor\n"
-    end
-
-    # Graphics state
-    def emit_gsave(_op, buf) = buf << "gsave\n"
-    def emit_grestore(_op, buf) = buf << "grestore\n"
-    def emit_grestoreall(_op, buf) = buf << "grestoreall\n"
-
-    def emit_setlinewidth(op, buf)
-      buf << "#{FormatNumber.call(op.width)} setlinewidth\n"
-    end
-
-    def emit_setlinecap(op, buf)
-      buf << "#{op.cap_code} setlinecap\n"
-    end
-
-    def emit_setlinejoin(op, buf)
-      buf << "#{op.join_code} setlinejoin\n"
-    end
-
-    def emit_setmiterlimit(op, buf)
-      buf << "#{FormatNumber.call(op.limit)} setmiterlimit\n"
-    end
-
-    def emit_setdash(op, buf)
-      pattern_str =
-        case op.pattern
-        when Array then "[#{op.pattern.map { |v| FormatNumber.call(v.to_f) }.join(' ')}]"
-        when Numeric then FormatNumber.call(op.pattern.to_f)
-        else "[]"
-        end
-      buf << "#{pattern_str} #{FormatNumber.call(op.offset)} setdash\n"
-    end
-
-    # Transformations
-    def emit_translate(op, buf)
-      buf << "#{FormatNumber.call(op.tx)} #{FormatNumber.call(op.ty)} translate\n"
-    end
-
-    def emit_scale(op, buf)
-      buf << "#{FormatNumber.call(op.sx)} #{FormatNumber.call(op.sy)} scale\n"
-    end
-
-    def emit_rotate(op, buf)
-      buf << "#{FormatNumber.call(op.angle)} rotate\n"
-    end
-
-    def emit_concat(op, buf)
-      m = op.matrix
-      arr = m.is_a?(Array) ? m : [m.a, m.b, m.c, m.d, m.e, m.f]
-      buf << "[#{arr.map { |v| FormatNumber.call(v.to_f) }.join(' ')}] concat\n"
-    end
-
     def escape_string(text)
-      escaped = text.to_s.gsub(/[\(\)\\]/) { |c| "\\#{c}" }
-                          .gsub("\n", "\\n")
-                          .gsub("\r", "\\r")
-                          .gsub("\t", "\\t")
+      escaped = text.to_s.gsub(/[()\\]/) { |c| "\\#{c}" }
+        .gsub("\n", '\\n')
+        .gsub("\r", '\\r')
+        .gsub("\t", '\\t')
       "(#{escaped})"
     end
 
-    # Font / text
-    def emit_findfont(op, buf)
-      name = font_name_value(op.name)
-      buf << "/#{name} findfont\n"
-    end
-
-    def emit_scalefont(op, buf)
-      buf << "#{FormatNumber.call(op.size)} scalefont\n"
-    end
-
-    def emit_setfont(_op, buf)
-      buf << "setfont\n"
-    end
-
-    def emit_show(op, buf)
-      buf << "#{escape_string(string_value(op.text))} show\n"
-    end
-
-    def emit_xyshow(_op, buf)
-      buf << "% xyshow: per-glyph advances not serialized\n"
-    end
-
-    def emit_stringwidth(_op, buf)
-      buf << "% stringwidth: no runtime result captured\n"
-    end
-
-    def emit_charpath(_op, buf)
-      buf << "% charpath: requires font metrics\n"
-    end
-
-    # Container operators
-    def emit_length(_op, buf) = buf << "length\n"
-    def emit_get(_op, buf) = buf << "get\n"
-    def emit_put(_op, buf) = buf << "put\n"
-    def emit_getinterval(_op, buf) = buf << "getinterval\n"
-    def emit_putinterval(_op, buf) = buf << "putinterval\n"
-    def emit_forall(_op, buf) = buf << "forall\n"
-    def emit_astore(_op, buf) = buf << "astore\n"
-    def emit_search(_op, buf) = buf << "search\n"
-    def emit_anchorsearch(_op, buf) = buf << "anchorsearch\n"
-    def emit_token(_op, buf) = buf << "token\n"
-    def emit_string(_op, buf) = buf << "string\n"
-    def emit_cvs(_op, buf) = buf << "cvs\n"
-
-    # Dictionary operators (currentdict etc.)
-    def emit_currentdict(_op, buf) = buf << "currentdict\n"
-    def emit_countdictstack(_op, buf) = buf << "countdictstack\n"
-    def emit_dictstack(_op, buf) = buf << "dictstack\n"
-    def emit_maxlength(_op, buf) = buf << "maxlength\n"
-
-    def font_name_value(value)
-      case value
-      when Model::Literals::Name then value.value
-      when Model::Literals::StringLiteral then value.value
-      when String then value
-      else value.to_s
-      end
-    end
-
-    def string_value(value)
-      case value
-      when Model::Literals::StringLiteral then value.value
-      when Model::Literals::HexLiteral then value.bytes
-      when String then value
-      else value.to_s
-      end
-    end
   end
 end

data/lib/postscript/source/ast_builder.rb

@@ -33,7 +33,10 @@ module Postscript
       private
 
       def consume_until(end_index, terminators: [], depth: 0)
-        raise RecursionLimitError, "procedure depth exceeded #{MAX_PROC_DEPTH}" if depth > MAX_PROC_DEPTH
+        if depth > MAX_PROC_DEPTH
+          raise RecursionLimitError,
+                "procedure depth exceeded #{MAX_PROC_DEPTH}"
+        end
 
         i = 0
         collected = []
@@ -65,7 +68,8 @@ module Postscript
           append_statement(node, collected)
           1
         when :name
-          node = Model::Literals::Name.new(token.value, literal: token.literal || false)
+          node = Model::Literals::Name.new(token.value,
+                                           literal: token.literal || false)
           @stack.push(node)
           append_statement(node, collected)
           1
@@ -101,11 +105,12 @@ module Postscript
       def build_number(token)
         raw = token.value
         value =
-          if raw =~ /\A[-+]?\d+\z/
+          case raw
+          when /\A[-+]?\d+\z/
             raw.to_i
-          elsif raw =~ /\A[-+]?\d+\.\d+\z/ || raw =~ /\A[-+]?(\.\d+|\d+\.)\z/
+          when /\A[-+]?\d+\.\d+\z/, /\A[-+]?(\.\d+|\d+\.)\z/
             raw.to_f
-          elsif raw =~ /\A[-+]?(\d+\.?\d*|\.\d+)[eE][-+]?\d+\z/
+          when /\A[-+]?(\d+\.?\d*|\.\d+)[eE][-+]?\d+\z/
             raw.to_f
           else
             raw.to_f
@@ -129,9 +134,12 @@ module Postscript
 
       def consume_array(after:, collected:)
         start_index = find_index(after)
-        body_tokens, end_index = match_until(start_index + 1, :array_close, :array_open)
+        body_tokens, end_index = match_until(start_index + 1, :array_close,
+                                             :array_open)
         body_nodes = sub_build(body_tokens)
-        array = Model::Literals::ArrayLiteral.new(body_nodes.select { |n| literal?(n) })
+        array = Model::Literals::ArrayLiteral.new(body_nodes.select do |n|
+          literal?(n)
+        end)
         @stack.push(array)
         append_statement(array, collected)
         end_index - start_index + 1
@@ -139,7 +147,8 @@ module Postscript
 
       def consume_dict(after:, collected:)
         start_index = find_index(after)
-        body_tokens, end_index = match_until(start_index + 1, :dict_close, :dict_open)
+        body_tokens, end_index = match_until(start_index + 1, :dict_close,
+                                             :dict_open)
         entries = {}
         pending_key = nil
         sub_nodes = sub_build(body_tokens)
@@ -221,13 +230,11 @@ module Postscript
         keyword = token.value
 
         # Resolve user-defined names to InvokeProcedure.
-        if (proc_value = lookup_user_definition(keyword))
-          if proc_value.is_a?(Model::Literals::Procedure)
-            inv = Model::InvokeProcedure.new(name: keyword, procedure: proc_value)
-            @body << inv
-            collected << inv
-            return 1
-          end
+        if (proc_value = lookup_user_definition(keyword)) && proc_value.is_a?(Model::Literals::Procedure)
+          inv = Model::InvokeProcedure.new(name: keyword, procedure: proc_value)
+          @body << inv
+          collected << inv
+          return 1
         end
 
         operator_class = Model::Operators[keyword]
@@ -262,7 +269,8 @@ module Postscript
       def apply_side_effects(operator)
         case operator
         when Model::Operators::Dictionary::Def
-          @dict_stack.last[operator.key.to_s.sub(/\A\//, "")] = operator.value
+          @dict_stack.last[operator.key.to_s.delete_prefix("/")] =
+            operator.value
         end
       end
 
@@ -278,14 +286,14 @@ module Postscript
         case text
         when /\ABoundingBox:\s*(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\z/
           @header = @header.with(bounding_box: [
-            ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
-            ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f,
-          ])
+                                   ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
+                                   ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f
+                                 ])
         when /\AHiResBoundingBox:\s*(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\s+(-?[\d.eE+-]+)\z/
           @header = @header.with(hires_bounding_box: [
-            ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
-            ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f,
-          ])
+                                   ::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
+                                   ::Regexp.last_match(3).to_f, ::Regexp.last_match(4).to_f
+                                 ])
         when /\ATitle:\s*(.+)\z/
           @header = @header.with(title: ::Regexp.last_match(1))
         when /\ACreator:\s*(.+)\z/

data/lib/postscript/source/lexer.rb

@@ -121,18 +121,15 @@ module Postscript
         start_pos = @position
         start_line = @line
         start_col = @column
-        until eos? || @source.getbyte(@position) == 10
-          advance
-        end
+        advance until eos? || @source.getbyte(@position) == 10
         text = @source.byteslice(start_pos, @position - start_pos)
-        @tokens << Model::Token.new(:dsc, text.chomp, line: start_line, column: start_col)
+        @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
+        advance until eos? || @source.getbyte(@position) == 10
         @state = :top
       end
 
@@ -148,16 +145,14 @@ module Postscript
       def scan_string_body
         until eos?
           byte = @source.getbyte(@position)
+          advance
           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
@@ -165,12 +160,12 @@ module Postscript
             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]])
+                           source_position: [@string_start[:line],
+                                             @string_start[:column]])
       end
 
       def handle_escape
@@ -193,17 +188,17 @@ module Postscript
           else
             char
           end
-        if replacement.is_a?(String)
-          advance
-          @string_start[:bytes] << replacement
-        end
+        return unless replacement.is_a?(String)
+
+        advance
+        @string_start[:bytes] << replacement
       end
 
       def consume_octal_escape
         digits = +""
         3.times do
           byte = peek
-          break unless byte && (byte >= 48 && byte <= 55) # 0..7
+          break unless byte && byte >= 48 && byte <= 55 # 0..7
 
           digits << byte.chr
           advance
@@ -244,7 +239,8 @@ module Postscript
           end
         end
         raise LexError.new("unterminated hex string literal",
-                           source_position: [@hex_start[:line], @hex_start[:column]])
+                           source_position: [@hex_start[:line],
+                                             @hex_start[:column]])
       end
 
       def emit_hexstring
@@ -266,7 +262,7 @@ module Postscript
         end
       end
 
-      def start_name_with_slash(prefix)
+      def start_name_with_slash(_prefix)
         start_line = @line
         start_col = @column
         advance
@@ -278,7 +274,8 @@ module Postscript
           bytes << byte.chr
           advance
         end
-        @tokens << Model::Token.new(:name, bytes, line: start_line, column: start_col, literal: true)
+        @tokens << Model::Token.new(:name, bytes, line: start_line,
+                                                  column: start_col, literal: true)
       end
 
       def delimiter_byte?(byte)
@@ -312,7 +309,7 @@ module Postscript
         @tokens << Model::Token.new(type, bytes, line: line, column: col)
       end
 
-      NUMBER_RE = /\A[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?\z/.freeze
+      NUMBER_RE = /\A[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?\z/
 
       def emit(type, value)
         @tokens << Model::Token.new(type, value, line: @line, column: @column)

data/lib/postscript/version.rb

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

data/lib/postscript.rb

@@ -30,4 +30,34 @@ module Postscript
 
   # PS source serializer
   autoload :Serializer, "postscript/serializer"
+
+  # CLI (only loaded when explicitly required or via the +postscript+
+  # executable). Avoids pulling in +thor+ for users who only need
+  # the library API.
+  autoload :CLI, "postscript/cli"
+
+  class << self
+    # One-shot: PS source string -> +Model::Program+.
+    #
+    # Example:
+    #   program = Postscript.parse(ps_source)
+    #   program.body.each { |node| puts node.class }
+    def parse(source)
+      Source.parse(source)
+    end
+
+    # One-shot: +Model::Program+ -> PS source string.
+    #
+    # Example:
+    #   ps = Postscript.serialize(program, eps: true)
+    def serialize(program, **opts)
+      Serializer.call(program, **opts)
+    end
+
+    # One-shot: PS source string -> array of +Model::Token+.
+    # Useful for debugging or building alternative parsers.
+    def tokenize(source)
+      Source::Lexer.tokenize(source)
+    end
+  end
 end

metadata

@@ -1,14 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: postscript
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+date: 2026-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Postscript is a pure-Ruby PostScript (PS) / EPS parser, typed
   domain model, and serializer. It is the lower layer of the
@@ -16,15 +31,22 @@ description: |
   that needs to read, write, or transform PostScript source.
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- postscript
 extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CHANGELOG.md
 - Gemfile
+- LICENSE
 - README.adoc
 - Rakefile
+- exe/postscript
 - lib/postscript.rb
+- lib/postscript/cli.rb
 - lib/postscript/color.rb
 - lib/postscript/errors.rb
 - lib/postscript/format_number.rb
@@ -61,7 +83,6 @@ files:
 - 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
@@ -71,6 +92,7 @@ metadata:
   changelog_uri: https://github.com/claricle/postscript/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/claricle/postscript/issues
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -85,7 +107,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Pure Ruby PostScript (PS) / EPS parser, domain model, and serializer
 test_files: []

data/postscript.gemspec

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