fontisan 0.4.11 → 0.4.12

data/lib/fontisan/svg/standalone_glyph.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Svg
+    # Renders a single UFO glyph as a standalone SVG document (a
+    # `<svg>` root with one `<path>` and a viewBox sized to the
+    # glyph's bounding box). Distinct from {FontGenerator}, which
+    # emits a `<svg><defs><font>` document covering every glyph.
+    #
+    # Used by the `fontisan ufo extract` CLI command and by
+    # downstream consumers that want per-glyph SVG exports without
+    # having to slice up a font-format SVG themselves.
+    #
+    # Path rendering supports quadratic and cubic Bezier curves
+    # (UFO's standard outline model). Curve logic is inlined here
+    # rather than reaching into GlyphGenerator's private path code
+    # — that logic is font-format-specific (Y-axis flip via
+    # ViewBoxCalculator) and doesn't cleanly factor out.
+    class StandaloneGlyph
+      # @param units_per_em [Integer] font units-per-em (default 1000)
+      # @param ascent [Integer] font ascender in font units (default 800)
+      # @param descent [Integer] font descender in font units (default -200)
+      def initialize(units_per_em: 1000, ascent: 800, descent: -200)
+        @units_per_em = units_per_em.to_i
+        @ascent = ascent.to_i
+        @descent = descent.to_i
+      end
+
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String] standalone SVG XML
+      def generate(glyph)
+        path_data = path_data_for(glyph)
+        view_box = view_box_for(glyph)
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="#{view_box}">
+            <path d="#{path_data}"/>
+          </svg>
+        SVG
+      end
+
+      private
+
+      def path_data_for(glyph)
+        return "" if glyph.contours.empty?
+
+        glyph.contours.filter_map { |c| contour_path(c) }.join(" ")
+      end
+
+      # Emit an SVG path for one contour with Y-axis flip applied.
+      # Walks points left-to-right; collects off-curve runs and
+      # flushes them as a Bezier curve (Q for 1 control point, C
+      # for 2). Single on-curve points become line segments.
+      def contour_path(contour)
+        points = contour.points
+        return nil if points.empty?
+
+        parts = []
+        first = points.first
+        parts << "M #{first.x} #{flip_y(first.y)}"
+
+        i = 1
+        while i < points.length
+          if points[i].on_curve?
+            parts << "L #{points[i].x} #{flip_y(points[i].y)}"
+            i += 1
+          else
+            # Collect consecutive off-curve points (1 → quadratic,
+            # 2 → cubic, 3+ → rare; treat as multiple quadratics).
+            controls = []
+            while i < points.length && !points[i].on_curve?
+              controls << points[i]
+              i += 1
+            end
+            end_pt = i < points.length ? points[i] : first
+            i += 1 if i < points.length
+
+            parts << curve_segment(controls, end_pt)
+          end
+        end
+
+        parts << "Z"
+        parts.join(" ")
+      end
+
+      def curve_segment(controls, end_pt)
+        end_x = end_pt.x
+        end_y = flip_y(end_pt.y)
+
+        case controls.size
+        when 1
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{end_x} #{end_y}"
+        when 2
+          "C #{controls[0].x} #{flip_y(controls[0].y)} " \
+            "#{controls[1].x} #{flip_y(controls[1].y)} " \
+            "#{end_x} #{end_y}"
+        else
+          # 3+ controls: emit a Q to the midpoint of the first two,
+          # then continue. Rare in practice; degrades to Q chain.
+          mid_x = (controls[0].x + controls[1].x) / 2.0
+          mid_y = flip_y((controls[0].y + controls[1].y) / 2.0)
+          "Q #{controls[0].x} #{flip_y(controls[0].y)} #{mid_x} #{mid_y}"
+        end
+      end
+
+      def flip_y(y)
+        @ascent - y.to_f
+      end
+
+      def view_box_for(glyph)
+        bbox = bounding_box(glyph)
+        format("%<xmin>s %<ymin>s %<w>s %<h>s",
+               xmin: bbox[:x_min], ymin: bbox[:y_min],
+               w: (bbox[:x_max] - bbox[:x_min]),
+               h: (bbox[:y_max] - bbox[:y_min]))
+      end
+
+      def bounding_box(glyph)
+        points = glyph.contours.flat_map(&:points)
+        return { x_min: 0, y_min: 0, x_max: @units_per_em, y_max: @units_per_em } if points.empty?
+
+        xs = points.map(&:x)
+        ys = points.map(&:y)
+        { x_min: xs.min, y_min: ys.min, x_max: xs.max, y_max: ys.max }
+      end
+    end
+  end
+end

data/lib/fontisan/svg.rb

@@ -7,6 +7,7 @@ module Fontisan
     autoload :FontFaceGenerator, "fontisan/svg/font_face_generator"
     autoload :FontGenerator, "fontisan/svg/font_generator"
     autoload :GlyphGenerator, "fontisan/svg/glyph_generator"
+    autoload :StandaloneGlyph, "fontisan/svg/standalone_glyph"
     autoload :ViewBoxCalculator, "fontisan/svg/view_box_calculator"
   end
 end

data/lib/fontisan/ufo/cli.rb

@@ -14,20 +14,15 @@ module Fontisan
       method_option :output, type: :string, required: true,
                              desc: "Output file path"
       method_option :to, type: :string, default: "ttf",
-                         desc: "Output format (ttf or otf)"
+                         desc: "Output format (ttf, otf, or otf2)"
       def build(ufo)
         font = Font.open(ufo)
-        format_sym = (options[:to] || "ttf").to_s.downcase.to_sym
-        compiler =
-          case format_sym
-          when :ttf then Compile::TtfCompiler
-          when :otf then Compile::OtfCompiler
-          else
-            warn "unknown format: #{options[:to].inspect}"
-            exit 1
-          end
-        compiler.new(font).compile(output_path: options[:output])
+        format = (options[:to] || "ttf").to_s.downcase.to_sym
+        Convert.convert(font, to: format, output_path: options[:output])
         puts "wrote #{options[:output]} (#{File.size(options[:output])} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       rescue Errno::ENOENT
         warn "UFO not found: #{ufo}"
         exit 1
@@ -35,20 +30,12 @@ module Fontisan
 
       desc "convert INPUT OUTPUT", "Convert between UFO and binary formats"
       method_option :to, type: :string,
-                         desc: "Override format detection (ttf, otf, ufo)"
+                         desc: "Override format detection (ttf, otf, otf2, ufo)"
       def convert(input, output)
         if ufo?(input)
           font = Font.open(input)
           format = options[:to] || File.extname(output).delete(".").downcase
-          compiler =
-            case format.to_sym
-            when :ttf then Compile::TtfCompiler
-            when :otf then Compile::OtfCompiler
-            else
-              warn "unsupported output format: #{format.inspect}"
-              exit 1
-            end
-          compiler.new(font).compile(output_path: output)
+          Convert.convert(font, to: format.to_sym, output_path: output)
         else
           # Binary → UFO
           loaded = Fontisan::FontLoader.load(input)
@@ -56,6 +43,9 @@ module Fontisan
           Writer.new(ufo).write(output)
         end
         puts "wrote #{output}"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
       end
 
       desc "validate UFO", "Check a UFO source for structural issues"
@@ -75,6 +65,29 @@ module Fontisan
         end
       end
 
+      desc "extract UFO GLYPH_NAME OUTPUT.svg",
+           "Render a single glyph from a UFO as a standalone SVG"
+      def extract(ufo, glyph_name, output)
+        font = Font.open(ufo)
+        glyph = font.glyph(glyph_name)
+        raise ArgumentError, "glyph not found: #{glyph_name.inspect}" unless glyph
+
+        head = font.info
+        renderer = Fontisan::Svg::StandaloneGlyph.new(
+          units_per_em: head.units_per_em || 1000,
+          ascent: head.ascender || 800,
+          descent: head.descender || -200,
+        )
+        File.write(output, renderer.generate(glyph))
+        puts "wrote #{output} (#{File.size(output)} bytes)"
+      rescue ArgumentError => e
+        warn e.message
+        exit 1
+      rescue Errno::ENOENT
+        warn "UFO not found: #{ufo}"
+        exit 1
+      end
+
       private
 
       def ufo?(path)

data/lib/fontisan/ufo/compile/feature_writers/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Value object returned by every feature writer's +#write+
+        # method. Carries the structured data the corresponding
+        # table builder needs to encode the binary subtable.
+        #
+        # Writers return +nil+ instead when the UFO has no data for
+        # the feature — the compiler skips +nil+ outputs.
+        FeatureOutput = Struct.new(
+          :table_tag, # "GPOS", "GSUB", "GDEF"
+          :feature_tag, # "kern", "mark", "curs", etc. (nil for GDEF)
+          :lookup_type, # Integer GSUB/GPOS lookup type
+          :data,        # Hash — writer-specific structure
+          keyword_init: true,
+        ) do
+          def table_tag
+            self[:table_tag]
+          end
+
+          def feature_tag
+            self[:feature_tag]
+          end
+
+          def lookup_type
+            self[:lookup_type]
+          end
+
+          def data
+            self[:data]
+          end
+        end
+
+        # Abstract base class for feature writers. Concrete writers
+        # (Kern, Gdef, Mark, etc.) extend this and implement +#write+.
+        class Base
+          attr_reader :font
+
+          # @param font [Fontisan::Ufo::Font] the UFO source
+          def initialize(font)
+            @font = font
+          end
+
+          # @return [FeatureOutput, nil] structured data for the
+          #   feature, or +nil+ if the UFO has nothing for it
+          def write
+            raise NotImplementedError, "#{self.class} must implement #write"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/curs.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS Cursive (lookup type 3) — cursive attachment.
+        #
+        # Pairs glyphs via their entry and exit anchors for cursive
+        # (joining) scripts. UFO convention: a glyph's +<name>entry+
+        # and +<name>exit+ anchors define where it connects to its
+        # neighbors.
+        #
+        # Pairs every glyph that has at least one +entry+ anchor with
+        # every glyph that has the corresponding +exit+ anchor.
+        # Multiple entry/exit class names are supported.
+        class Curs < Base
+          LOOKUP_TYPE = 3
+          FEATURE_TAG = "curs"
+          TABLE_TAG = "GPOS"
+
+          # @return [FeatureOutput, nil]
+          def write
+            attachments = {}
+
+            entry_glyphs = glyphs_with_anchor(/entry\z/)
+            exit_glyphs = glyphs_with_anchor(/exit\z/)
+
+            return nil if entry_glyphs.empty? && exit_glyphs.empty?
+
+            # Cursive attachment: each glyph can be both a "previous"
+            # (with exit anchor) and "next" (with entry anchor) in
+            # a cursive chain. The GPOS builder handles the
+            # cross-references; we emit every glyph with its entry
+            # and/or exit anchor positions.
+            font.glyphs.each_value do |glyph|
+              entry = find_anchor(glyph, /entry\z/)
+              exit = find_anchor(glyph, /exit\z/)
+              next unless entry || exit
+
+              attachments[glyph.name] = {
+                entry: entry && [entry.x, entry.y],
+                exit: exit && [exit.x, exit.y],
+              }
+            end
+
+            return nil if attachments.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { attachments: attachments },
+            )
+          end
+
+          private
+
+          def glyphs_with_anchor(pattern)
+            font.glyphs.select do |_name, glyph|
+              glyph.anchors.any? { |a| pattern.match?(a.name.to_s) }
+            end
+          end
+
+          def find_anchor(glyph, pattern)
+            glyph.anchors.find { |a| pattern.match?(a.name.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/gdef.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GDEF GlyphClassDef — classifies every glyph into one of
+        # the four OpenType glyph classes:
+        #
+        #   1 — Base glyph
+        #   2 — Ligature glyph
+        #   3 — Combining mark
+        #   4 — Glyph spacing variant (e.g. alternate space)
+        #
+        # The classification drives how GSUB/GPOS lookups apply. UFO
+        # sources carry this in the glyph's +lib+ plist under the
+        # +public.openTypeCategory+ key; this writer translates that
+        # into the structured form the GDEF builder expects.
+        class Gdef < Base
+          TABLE_TAG = "GDEF"
+
+          # Map UFO public.openTypeCategory values → OpenType glyph
+          # class integers. Glyphs whose category isn't listed get
+          # class 0 (unclassified — the GDEF ClassDef omits them).
+          CATEGORY_TO_CLASS = {
+            "base" => 1,
+            "ligature" => 2,
+            "mark" => 3,
+            "component" => 3, # UFO treats component as mark for GDEF
+            "spacing" => 4,
+          }.freeze
+
+          # @return [FeatureOutput]
+          def write
+            classifications = {}
+
+            font.glyphs.each_value do |glyph|
+              cls = classify(glyph)
+              classifications[glyph.name] = cls if cls
+            end
+
+            # A GDEF without any classified glyphs is meaningless —
+            # return nil so the compiler skips the table.
+            return nil if classifications.empty?
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: nil,
+              lookup_type: nil,
+              data: { classes: classifications },
+            )
+          end
+
+          private
+
+          # Resolve a glyph's GDEF class. Prefer the explicit
+          # +public.openTypeCategory+ lib entry; fall back to a
+          # heuristic (glyphs with anchors named "top"/"bottom" are
+          # marks; glyphs with component references are ligatures
+          # only if their name has a +.liga+ suffix).
+          def classify(glyph)
+            category = glyph_lib_category(glyph)
+            return CATEGORY_TO_CLASS[category] if category && CATEGORY_TO_CLASS.key?(category)
+
+            heuristic_class(glyph)
+          end
+
+          def glyph_lib_category(glyph)
+            return nil unless glyph.lib
+
+            lib = glyph.lib
+            return lib["public.openTypeCategory"] if lib["public.openTypeCategory"]
+
+            categories = lib["public.openTypeCategories"]
+            categories[glyph.name] if categories.is_a?(Hash)
+          end
+
+          def heuristic_class(glyph)
+            anchor_names = glyph.anchors.map(&:name)
+            mark_anchor_pattern = /\A_[a-zA-Z]+\z/
+            return 3 if anchor_names.any? { |n| mark_anchor_pattern.match?(n.to_s) }
+            return 2 if glyph.name.to_s.end_with?(".liga")
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/kern.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS PairPos (lookup type 2) — kerning pairs.
+        #
+        # Reads +font.kerning+ (parsed from kerning.plist) and emits
+        # a {FeatureOutput} whose +data+ is a structured list of
+        # pairs ready for the GPOS PairPos builder. Returns +nil+
+        # when the UFO has no kerning data — the compiler then
+        # omits the GPOS table entirely.
+        #
+        # Group-based kerning keys (e.g. +"@MMK_L_A @MMK_R_B"+) are
+        # emitted verbatim with +group: true+; the GPOS builder is
+        # responsible for resolving group references via the UFO's
+        # groups.plist data (TODO: groups.plist support is partial).
+        class Kern < Base
+          # GPOS lookup type 2 — PairPos (pair-positioning).
+          LOOKUP_TYPE = 2
+          FEATURE_TAG = "kern"
+          TABLE_TAG = "GPOS"
+
+          # @return [FeatureOutput, nil]
+          def write
+            return nil if font.kerning.nil? || font.kerning.empty?
+
+            pairs = font.kerning.pairs.map do |key, value|
+              left, right = key.to_s.split(" ", 2)
+              {
+                left: left,
+                right: right,
+                value: value.to_f,
+                group_left: left.to_s.start_with?("@"),
+                group_right: right.to_s.start_with?("@"),
+              }
+            end
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { pairs: pairs },
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/kern2.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Extended kerning (format 2 / Device-table variant of PairPos).
+        #
+        # Same data shape as the basic {Kern} writer, but emits the
+        # extended format that supports:
+        #   - device tables (sub-pixel kerning)
+        #   - cross-stream kerning (y-direction adjustments)
+        #   - per-pair value-format overrides
+        #
+        # The current implementation extracts the same kerning.pairs
+        # data as Kern; the differentiation is in how the GPOS table
+        # builder encodes the value format (Format1 vs Format2, plus
+        # device tables). Writers do not need to know about that —
+        # they just emit the structured data; the table builder
+        # picks the encoding.
+        #
+        # Downstream consumers (compilers) choose between Kern and
+        # Kern2 based on whether they need device tables. Most don't;
+        # basic Kern is sufficient for the common case.
+        class Kern2 < Base
+          LOOKUP_TYPE = 2
+          FEATURE_TAG = "kern"
+          TABLE_TAG = "GPOS"
+          FORMAT = 2
+
+          # @return [FeatureOutput, nil]
+          def write
+            return nil if font.kerning.nil? || font.kerning.empty?
+
+            pairs = font.kerning.pairs.map do |key, value|
+              left, right = key.to_s.split(" ", 2)
+              {
+                left: left,
+                right: right,
+                value: value.to_f,
+                group_left: left.to_s.start_with?("@"),
+                group_right: right.to_s.start_with?("@"),
+              }
+            end
+
+            FeatureOutput.new(
+              table_tag: TABLE_TAG,
+              feature_tag: FEATURE_TAG,
+              lookup_type: LOOKUP_TYPE,
+              data: { format: FORMAT, pairs: pairs },
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/mark.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS MarkToBase (lookup type 4) + MarkToLigature (type 5).
+        #
+        # Builds mark attachments from the UFO's per-glyph anchors.
+        # Pair every mark glyph (one whose anchors include a
+        # +_<name>+ entry, e.g. +_top+) with every base glyph that
+        # has the matching non-underscore anchor (e.g. +top+).
+        #
+        # Prerequisite: {Filters::PropagateAnchors} should have run
+        # first so composite glyphs carry their inherited anchors.
+        class Mark < MarkFamilyBase
+          LOOKUP_TYPE = 4
+          FEATURE_TAG = "mark"
+
+          private
+
+          def feature_tag
+            FEATURE_TAG
+          end
+
+          def lookup_type
+            LOOKUP_TYPE
+          end
+
+          # Mark convention: _<name> → class_name = name (drop underscore).
+          def mark_class_from_anchor(anchor_name)
+            return nil unless anchor_name.start_with?("_")
+
+            anchor_name[1..]
+          end
+
+          # Base convention: class_name is the anchor name verbatim.
+          def base_anchor_name_for(class_name)
+            class_name
+          end
+        end
+      end
+    end
+  end
+end