fontisan 0.4.6 → 0.4.7

data/lib/fontisan/svg_to_glyf/geometry/affine_transform.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Geometry
+      # A 2×3 affine transform representing:
+      #
+      #   x' = a·x + c·y + e
+      #   y' = b·x + d·y + f
+      #
+      # Every coordinate operation in SvgToGlyf (SVG group transforms,
+      # viewBox mapping, Y-flip, UPM scaling) is modeled as an
+      # AffineTransform so they can be composed into a single matrix
+      # applied once per point.
+      class AffineTransform
+        attr_reader :a, :b, :c, :d, :e, :f
+
+        # @param a [Float] x-scale
+        # @param b [Float] y-skew-x
+        # @param c [Float] x-skew-y
+        # @param d [Float] y-scale
+        # @param e [Float] x-translate
+        # @param f [Float] y-translate
+        def initialize(a, b, c, d, e, f)
+          @a = a.to_f
+          @b = b.to_f
+          @c = c.to_f
+          @d = d.to_f
+          @e = e.to_f
+          @f = f.to_f
+        end
+
+        def self.identity
+          new(1, 0, 0, 1, 0, 0)
+        end
+
+        def self.translate(tx, ty = 0)
+          new(1, 0, 0, 1, tx, ty)
+        end
+
+        def self.scale(sx, sy = nil)
+          sy = sx if sy.nil?
+          new(sx, 0, 0, sy, 0, 0)
+        end
+
+        def self.rotate_radians(angle)
+          cos = Math.cos(angle)
+          sin = Math.sin(angle)
+          new(cos, sin, -sin, cos, 0, 0)
+        end
+
+        def self.rotate_degrees(angle)
+          rotate_radians(angle.to_f * Math::PI / 180.0)
+        end
+
+        def self.skew_x_radians(angle)
+          new(1, 0, Math.tan(angle), 1, 0, 0)
+        end
+
+        def self.skew_y_radians(angle)
+          new(1, Math.tan(angle), 0, 1, 0, 0)
+        end
+
+        # Reflect across a horizontal line at y = axis.
+        # Points above the axis map below it and vice versa.
+        def self.flip_y(axis)
+          new(1, 0, 0, -1, 0, 2 * axis)
+        end
+
+        # Compose this transform with `other`, returning a new
+        # AffineTransform equivalent to applying `other` first,
+        # then `self`. This matches SVG's `transform="self other"`
+        # convention.
+        #
+        #   result.apply(x, y) == self.apply(*other.apply(x, y))
+        def compose(other)
+          AffineTransform.new(
+            @a * other.a + @c * other.b,
+            @b * other.a + @d * other.b,
+            @a * other.c + @c * other.d,
+            @b * other.c + @d * other.d,
+            @a * other.e + @c * other.f + @e,
+            @b * other.e + @d * other.f + @f,
+          )
+        end
+
+        # @param x [Numeric]
+        # @param y [Numeric]
+        # @return [Array(Float, Float)] transformed [x', y']
+        def apply(x, y)
+          [@a * x + @c * y + @e, @b * x + @d * y + @f]
+        end
+
+        def identity?
+          @a == 1 && @b.zero? && @c.zero? && @d == 1 && @e.zero? && @f.zero?
+        end
+
+        def ==(other)
+          other.is_a?(AffineTransform) &&
+            @a == other.a && @b == other.b && @c == other.c &&
+            @d == other.d && @e == other.e && @f == other.f
+        end
+
+        alias eql? ==
+
+        def hash
+          [@a, @b, @c, @d, @e, @f].hash
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/geometry/normalizer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Geometry
+      # Computes the affine transform that maps SVG viewBox coordinates
+      # (Y-down, origin at top-left) into font coordinates (Y-up, origin
+      # at bottom-left, scaled to UPM).
+      #
+      # The normalization combines a Y-flip across the viewBox midline
+      # with a uniform scale from viewBox units to font units. The
+      # resulting matrix is then composed with the SVG document's
+      # accumulated group transform to produce the final per-point
+      # transform.
+      class Normalizer
+        attr_reader :viewbox_width, :viewbox_height, :upm
+
+        # @param viewbox_width [Float] SVG viewBox width
+        # @param viewbox_height [Float] SVG viewBox height
+        # @param upm [Integer] font units-per-em
+        def initialize(viewbox_width:, viewbox_height:, upm:)
+          @viewbox_width = viewbox_width.to_f
+          @viewbox_height = viewbox_height.to_f
+          @upm = upm.to_f
+        end
+
+        # @return [AffineTransform] the viewBox→font normalization
+        def matrix
+          sx = @upm / @viewbox_width
+          sy = @upm / @viewbox_height
+          AffineTransform.new(sx, 0, 0, -sy, 0, @upm)
+        end
+
+        # Compose the normalization with an SVG group transform,
+        # producing the final per-point transform.
+        #
+        # @param group_transform [AffineTransform] accumulated <g> transforms
+        # @return [AffineTransform] final transform: font_point = N · T · path_point
+        def final_transform(group_transform = AffineTransform.identity)
+          matrix.compose(group_transform)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/geometry/transform_parser.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Geometry
+      # Parses an SVG `transform="..."` attribute string into a single
+      # AffineTransform representing the accumulated composition.
+      #
+      # Supports all six SVG transform functions:
+      #   translate, scale, rotate, matrix, skewX, skewY
+      #
+      # Multiple functions compose left-to-right (leftmost is applied
+      # last to the point), matching the SVG specification.
+      module TransformParser
+        FUNCTION_RE = /(\w+)\s*\(([^)]*)\)/
+
+        # @param transform_string [String, nil] the SVG transform attribute
+        # @return [AffineTransform]
+        def self.parse(transform_string)
+          return AffineTransform.identity if transform_string.nil? || transform_string.strip.empty?
+
+          transforms = transform_string.scan(FUNCTION_RE).map do |name, args|
+            build_transform(name, args)
+          end
+          transforms.reduce(AffineTransform.identity) { |acc, t| acc.compose(t) }
+        end
+
+        def self.build_transform(name, args_string)
+          args = parse_args(args_string)
+          case name
+          when "translate" then build_translate(args)
+          when "scale" then build_scale(args)
+          when "rotate" then build_rotate(args)
+          when "matrix" then build_matrix(args)
+          when "skewX" then AffineTransform.skew_x_radians(degrees_to_radians(args.fetch(0)))
+          when "skewY" then AffineTransform.skew_y_radians(degrees_to_radians(args.fetch(0)))
+          else
+            raise ArgumentError, "unknown SVG transform function: #{name.inspect}"
+          end
+        end
+
+        def self.build_translate(args)
+          AffineTransform.translate(args.fetch(0, 0), args.fetch(1, 0))
+        end
+
+        def self.build_scale(args)
+          sx = args.fetch(0, 1)
+          sy = args.fetch(1, sx)
+          AffineTransform.scale(sx, sy)
+        end
+
+        def self.build_rotate(args)
+          angle = args.fetch(0)
+          return AffineTransform.rotate_degrees(angle) if args.size < 3
+
+          cx = args.fetch(1)
+          cy = args.fetch(2)
+          around_point(AffineTransform.rotate_degrees(angle), cx, cy)
+        end
+
+        def self.build_matrix(args)
+          raise ArgumentError, "matrix() requires 6 arguments, got #{args.size}" if args.size != 6
+
+          AffineTransform.new(args[0], args[1], args[2], args[3], args[4], args[5])
+        end
+
+        # Rotate around a specific point: translate to origin, rotate,
+        # translate back.
+        def self.around_point(rotation, cx, cy)
+          AffineTransform.translate(cx, cy)
+            .compose(rotation)
+            .compose(AffineTransform.translate(-cx, -cy))
+        end
+
+        # Parse comma/whitespace-separated numbers from a function arg list.
+        def self.parse_args(args_string)
+          args_string.to_s.scan(/[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/)
+            .map(&:to_f)
+        end
+
+        def self.degrees_to_radians(degrees)
+          degrees.to_f * Math::PI / 180.0
+        end
+
+        private_class_method :build_transform, :build_translate, :build_scale,
+                             :build_rotate, :build_matrix, :around_point,
+                             :parse_args, :degrees_to_radians
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/geometry.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    # Geometry primitives for SvgToGlyf: affine transforms, SVG
+    # transform attribute parsing, and coordinate normalization.
+    module Geometry
+      autoload :AffineTransform, "fontisan/svg_to_glyf/geometry/affine_transform"
+      autoload :TransformParser, "fontisan/svg_to_glyf/geometry/transform_parser"
+      autoload :Normalizer, "fontisan/svg_to_glyf/geometry/normalizer"
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/path/command.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Path
+      # A single parsed SVG path command.
+      #
+      # @attr type [Symbol] one of :M, :L, :H, :V, :C, :S, :Q, :T, :Z
+      # @attr absolute [Boolean] true for uppercase (absolute), false for lowercase (relative)
+      # @attr args [Array<Float>] the numeric arguments in order
+      Command = Struct.new(:type, :absolute, :args, keyword_init: true) do
+        def relative?
+          !absolute
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/path/contour_builder.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Path
+      # Converts an array of Path::Command objects into an array of
+      # Fontisan::Ufo::Contour objects.
+      #
+      # Tracks current-point, subpath-start, and previous-control-point
+      # state to resolve relative coordinates and smooth-curve reflections.
+      #
+      # Point type mapping (Ufo::Point types):
+      #   M (first in subpath) → first point of contour, type "line"
+      #   L / H / V            → "line"
+      #   C                    → "offcurve", "offcurve", "curve"
+      #   S                    → reflected "offcurve", "offcurve", "curve"
+      #   Q                    → "offcurve", "qcurve"
+      #   T                    → reflected "offcurve", "qcurve"
+      #   Z                    → closes the contour (no point emitted)
+      class ContourBuilder
+        # @param commands [Array<Path::Command>]
+        # @return [Array<Fontisan::Ufo::Contour>]
+        def build(commands)
+          state = State.new
+          commands.each { |cmd| apply(cmd, state) }
+          state.finalize_contour
+          state.contours
+        end
+
+        private
+
+        def apply(cmd, state)
+          case cmd.type
+          when :M then handle_move(cmd, state)
+          when :L then handle_line(cmd, state)
+          when :H then handle_horizontal(cmd, state)
+          when :V then handle_vertical(cmd, state)
+          when :C then handle_cubic(cmd, state)
+          when :S then handle_smooth_cubic(cmd, state)
+          when :Q then handle_quadratic(cmd, state)
+          when :T then handle_smooth_quadratic(cmd, state)
+          when :Z then state.close_contour
+          end
+        end
+
+        def handle_move(cmd, state)
+          x, y = resolve_pair(cmd, state.current)
+          state.start_contour(x, y)
+        end
+
+        def handle_line(cmd, state)
+          x, y = resolve_pair(cmd, state.current)
+          state.add_point(x, y, "line")
+          state.reset_controls
+        end
+
+        def handle_horizontal(cmd, state)
+          dx = cmd.absolute ? cmd.args[0] - state.current[0] : cmd.args[0]
+          x = state.current[0] + dx
+          y = state.current[1]
+          state.add_point(x, y, "line")
+          state.reset_controls
+        end
+
+        def handle_vertical(cmd, state)
+          dy = cmd.absolute ? cmd.args[0] - state.current[1] : cmd.args[0]
+          x = state.current[0]
+          y = state.current[1] + dy
+          state.add_point(x, y, "line")
+          state.reset_controls
+        end
+
+        def handle_cubic(cmd, state)
+          base = state.current
+          c1 = resolve_pair_at(cmd, base, 0)
+          c2 = resolve_pair_at(cmd, base, 2)
+          endpoint = resolve_pair_at(cmd, base, 4)
+
+          state.add_point(c1[0], c1[1], "offcurve")
+          state.add_point(c2[0], c2[1], "offcurve")
+          state.add_point(endpoint[0], endpoint[1], "curve")
+          state.cubic_control = c2
+        end
+
+        def handle_smooth_cubic(cmd, state)
+          base = state.current
+          reflected = reflect(state.cubic_control, base)
+          c2 = resolve_pair_at(cmd, base, 0)
+          endpoint = resolve_pair_at(cmd, base, 2)
+
+          state.add_point(reflected[0], reflected[1], "offcurve")
+          state.add_point(c2[0], c2[1], "offcurve")
+          state.add_point(endpoint[0], endpoint[1], "curve")
+          state.cubic_control = c2
+        end
+
+        def handle_quadratic(cmd, state)
+          base = state.current
+          control = resolve_pair_at(cmd, base, 0)
+          endpoint = resolve_pair_at(cmd, base, 2)
+
+          state.add_point(control[0], control[1], "offcurve")
+          state.add_point(endpoint[0], endpoint[1], "qcurve")
+          state.quad_control = control
+        end
+
+        def handle_smooth_quadratic(cmd, state)
+          base = state.current
+          reflected = reflect(state.quad_control, base)
+          endpoint = resolve_pair_at(cmd, base, 0)
+
+          state.add_point(reflected[0], reflected[1], "offcurve")
+          state.add_point(endpoint[0], endpoint[1], "qcurve")
+          state.quad_control = reflected
+        end
+
+        # Resolve an (x,y) pair from a command at the given arg offset.
+        # Absolute: use args directly. Relative: add to base point.
+        def resolve_pair_at(cmd, base, offset)
+          if cmd.absolute
+            [cmd.args[offset], cmd.args[offset + 1]]
+          else
+            [base[0] + cmd.args[offset], base[1] + cmd.args[offset + 1]]
+          end
+        end
+
+        def resolve_pair(cmd, base)
+          resolve_pair_at(cmd, base, 0)
+        end
+
+        # Reflect a control point through the current point.
+        def reflect(control, current)
+          return current unless control
+
+          [2 * current[0] - control[0], 2 * current[1] - control[1]]
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/path/parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Path
+      # Tokenizes an SVG path `d` attribute string and groups the
+      # tokens into typed Command objects, handling implicit command
+      # repetition.
+      #
+      # Arc (A/a) is not supported — ucode chart SVGs use cubic
+      # curves exclusively. Encountering A raises a clear ArgumentError.
+      module Parser
+        COMMAND_RE = /[MmLlHhVvCcSsQqTtAaZz]/
+        NUMBER_RE = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/
+        TOKEN_RE = /#{COMMAND_RE}|#{NUMBER_RE}/
+
+        # Expected argument count per command letter.
+        ARITY = {
+          "M" => 2, "L" => 2, "H" => 1, "V" => 1,
+          "C" => 6, "S" => 4, "Q" => 4, "T" => 2,
+          "Z" => 0
+        }.freeze
+
+        # @param d_string [String] SVG path data
+        # @return [Array<Command>]
+        def self.parse(d_string)
+          tokens = tokenize(d_string)
+          group_into_commands(tokens)
+        end
+
+        def self.tokenize(d_string)
+          d_string.to_s.scan(TOKEN_RE).map do |tok|
+            COMMAND_RE.match?(tok) ? [:command, tok] : [:number, tok.to_f]
+          end
+        end
+
+        # Walk the token stream. After a command letter, consume its
+        # arity's worth of numbers per command; extra numbers repeat
+        # the command. After M/m, subsequent pairs become implicit L/l.
+        def self.group_into_commands(tokens)
+          commands = []
+          current = nil
+          args = []
+
+          tokens.each do |type, value|
+            if type == :command
+              check_arc!(value)
+              if value.upcase == "Z"
+                commands << build_command(value, [])
+                current = nil
+              else
+                current = value
+              end
+              args = []
+              next
+            end
+
+            next unless current
+
+            arity = ARITY.fetch(current.upcase)
+            args << value
+
+            next unless args.size >= arity
+
+            commands << build_command(current, args.shift(arity))
+            current = implicit_repeat_letter(current) if current.upcase == "M"
+          end
+
+          commands
+        end
+
+        def self.build_command(letter, args)
+          Command.new(
+            type: letter.upcase.to_sym,
+            absolute: letter == letter.upcase,
+            args: args,
+          )
+        end
+
+        # After M/m, subsequent coordinate pairs become L/l (SVG spec).
+        def self.implicit_repeat_letter(letter)
+          letter == letter.upcase ? "L" : "l"
+        end
+
+        def self.check_arc!(letter)
+          return unless letter && letter.upcase == "A"
+
+          raise ArgumentError,
+                "SVG arc command (A/a) is not supported by SvgToGlyf. " \
+                "Convert arcs to cubic curves first."
+        end
+
+        private_class_method :tokenize, :group_into_commands, :build_command,
+                             :implicit_repeat_letter, :check_arc!
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/path/state.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    module Path
+      # Mutable state carried through the contour-building walk.
+      # Tracks the current pen position, the subpath start (for Z
+      # closure), the last cubic and quadratic control points (for
+      # smooth-curve reflection), and the contour being assembled.
+      class State
+        attr_reader :contours, :current, :subpath_start,
+                    :cubic_control, :quad_control
+
+        def initialize
+          @contours = []
+          @current = nil
+          @subpath_start = nil
+          @cubic_control = nil
+          @quad_control = nil
+          @pending = nil
+        end
+
+        # Start a new subpath at (x, y). Flushes any in-progress contour.
+        def start_contour(x, y)
+          finalize_contour
+          @pending = []
+          add_point(x, y, "line")
+          @subpath_start = [x, y]
+          @cubic_control = nil
+          @quad_control = nil
+        end
+
+        # Append a point to the current contour and advance current position
+        # for on-curve points (off-curve control points do not advance).
+        def add_point(x, y, type)
+          return unless @pending
+
+          @pending << Fontisan::Ufo::Point.new(x: x, y: y, type: type)
+          return if type == "offcurve"
+
+          @current = [x, y]
+        end
+
+        # Mark the end of the current subpath. The contour is closed
+        # implicitly (UFO contours wrap around). Reset current to the
+        # subpath start so a subsequent M picks up from the right place.
+        def close_contour
+          return unless @pending
+
+          finalize_contour
+          @current = @subpath_start
+        end
+
+        # Flush the in-progress contour into the contours list if it
+        # has more than one point (a lone M with nothing else is
+        # degenerate and dropped).
+        def finalize_contour
+          return unless @pending
+
+          @contours << Fontisan::Ufo::Contour.new(@pending) if @pending.size > 1
+          @pending = nil
+        end
+
+        def cubic_control=(value)
+          @cubic_control = value
+        end
+
+        def quad_control=(value)
+          @quad_control = value
+        end
+
+        def reset_controls
+          @cubic_control = nil
+          @quad_control = nil
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf/path.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module SvgToGlyf
+    # SVG path parsing: tokenize the `d` attribute and produce typed
+    # Command value objects ready for contour assembly.
+    module Path
+      autoload :Command, "fontisan/svg_to_glyf/path/command"
+      autoload :Parser, "fontisan/svg_to_glyf/path/parser"
+      autoload :State, "fontisan/svg_to_glyf/path/state"
+      autoload :ContourBuilder, "fontisan/svg_to_glyf/path/contour_builder"
+    end
+  end
+end

data/lib/fontisan/svg_to_glyf.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::SvgToGlyf namespace.
+#
+# SvgToGlyf converts SVG path data (as produced by ucode's code-chart
+# extraction) into Ufo::Glyph objects that feed directly into the
+# existing UFO → TTF compile pipeline.
+#
+# The cubic-to-quadratic conversion and contour winding correction
+# are handled automatically by Ufo::Compile::Filters::CubicToQuadratic
+# and ReverseContourDirection when the glyph is compiled to TTF.
+# SvgToGlyf only needs to parse the SVG and emit cubic contours.
+module Fontisan
+  module SvgToGlyf
+    autoload :Geometry, "fontisan/svg_to_glyf/geometry"
+    autoload :Path, "fontisan/svg_to_glyf/path"
+    autoload :Document, "fontisan/svg_to_glyf/document"
+    autoload :Assembler, "fontisan/svg_to_glyf/assembler"
+
+    DEFAULT_UPM = 1000
+
+    # Convert an SVG path `d` string into a Ufo::Glyph.
+    #
+    # @param path_data [String] SVG path commands (e.g., "M 0 0 L 100 100 Z")
+    # @param upm [Integer] target font units-per-em
+    # @param codepoint [Integer, nil] Unicode codepoint to assign
+    # @param name [String, nil] glyph name (defaults to uni{codepoint.hex})
+    # @param viewbox [Hash{Symbol=>Float}, nil] SVG viewbox with :width, :height
+    # @param transform [Fontisan::SvgToGlyf::Geometry::AffineTransform, nil]
+    #   accumulated group transform
+    # @return [Fontisan::Ufo::Glyph]
+    def self.convert(path_data, upm: DEFAULT_UPM, codepoint: nil, name: nil,
+                     viewbox: nil, transform: nil)
+      Assembler.new(upm: upm).build_from_path_data(
+        path_data, codepoint: codepoint, name: name,
+                   viewbox: viewbox, transform: transform
+      )
+    end
+
+    # Convert an SVG file into a Ufo::Glyph.
+    #
+    # @param file_path [String] path to an .svg file
+    # @param upm [Integer] target font units-per-em
+    # @param codepoint [Integer, nil] override the codepoint (otherwise
+    #   derived from the filename if it matches U+XXXX.svg)
+    # @return [Fontisan::Ufo::Glyph]
+    def self.from_svg_file(file_path, upm: DEFAULT_UPM, codepoint: nil)
+      Assembler.new(upm: upm).build_from_file(file_path, codepoint: codepoint)
+    end
+
+    # Convert a directory of SVG files into a Ufo::Font, one glyph per file.
+    #
+    # Filenames must encode a codepoint: U+XXXX.svg or hexcode.svg.
+    #
+    # @param dir [String] directory containing .svg files
+    # @param upm [Integer] target font units-per-em
+    # @return [Fontisan::Ufo::Font]
+    def self.from_directory(dir, upm: DEFAULT_UPM)
+      Assembler.new(upm: upm).build_from_directory(dir)
+    end
+  end
+end