postsvg 0.2.2 → 0.3.0

data/lib/postsvg/source/lexer.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Postsvg
+  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/postsvg/source/operand_stack.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Postsvg
+  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/postsvg/source.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Postsvg
+  # 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 Postsvg::LexError
+  # and Postsvg::SyntaxError respectively.
+  module Source
+    autoload :Lexer, "postsvg/source/lexer"
+    autoload :AstBuilder, "postsvg/source/ast_builder"
+    autoload :OperandStack, "postsvg/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/postsvg/svg/clip_path_registry.rb

@@ -34,9 +34,7 @@ module Postsvg
           # 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
+          ds = node.xpath(".//*[local-name()='path']").map { |p| p["d"] }.compact
           registry[id] = ds.join(" ") unless ds.empty?
         end
         new(registry)

data/lib/postsvg/svg/element.rb

@@ -62,9 +62,7 @@ module Postsvg
           return subclass.from_node(node) if subclass
 
           OpenElement.new(name: node.name,
-                          children: node.element_children.map do |c|
-                            from_node(c)
-                          end)
+                          children: node.element_children.map { |c| from_node(c) })
         end
       end
     end

data/lib/postsvg/svg/elements/ellipse.rb

@@ -9,8 +9,7 @@ module Postsvg
 
         attr_reader :cx, :cy, :rx, :ry, :fill, :stroke_paint, :stroke
 
-        def initialize(cx:, cy:, rx:, ry:, fill:, stroke_paint:, stroke:,
-**rest)
+        def initialize(cx:, cy:, rx:, ry:, fill:, stroke_paint:, stroke:, **rest)
           super(**rest)
           @cx = cx
           @cy = cy

data/lib/postsvg/svg/elements/svg.rb

@@ -9,8 +9,7 @@ module Postsvg
 
         attr_reader :viewbox, :width, :height, :children
 
-        def initialize(viewbox: nil, width: nil, height: nil, children: [],
-**rest)
+        def initialize(viewbox: nil, width: nil, height: nil, children: [], **rest)
           super(**rest)
           @viewbox = viewbox
           @width = width

data/lib/postsvg/svg/paint.rb

@@ -15,7 +15,7 @@ module Postsvg
         end
 
         color = begin
-          ::Postscript::Color.parse(text.to_s)
+          ::Postsvg::Color.parse(text.to_s)
         rescue ArgumentError
           nil
         end

data/lib/postsvg/svg/path_data/parser.rb

@@ -10,7 +10,7 @@ module Postsvg
         module_function
 
         COMMAND_RE = /([MmLlHhVvCcSsQqTtAaZz])/
-        ARG_RE = /(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/
+        ARG_RE = /(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/.freeze
 
         def parse(text)
           return [] if text.nil? || text.empty?
@@ -36,11 +36,7 @@ module Postsvg
               commands << Command.new(opcode: opcode, args: args)
               i += consumed
               # After moveto, implicit lineto for subsequent tuples.
-              opcode = if opcode == "M"
-                         "L"
-                       else
-                         (opcode == "m" ? "l" : opcode)
-                       end
+              opcode = (opcode == "M") ? "L" : (opcode == "m" ? "l" : opcode)
               # For H/V/Z, no implicit repetition.
               break if %w[H V Z h v z].include?(opcode)
             end
@@ -61,12 +57,12 @@ module Postsvg
         end
 
         def tokenize(text)
-          text.to_s.gsub("-", " -")
-            .scan(/([MmLlHhVvCcSsQqTtAaZz])|(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/)
-            .flatten.compact
+          text.to_s.gsub(/-/, " -")
+               .scan(/([MmLlHhVvCcSsQqTtAaZz])|(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)/)
+               .flatten.compact
         end
 
-        NUMBER_ONLY_RE = /\A-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?\z/
+        NUMBER_ONLY_RE = /\A-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?\z/.freeze
 
         def take_args(tokens, start, count)
           args = []

data/lib/postsvg/svg/stroke.rb

@@ -14,12 +14,10 @@ module Postsvg
           if dasharray_raw && dasharray_raw != "none"
             AttributeParser.number_list(dasharray_raw)
           end
-        dashoffset = AttributeParser.number(node["stroke-dashoffset"],
-                                            default: 0.0)
+        dashoffset = AttributeParser.number(node["stroke-dashoffset"], default: 0.0)
         linecap = (node["stroke-linecap"] || "butt").to_sym
         linejoin = (node["stroke-linejoin"] || "miter").to_sym
-        miterlimit = AttributeParser.number(node["stroke-miterlimit"],
-                                            default: 10.0)
+        miterlimit = AttributeParser.number(node["stroke-miterlimit"], default: 10.0)
         new(width: width, dasharray: dasharray, dashoffset: dashoffset,
             linecap: linecap, linejoin: linejoin, miterlimit: miterlimit)
       end

data/lib/postsvg/svg/transform_list.rb

@@ -3,7 +3,7 @@
 module Postsvg
   module Svg
     # Parsed SVG transform attribute. Produces a list of
-    # Postscript::Matrix instances that, multiplied in order, give the
+    # Postsvg::Matrix instances that, multiplied in order, give the
     # composite CTM for the element.
     class TransformList
       attr_reader :matrices

data/lib/postsvg/svg_builder.rb

@@ -11,9 +11,9 @@ module Postsvg
   # - <defs> block orders clipPaths, gradients, then patterns by
   #   registration order so output is reproducible.
   class SvgBuilder
-    CLIP_PREFIX = "clip"
-    GRADIENT_PREFIX = "grad"
-    PATTERN_PREFIX = "pattern"
+    CLIP_PREFIX = "clip".freeze
+    GRADIENT_PREFIX = "grad".freeze
+    PATTERN_PREFIX = "pattern".freeze
 
     def initialize
       @buffer = String.new(capacity: 4096)
@@ -132,7 +132,7 @@ module Postsvg
     def path(d:, mode:, color: nil, stroke_color: nil,
              stroke_width: nil, line_cap: nil, line_join: nil,
              dash: nil, clip_path_id: nil, fill_id: nil)
-      attrs = "d=\"#{d}\""
+      attrs = +"d=\"#{d}\""
 
       attrs << case mode
                when :fill
@@ -140,8 +140,7 @@ module Postsvg
                when :stroke
                  %( fill="none" stroke="#{color_attr(stroke_color || color)}")
                when :fill_and_stroke
-                 "#{fill_attr(color,
-                              fill_id)} stroke=\"#{color_attr(stroke_color || color)}\""
+                 "#{fill_attr(color, fill_id)} stroke=\"#{color_attr(stroke_color || color)}\""
                else
                  %( fill="none" stroke="none")
                end
@@ -185,10 +184,7 @@ module Postsvg
 
     def close_svg
       raise RenderError, "svg not open" unless @svg_open
-      if @group_depth.positive?
-        raise RenderError,
-              "unclosed groups: #{@group_depth}"
-      end
+      raise RenderError, "unclosed groups: #{@group_depth}" if @group_depth.positive?
 
       @buffer << "<defs>\n" unless @clip_paths.empty? && @gradients.empty? && @patterns.empty?
       @buffer << @defs_buffer
@@ -243,11 +239,11 @@ module Postsvg
 
     def escape(text)
       text.to_s
-        .gsub("&", "&amp;")
-        .gsub("<", "&lt;")
-        .gsub(">", "&gt;")
-        .gsub('"', "&quot;")
-        .gsub("'", "&#39;")
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&#39;")
     end
   end
 end

data/lib/postsvg/translation/arc_converter.rb

@@ -26,8 +26,8 @@ module Postsvg
         # Step 1: rotate and scale (x1,y1) into the unit-circle frame.
         dx = (x1 - x2) / 2.0
         dy = (y1 - y2) / 2.0
-        x1p = (cos_phi * dx) + (sin_phi * dy)
-        y1p = (-sin_phi * dx) + (cos_phi * dy)
+        x1p =  cos_phi * dx + sin_phi * dy
+        y1p = -sin_phi * dx + cos_phi * dy
 
         # Ensure radii are large enough; if not, scale them up.
         rx_sq = rx * rx
@@ -44,17 +44,17 @@ module Postsvg
         end
 
         # Step 2: compute center (cx', cy') in the rotated frame.
-        sign = large_arc == sweep ? -1 : 1
-        num = (rx_sq * ry_sq) - (rx_sq * y1p_sq) - (ry_sq * x1p_sq)
-        den = (rx_sq * y1p_sq) + (ry_sq * x1p_sq)
+        sign = (large_arc == sweep) ? -1 : 1
+        num = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq
+        den = rx_sq * y1p_sq + ry_sq * x1p_sq
         den = EPSILON if den.abs < EPSILON
         coef = sign * Math.sqrt([num / den, 0.0].max)
         cxp =  coef * (rx * y1p) / ry
         cyp = -coef * (ry * x1p) / rx
 
         # Step 3: rotate (cx', cy') back into original frame.
-        cx = (cos_phi * cxp) - (sin_phi * cyp) + ((x1 + x2) / 2.0)
-        cy = (sin_phi * cxp) + (cos_phi * cyp) + ((y1 + y2) / 2.0)
+        cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2.0
+        cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2.0
 
         # Step 4: compute angles.
         ux = (x1p - cxp) / rx
@@ -73,23 +73,13 @@ module Postsvg
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
 
       def angle_between(ux, uy, vx, vy)
-        len = vector_length(ux, uy, vx, vy)
+        dot = ux * vx + uy * vy
+        len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy))
         return 0.0 if len < EPSILON
 
-        cos_val = (dot_product(ux, uy, vx, vy) / len).clamp(-1.0, 1.0)
-        cross_sign(ux, uy, vx, vy) * Math.acos(cos_val)
-      end
-
-      def vector_length(ux, uy, vx, vy)
-        Math.sqrt(((ux * ux) + (uy * uy)) * ((vx * vx) + (vy * vy)))
-      end
-
-      def dot_product(ux, uy, vx, vy)
-        (ux * vx) + (uy * vy)
-      end
-
-      def cross_sign(ux, uy, vx, vy)
-        ((ux * vy) - (uy * vx)).negative? ? -1.0 : 1.0
+        cos_val = (dot / len).clamp(-1.0, 1.0)
+        sign = (ux * vy - uy * vx).negative? ? -1.0 : 1.0
+        sign * Math.acos(cos_val)
       end
     end
   end

data/lib/postsvg/translation/bounding_box.rb

@@ -27,14 +27,11 @@ module Postsvg
       def expand(x_range, y_range)
         return self if x_range.nil? || y_range.nil?
 
-        new_min_x = [(empty? ? x_range.begin : @min_x),
-                     x_range.begin].compact.min
+        new_min_x = [(empty? ? x_range.begin : @min_x), x_range.begin].compact.min
         new_max_x = [(empty? ? x_range.end : @max_x), x_range.end].compact.max
-        new_min_y = [(empty? ? y_range.begin : @min_y),
-                     y_range.begin].compact.min
+        new_min_y = [(empty? ? y_range.begin : @min_y), y_range.begin].compact.min
         new_max_y = [(empty? ? y_range.end : @max_y), y_range.end].compact.max
-        BoundingBox.new(min_x: new_min_x, min_y: new_min_y, max_x: new_max_x,
-                        max_y: new_max_y)
+        BoundingBox.new(min_x: new_min_x, min_y: new_min_y, max_x: new_max_x, max_y: new_max_y)
       end
 
       def to_a
@@ -54,7 +51,7 @@ module Postsvg
 
         "%s %s %s %s" % [
           FormatNumber.call(@min_x), FormatNumber.call(@min_y),
-          FormatNumber.call(@max_x), FormatNumber.call(@max_y)
+          FormatNumber.call(@max_x), FormatNumber.call(@max_y),
         ]
       end
     end

data/lib/postsvg/translation/handlers/circle_handler.rb

@@ -15,8 +15,8 @@ module Postsvg
           cy = element.cy
           if r.to_f.positive?
             context.emitter.emit(Model::Operators::Path::Arc.new(
-                                   x: cx, y: cy, radius: r, angle1: 0, angle2: 360,
-                                 ))
+              x: cx, y: cy, radius: r, angle1: 0, angle2: 360,
+            ))
           end
           emit_paint(element, context)
           context.emitter.emit(Model::Operators::GraphicsState::Grestore.new)