postsvg 0.1.0 → 0.2.1

data/exe/postsvg

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require_relative "../lib/postsvg"
 require_relative "../lib/postsvg/cli"
 
 Postsvg::CLI.start(ARGV)

data/lib/postsvg/cli.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../postsvg"
 
 module Postsvg
-  # Command-line interface for postsvg
+  # Command-line interface. Thor-based. Auto-detects conversion
+  # direction by file extension in +batch+.
   class CLI < Thor
-    desc "convert INPUT [OUTPUT]", "Convert PostScript/EPS file to SVG"
+    package_name "postsvg"
+
+    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 format.
+      Convert a PostScript (.ps) or Encapsulated PostScript (.eps) file to SVG.
 
-      If OUTPUT is not specified, the output will be written to stdout.
+      If OUTPUT is not specified, SVG is written to stdout.
 
       Examples:
 
@@ -18,43 +21,52 @@ module Postsvg
         $ postsvg convert input.eps > output.svg
     DESC
     def convert(input_path, output_path = nil)
-      unless File.exist?(input_path)
-        say "Error: Input file '#{input_path}' not found", :red
-        exit 1
-      end
+      handle_input(input_path, output_path, method(:read_ps_to_svg),
+                   direction: "PS/EPS -> SVG")
+    end
 
-      begin
-        ps_content = File.read(input_path)
-        svg_output = Postsvg.convert(ps_content)
+    desc "to-svg INPUT [OUTPUT]", "Convert PostScript/EPS to SVG"
+    long_desc <<~DESC
+      Alias for `convert`. Reads PS or EPS, writes SVG.
+    DESC
+    def to_svg(input_path, output_path = nil)
+      convert(input_path, output_path)
+    end
 
-        if output_path
-          File.write(output_path, svg_output)
-          say "Successfully converted #{input_path} to #{output_path}", :green
-        else
-          puts svg_output
-        end
-      rescue Postsvg::Error => e
-        say "Conversion error: #{e.message}", :red
-        exit 1
-      rescue StandardError => e
-        say "Unexpected error: #{e.message}", :red
-        say e.backtrace.join("\n"), :red if options[:verbose]
-        exit 1
-      end
+    desc "to-ps INPUT [OUTPUT]", "Convert SVG to PostScript"
+    long_desc <<~DESC
+      Convert an SVG file to PostScript source. If OUTPUT is not specified,
+      PS source is written to stdout.
+
+      Examples:
+
+        $ postsvg to-ps input.svg output.ps
+        $ 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")
     end
 
-    desc "batch INPUT_DIR [OUTPUT_DIR]",
-         "Convert all PS/EPS files in a directory"
+    desc "to-eps INPUT [OUTPUT]", "Convert SVG to Encapsulated PostScript"
     long_desc <<~DESC
-      Convert all .ps and .eps files in INPUT_DIR to SVG format.
+      Like to-ps but emits an EPSF-3.0 header and a single-page program
+      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")
+    end
 
-      If OUTPUT_DIR is specified, SVG files will be written there.
-      Otherwise, SVG files will be written to the same directory as the input files.
+    desc "batch INPUT_DIR [OUTPUT_DIR]",
+         "Convert all PS/EPS/SVG files in a directory"
+    long_desc <<~DESC
+      Auto-detects direction by file extension:
 
-      Examples:
+        .ps, .eps   -> .svg
+        .svg        -> .ps
 
-        $ postsvg batch ps_files/
-        $ postsvg batch ps_files/ svg_files/
+      Output goes to OUTPUT_DIR if given, otherwise to INPUT_DIR.
     DESC
     def batch(input_dir, output_dir = nil)
       unless Dir.exist?(input_dir)
@@ -64,34 +76,15 @@ module Postsvg
 
       Dir.mkdir(output_dir) if output_dir && !Dir.exist?(output_dir)
 
-      pattern = File.join(input_dir, "*.{ps,eps}")
-      files = Dir.glob(pattern, File::FNM_CASEFOLD)
-
+      files = Dir.glob(File.join(input_dir, "*.{ps,eps,svg}"), File::FNM_CASEFOLD)
       if files.empty?
-        say "No PS or EPS files found in #{input_dir}", :yellow
+        say "No PS, EPS, or SVG files found in #{input_dir}", :yellow
         return
       end
 
       say "Found #{files.size} file(s) to convert", :cyan
-
-      files.each do |input_path|
-        basename = File.basename(input_path, ".*")
-        output_path = if output_dir
-                        File.join(output_dir, "#{basename}.svg")
-                      else
-                        File.join(input_dir, "#{basename}.svg")
-                      end
-
-        begin
-          ps_content = File.read(input_path)
-          svg_output = Postsvg.convert(ps_content)
-          File.write(output_path, svg_output)
-          say "  ✓ #{input_path} → #{output_path}", :green
-        rescue Postsvg::Error => e
-          say "  ✗ #{input_path}: #{e.message}", :red
-        rescue StandardError => e
-          say "  ✗ #{input_path}: Unexpected error: #{e.message}", :red
-        end
+      files.each do |path|
+        convert_in_batch(path, input_dir, output_dir)
       end
     end
 
@@ -99,5 +92,64 @@ module Postsvg
     def version
       say "postsvg version #{Postsvg::VERSION}"
     end
+
+    private
+
+    def handle_input(input_path, output_path, reader, direction:)
+      unless File.exist?(input_path)
+        say "Error: Input file '#{input_path}' not found", :red
+        exit 1
+      end
+
+      output = reader.call(File.read(input_path))
+      if output_path
+        File.write(output_path, output)
+        say "Converted #{input_path} -> #{output_path} (#{direction})", :green
+      else
+        puts output
+      end
+    rescue Postsvg::Error => e
+      say "Conversion error: #{e.message}", :red
+      exit 2
+    rescue StandardError => e
+      say "Unexpected error: #{e.message}", :red
+      say e.backtrace.join("\n"), :red if options[:verbose]
+      exit 2
+    end
+
+    def read_ps_to_svg(content)
+      Postsvg.to_svg(content)
+    end
+
+    def read_svg_to_ps(content)
+      Postsvg.to_ps(content)
+    end
+
+    def read_svg_to_eps(content)
+      Postsvg.to_eps(content)
+    end
+
+    def convert_in_batch(path, input_dir, output_dir)
+      ext = File.extname(path).downcase
+      basename = File.basename(path, ".*")
+      out_ext =
+        case ext
+        when ".svg" then ".ps"
+        else ".svg"
+        end
+      out_dir = output_dir || input_dir
+      out_path = File.join(out_dir, "#{basename}#{out_ext}")
+
+      content = File.read(path)
+      output =
+        case ext
+        when ".svg" then Postsvg.to_ps(content)
+        else Postsvg.to_svg(content)
+        end
+      File.write(out_path, output)
+      say "  #{path} -> #{out_path}", :green
+    rescue Postsvg::Error => e
+      say "  #{path}: #{e.message}", :red
+    end
   end
 end

data/lib/postsvg/errors.rb

@@ -1,11 +1,76 @@
 # frozen_string_literal: true
 
 module Postsvg
+  # Base class for every Postsvg error. rescue this to catch anything
+  # Postsvg raises.
   class Error < StandardError; end
 
-  class ParseError < Error; end
+  # Lexing or parsing failed. Carries +source_position+ when known.
+  class ParseError < Error
+    attr_reader :source_position
 
-  class ConversionError < Error; end
+    def initialize(message, source_position: nil)
+      @source_position = source_position
+      super(message)
+    end
+  end
 
-  class UnsupportedOperatorError < Error; end
+  # Lexer hit a character or construct it could not consume.
+  class LexError < ParseError; end
+
+  # Tokens did not form a valid PostScript program (unbalanced braces,
+  # missing operands, malformed literal).
+  class SyntaxError < ParseError; end
+
+  # PS -> SVG execution failed.
+  class RenderError < Error
+    attr_reader :operator_name
+
+    def initialize(message, operator_name: nil)
+      @operator_name = operator_name
+      super(message)
+    end
+  end
+
+  # An operator tried to pop more values than the stack held.
+  class StackUnderflowError < RenderError; end
+
+  # An operator referenced a name that has no definition in any
+  # active dictionary.
+  class UndefinedOperatorError < RenderError; end
+
+  # A procedure invocation chain exceeded the depth limit.
+  class RecursionLimitError < RenderError; end
+
+  # Output exceeded the configured byte limit.
+  class SizeLimitError < RenderError; end
+
+  # SVG -> PS translation failed.
+  class TranslationError < Error
+    attr_reader :element_name
+
+    def initialize(message, element_name: nil)
+      @element_name = element_name
+      super(message)
+    end
+  end
+
+  # Encountered an SVG element type with no registered handler.
+  class UnsupportedElementError < TranslationError; end
+
+  # A reference (clip-path, gradient, pattern) could not be resolved.
+  class UnresolvedReferenceError < TranslationError; end
+
+  # Model -> PS source serialization failed.
+  class SerializeError < Error; end
+
+  # Legacy aliases kept so older rescue clauses still match.
+  ConversionError = RenderError
+  UnsupportedOperatorError = UndefinedOperatorError
+
+  # Internal control-flow signals used by the visitor to unwind
+  # loops and stop program execution. These are NOT user-facing
+  # errors — they are caught by the Renderer.
+  class ExitSignal < StandardError; end
+  class QuitSignal < StandardError; end
 end

data/lib/postsvg/graphics_context.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Immutable graphics state snapshot. Mutations return new instances
+  # via +with(...)+. The GraphicsStack pushes/pops these.
+  #
+  # Fields mirror PLRM §7.2 graphics state operators. Optional fields
+  # are +nil+ meaning "not set in this state"; the renderer falls back
+  # to defaults at emit time.
+  class GraphicsContext
+    attr_reader :ctm, :fill_color, :stroke_color, :stroke_width,
+                :line_cap, :line_join, :miter_limit, :dash,
+                :font_name, :font_size, :clip_paths, :last_text_position,
+                :fill_rule
+
+    DEFAULTS = {
+      ctm: Matrix.new,
+      fill_color: Color::BLACK,
+      stroke_color: Color::BLACK,
+      stroke_width: 1.0,
+      line_cap: :butt,
+      line_join: :miter,
+      miter_limit: 10.0,
+      dash: nil,
+      font_name: "Helvetica",
+      font_size: 12.0,
+      clip_paths: [],
+      last_text_position: nil,
+      fill_rule: :nonzero,
+    }.freeze
+
+    def initialize(**fields)
+      merged = DEFAULTS.merge(fields)
+      @ctm = merged[:ctm]
+      @fill_color = merged[:fill_color]
+      @stroke_color = merged[:stroke_color]
+      @stroke_width = merged[:stroke_width]
+      @line_cap = merged[:line_cap]
+      @line_join = merged[:line_join]
+      @miter_limit = merged[:miter_limit]
+      @dash = merged[:dash]
+      @font_name = merged[:font_name]
+      @font_size = merged[:font_size]
+      @clip_paths = merged[:clip_paths].freeze
+      @last_text_position = merged[:last_text_position]
+      @fill_rule = merged[:fill_rule]
+      freeze
+    end
+
+    def with(**overrides)
+      GraphicsContext.new(
+        ctm: overrides.fetch(:ctm, @ctm),
+        fill_color: overrides.fetch(:fill_color, @fill_color),
+        stroke_color: overrides.fetch(:stroke_color, @stroke_color),
+        stroke_width: overrides.fetch(:stroke_width, @stroke_width),
+        line_cap: overrides.fetch(:line_cap, @line_cap),
+        line_join: overrides.fetch(:line_join, @line_join),
+        miter_limit: overrides.fetch(:miter_limit, @miter_limit),
+        dash: overrides.fetch(:dash, @dash),
+        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),
+        fill_rule: overrides.fetch(:fill_rule, @fill_rule),
+      )
+    end
+
+    def push_clip_path(path_d)
+      with(clip_paths: @clip_paths + [path_d])
+    end
+
+    def identity_ctm?
+      @ctm.identity?
+    end
+
+    def clipped?
+      !@clip_paths.empty?
+    end
+  end
+end

data/lib/postsvg/graphics_stack.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # LIFO stack of immutable GraphicsContext snapshots. +gsave+ pushes
+  # a duplicate of the current top; +grestore+ pops. Popping an empty
+  # stack is a no-op (mirrors PLRM §7.2.2).
+  class GraphicsStack
+    def initialize(initial: GraphicsContext.new)
+      @stack = [initial]
+    end
+
+    def current
+      @stack.last
+    end
+
+    def push
+      @stack.push(current)
+      self
+    end
+    alias gsave push
+
+    def pop
+      return current if @stack.size == 1
+
+      @stack.pop
+      current
+    end
+    alias grestore pop
+
+    def depth
+      @stack.size
+    end
+
+    def replace(new_state)
+      @stack[-1] = new_state
+      new_state
+    end
+
+    def update(**overrides)
+      replace(current.with(**overrides))
+    end
+  end
+end

data/lib/postsvg/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Shared options for both directions. Frozen on construction.
+  class Options
+    attr_reader :eps, :width, :height, :viewbox_override, :verbose, :page_size
+
+    DEFAULT_PAGE_SIZE = [595, 842].freeze # A4 in PostScript points
+
+    def initialize(eps: false, width: nil, height: nil, viewbox_override: nil,
+                   verbose: false, page_size: nil)
+      @eps = eps
+      @width = width
+      @height = height
+      @viewbox_override = viewbox_override
+      @verbose = verbose
+      @page_size = page_size || DEFAULT_PAGE_SIZE
+      freeze
+    end
+
+    def to_h
+      {
+        eps: @eps, width: @width, height: @height,
+        viewbox_override: @viewbox_override, verbose: @verbose,
+        page_size: @page_size
+      }
+    end
+  end
+end

data/lib/postsvg/parser/postscript_parser.rb

@@ -38,7 +38,7 @@ module Postsvg
         (str("\\") >> any) | (str(")").absent? >> any)
       end
       rule(:string) do
-        (str("(") >> string_char.repeat.as(:string) >> str(")"))
+        str("(") >> string_char.repeat.as(:string) >> str(")")
       end
 
       # Operators and keywords
@@ -49,16 +49,16 @@ module Postsvg
 
       # Arrays
       rule(:array) do
-        (str("[") >> whitespace? >>
-         value.repeat.as(:array) >>
-         whitespace? >> str("]"))
+        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("}"))
+        str("{") >> whitespace? >>
+          statement.repeat.as(:procedure) >>
+          whitespace? >> str("}")
       end
 
       # Values

data/lib/postsvg/renderer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # Top-level orchestrator for PS -> SVG. Owns lifecycle: BoundingBox
+  # pre-scan, builder open/close, visitor dispatch.
+  class Renderer
+    MAX_OUTPUT_BYTES = 100 * 1024 * 1024
+
+    def self.call(program, options = Options.new)
+      new(program, options).call
+    end
+
+    attr_reader :program, :options, :builder, :visitor
+
+    def initialize(program, options)
+      unless program.is_a?(Model::Program)
+        raise ArgumentError,
+              "program must be a Model::Program"
+      end
+
+      @program = program
+      @options = options
+      @builder = SvgBuilder.new
+      @visitor = Visitors::PsVisitor.new(builder: @builder)
+    end
+
+    def call
+      open_svg
+      wrap_y_flip do
+        visitor.visit_program(program)
+      rescue Postscript::QuitSignal
+        # PS +quit+ ends program execution; suppress and finalize SVG.
+      end
+      builder.close_svg
+      result = builder.to_s
+      enforce_size_limit(result)
+      result
+    end
+
+    private
+
+    def open_svg
+      viewbox, width, height = compute_viewbox
+      builder.open_svg(viewbox: viewbox, width: width, height: height)
+    end
+
+    def wrap_y_flip
+      builder.open_y_flip_group
+      yield
+      builder.close_group
+    end
+
+    # Determine viewBox from (1) explicit override, (2) header
+    # BoundingBox / HiResBoundingBox, (3) default A4 page size.
+    def compute_viewbox
+      return options_viewbox if options_viewbox
+
+      bbox = program.header.hires_bounding_box || program.header.bounding_box
+      if bbox
+        llx, lly, urx, ury = bbox
+        width = urx - llx
+        height = ury - lly
+        viewbox = "#{FormatNumber.call(llx)} #{FormatNumber.call(lly)} " \
+                  "#{FormatNumber.call(width)} #{FormatNumber.call(height)}"
+        [viewbox, width, height]
+      else
+        width, height = options.page_size
+        ["0 0 #{FormatNumber.call(width)} #{FormatNumber.call(height)}", width,
+         height]
+      end
+    end
+
+    def options_viewbox
+      return nil unless options.viewbox_override
+
+      vb = options.viewbox_override
+      return vb if vb.is_a?(Array) && vb.length == 4
+
+      [vb, nil, nil]
+    end
+
+    def enforce_size_limit(result)
+      return unless result.bytesize > MAX_OUTPUT_BYTES
+
+      raise SizeLimitError,
+            "SVG output #{result.bytesize} bytes exceeds limit #{MAX_OUTPUT_BYTES}"
+    end
+  end
+end

data/lib/postsvg/svg/attribute_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Helpers for parsing presentation attributes into typed values.
+    # Used by Element.from_node factories.
+    module AttributeParser
+      module_function
+
+      # Parse a length attribute ("10", "10px", "10pt", "50%").
+      # Returns a Float. Percentage values resolve to nil — the caller
+      # must know the reference dimension.
+      def length(text)
+        return nil if text.nil? || text.empty?
+
+        match = text.strip.match(/\A(-?\d+(?:\.\d+)?)(px|pt|in|cm|mm|em|ex|%)?\z/)
+        return nil unless match
+
+        return nil if match[2] == "%"
+
+        value = match[1].to_f
+        case match[2]
+        when "pt" then value * (1.0 / 72.0) * 72.0 # PS uses points natively
+        when "in" then value * 72.0
+        when "cm" then value * (72.0 / 2.54)
+        when "mm" then value * (72.0 / 25.4)
+        else value
+        end
+      end
+
+      def number_list(text)
+        return [] if text.nil? || text.empty?
+
+        text.scan(/-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?/).map(&:to_f)
+      end
+
+      def number(text, default: nil)
+        return default if text.nil? || text.empty?
+
+        match = text.strip.match(/\A(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)\z/)
+        match ? match[1].to_f : default
+      end
+    end
+  end
+end

data/lib/postsvg/svg/clip_path_registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Indexes <clipPath id="..."> definitions in a document so handlers
+    # can resolve url(#id) references without re-walking the tree.
+    class ClipPathRegistry
+      attr_reader :by_id
+
+      def initialize(by_id = {})
+        @by_id = by_id.dup.freeze
+        freeze
+      end
+
+      def self.empty
+        @empty ||= new({})
+      end
+
+      def lookup(id)
+        @by_id[id]
+      end
+
+      def key?(id)
+        @by_id.key?(id)
+      end
+
+      # Build a registry by scanning +root+ for <clipPath> children.
+      def self.from_node(root)
+        registry = {}
+        root.xpath(".//*[local-name()='clipPath']").each do |node|
+          id = node["id"]
+          next unless id
+
+          # Concatenate the d attributes of all child <path> elements
+          # in document order. Other shape children are converted to
+          # path data lazily; for now we only support <path>.
+          ds = node.xpath(".//*[local-name()='path']").filter_map do |p|
+            p["d"]
+          end
+          registry[id] = ds.join(" ") unless ds.empty?
+        end
+        new(registry)
+      end
+    end
+  end
+end

data/lib/postsvg/svg/document.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Root value object produced by Svg::Parser. Carries the SVG root
+    # element, the document's viewBox / width / height (parsed once),
+    # and the ClipPathRegistry assembled from <defs>.
+    class Document
+      attr_reader :root_element, :viewbox, :width, :height, :clip_paths
+
+      def initialize(root_element:, viewbox: nil, width: nil, height: nil,
+                     clip_paths: ClipPathRegistry.empty)
+        @root_element = root_element
+        @viewbox = viewbox
+        @width = width
+        @height = height
+        @clip_paths = clip_paths
+        freeze
+      end
+    end
+  end
+end