fontisan 0.4.10 → 0.4.12

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

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Shared base for feature writers that pair "mark" glyphs with
+        # "base" glyphs via a paired-anchor convention (Mark uses
+        # +_<name>+ ↔ +<name>+; Mkmk uses +_<name>mkmk+ ↔
+        # +<name>mkmk+). Concrete subclasses plug in the lookup
+        # convention + the lookup type + the feature tag.
+        #
+        # Reduces duplication between Mark and Mkmk: both walk every
+        # glyph, collect its anchor classes (with the convention's
+        # prefix + suffix), then pair each class with matching bases.
+        class MarkFamilyBase < Base
+          # @return [FeatureOutput, nil]
+          def write
+            marks = collect_marks
+            return nil if marks.empty?
+
+            attachments = {}
+
+            marks.each do |(mark_name, classes)|
+              classes.each do |class_name, mark_anchor|
+                bases = collect_bases_for(class_name)
+                next if bases.empty?
+
+                attachments[class_name] ||= new_class_entry
+                attachments[class_name][:marks][mark_name] = mark_anchor
+                bases.each { |n, a| attachments[class_name][base_bucket_key][n] = a }
+              end
+            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
+
+          # The convention's mark-anchor predicate. Returns the
+          # class_name extracted from a mark glyph's anchor name, or
+          # +nil+ if the anchor doesn't match the convention.
+          #
+          # Subclasses implement this — Mark's convention is
+          # "_<name>"; Mkmk's is "_<name>mkmk".
+          def mark_class_from_anchor(_anchor_name)
+            raise NotImplementedError,
+                  "#{self.class} must implement #mark_class_from_anchor"
+          end
+
+          # Inverse of +mark_class_from_anchor+: given a class name
+          # extracted from a mark anchor, what's the matching
+          # base-anchor name? Mark's convention is class_name; Mkmk's
+          # is "<class_name>mkmk".
+          def base_anchor_name_for(_class_name)
+            raise NotImplementedError,
+                  "#{self.class} must implement #base_anchor_name_for"
+          end
+
+          # Subclass overrides — Mark uses :bases, Mkmk uses :base_marks.
+          def base_bucket_key
+            :bases
+          end
+
+          # Build a fresh per-class attachment entry with the right
+          # base bucket key. Avoids inline hash-literal ambiguity
+          # with dynamic keys.
+          def new_class_entry
+            { marks: {}, base_bucket_key => {} }
+          end
+
+          def table_tag
+            "GPOS"
+          end
+
+          def feature_tag
+            nil
+          end
+
+          def lookup_type
+            nil
+          end
+
+          def collect_marks
+            font.glyphs.each_with_object({}) do |(name, glyph), h|
+              classes = mark_classes_for(glyph)
+              h[name] = classes unless classes.empty?
+            end
+          end
+
+          def mark_classes_for(glyph)
+            glyph.anchors.each_with_object({}) do |anchor, h|
+              class_name = mark_class_from_anchor(anchor.name.to_s)
+              next unless class_name
+
+              h[class_name] = [anchor.x, anchor.y]
+            end
+          end
+
+          def collect_bases_for(class_name)
+            target = base_anchor_name_for(class_name)
+            return {} unless target
+
+            font.glyphs.each_with_object({}) do |(name, glyph), h|
+              anchor = glyph.anchors.find { |a| a.name == target }
+              next unless anchor
+
+              h[name] = [anchor.x, anchor.y]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS MarkToMark (lookup type 6) — mark-to-mark attachment.
+        #
+        # Same shape as MarkToBase, but pairs marks with OTHER marks
+        # rather than marks with bases. UFO convention: a mark glyph
+        # that can attach to another mark has a +_<name>mkmk+ anchor
+        # (the attach-FROM point), and the "base mark" it attaches to
+        # has the matching +<name>mkmk+ anchor (the attach-TO point).
+        #
+        # Pairs every glyph with a +_<name>mkmk+ anchor with every
+        # glyph that has the matching +<name>mkmk+ anchor.
+        class Mkmk < MarkFamilyBase
+          LOOKUP_TYPE = 6
+          FEATURE_TAG = "mkmk"
+          MKMK_SUFFIX = "mkmk"
+
+          private
+
+          def feature_tag
+            FEATURE_TAG
+          end
+
+          def lookup_type
+            LOOKUP_TYPE
+          end
+
+          def base_bucket_key
+            :base_marks
+          end
+
+          # Mkmk convention: _<name>mkmk → class_name = name (drop
+          # underscore prefix + "mkmk" suffix).
+          def mark_class_from_anchor(anchor_name)
+            return nil unless anchor_name.start_with?("_")
+            return nil unless anchor_name.end_with?(MKMK_SUFFIX)
+
+            anchor_name[1..-MKMK_SUFFIX.length - 1]
+          end
+
+          # Base-mark convention: class_name + "mkmk" suffix.
+          def base_anchor_name_for(class_name)
+            "#{class_name}#{MKMK_SUFFIX}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Feature writers extract GSUB/GPOS feature data from a UFO
+      # source. Each writer is a class extending {FeatureWriters::Base}
+      # with a +#write+ method that returns a {FeatureOutput} value
+      # object (or +nil+ if the UFO has no data for that feature).
+      #
+      # The compiler runs registered writers, collects their outputs,
+      # and feeds each into the corresponding table builder
+      # (`Tables::Gpos`, `Tables::Gsub`, etc.) for binary encoding.
+      #
+      # OCP: adding a new feature writer = new class + one REGISTRY
+      # entry. No edits to the compiler.
+      module FeatureWriters
+        autoload :Base, "fontisan/ufo/compile/feature_writers/base"
+        autoload :MarkFamilyBase, "fontisan/ufo/compile/feature_writers/mark_family_base"
+        autoload :Kern, "fontisan/ufo/compile/feature_writers/kern"
+        autoload :Kern2, "fontisan/ufo/compile/feature_writers/kern2"
+        autoload :Gdef, "fontisan/ufo/compile/feature_writers/gdef"
+        autoload :Mark, "fontisan/ufo/compile/feature_writers/mark"
+        autoload :Mkmk, "fontisan/ufo/compile/feature_writers/mkmk"
+        autoload :Curs, "fontisan/ufo/compile/feature_writers/curs"
+
+        # Default writer set — what the compiler runs when the user
+        # doesn't override. Per feature, +#write+ returns +nil+ when
+        # the UFO has no data for that feature, so it's safe to
+        # always run them all. Order matters: Gdef first (so later
+        # writers can rely on glyph classification), then position
+        # features (kern, mark, mkmk, curs).
+        DEFAULT_WRITERS = [Gdef, Kern, Mark, Mkmk, Curs].freeze
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/propagate_anchors.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Propagates anchors from base glyphs to composite glyphs.
+        #
+        # In UFO sources, a composite glyph references base glyphs via
+        # Component entries. Anchors (mark-attachment points used by
+        # GPOS mark feature writers) typically live on the base glyphs
+        # only — the composite inherits them by applying each
+        # component's transformation matrix to the base's anchors.
+        #
+        # This filter does that propagation in place. After it runs,
+        # every composite glyph carries its component-derived anchors,
+        # ready for the mark feature writer to read.
+        #
+        # Single-pass (no recursive propagation through multi-level
+        # component chains). Multi-level propagation would require
+        # topological sort; if you need it, run the filter repeatedly
+        # until no anchors change.
+        module PropagateAnchors
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>] the glyphs to
+          #   mutate. Must include any base glyphs referenced by
+          #   components, or those references will be silently
+          #   skipped.
+          # @param font [Fontisan::Ufo::Font, nil] optional explicit
+          #   font lookup. When provided, base glyphs are resolved
+          #   via +font.glyph(name)+ instead of the +glyphs+ array,
+          #   so composites can reference base glyphs that aren't in
+          #   the +glyphs+ list.
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, font: nil, **_opts)
+            lookup = build_lookup(font, glyphs)
+
+            glyphs.each do |glyph|
+              next if glyph.components.empty?
+
+              glyph.components.each do |component|
+                base = lookup[component.base_glyph]
+                next unless base
+
+                transform = coerce_transformation(component.transformation)
+                propagate_anchors(glyph, base, transform)
+              end
+            end
+
+            glyphs
+          end
+
+          class << self
+            private
+
+            def build_lookup(font, glyphs)
+              return ->(name) { font.glyph(name) } if font
+
+              hash = glyphs.to_h { |g| [g.name, g] }
+              ->(name) { hash[name] }
+            end
+
+            def coerce_transformation(matrix)
+              return Fontisan::Ufo::Transformation.new if matrix.nil?
+              return matrix if matrix.is_a?(Fontisan::Ufo::Transformation)
+
+              Fontisan::Ufo::Transformation.new(
+                a: matrix[0], b: matrix[1],
+                c: matrix[2], d: matrix[3],
+                e: matrix[4], f: matrix[5]
+              )
+            end
+
+            # Copy each anchor from +base+ into +glyph+, transformed
+            # by +transform+. Skip anchors whose (name, transformed
+            # x, transformed y) already exist on +glyph+ (the user
+            # may have placed them manually). Coordinates are coerced
+            # to Float so an Integer manual placement and the Float
+            # transform output compare equal as dedup keys (Ruby's
+            # eql? is type-strict, but == treats 100 == 100.0).
+            def propagate_anchors(glyph, base, transform)
+              existing = glyph.anchors.to_h do |a|
+                [[a.name, a.x.to_f, a.y.to_f], true]
+              end
+
+              base.anchors.each do |anchor|
+                tx, ty = transform.apply(anchor.x, anchor.y)
+                key = [anchor.name, tx, ty]
+                next if existing[key]
+
+                glyph.add_anchor(Fontisan::Ufo::Anchor.new(
+                                   x: tx, y: ty, name: anchor.name,
+                                 ))
+                existing[key] = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/remove_overlaps.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Boolean union of overlapping contours within each glyph.
+        # Two contours that overlap visually are merged into one,
+        # removing the seam. Required for some hinting programs and
+        # for SVG/COLR rendering correctness.
+        #
+        # == Why bounding-box approximation, not polygon clipping
+        #
+        # Full polygon clipping (Greiner-Hormann or Vatti) operates
+        # on straight-line polygons. UFO contours are Bezier curves.
+        # Applying polygon clipping would require:
+        #   1. Flatten Bezier to polygon edges (tessellation).
+        #   2. Run polygon clipping (union).
+        #   3. Re-fit Bezier curves on the result (curve fitting).
+        #
+        # Step 3 is the killer: curve fitting is lossy. The output
+        # curves won't match the input curves' control points,
+        # changing the glyph's rendering at small sizes. For a font
+        # pipeline, preserving curve fidelity matters more than
+        # mathematical union correctness.
+        #
+        # The bounding-box approximation handles the common cases
+        # (overlapping duplicates, fully-contained sub-contours)
+        # without losing any curve data. It does NOT handle partial
+        # overlaps — those remain as separate contours. For fonts
+        # that need partial-overlap removal, preprocess in an editor
+        # (FontLab, Glyphs) or use the `clipper` gem as a pre-compile
+        # step with explicit curve-flattening tolerances.
+        module RemoveOverlaps
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, **_opts)
+            glyphs.each { |g| remove_overlaps_in_glyph(g) }
+            glyphs
+          end
+
+          class << self
+            private
+
+            def remove_overlaps_in_glyph(glyph)
+              return if glyph.contours.size < 2
+
+              bboxes = glyph.contours.map { |c| bounding_box(c) }
+              drop = Set.new
+
+              glyph.contours.each_with_index do |outer, i|
+                next if drop.include?(i)
+
+                glyph.contours.each_with_index do |inner, j|
+                  next if i == j || drop.include?(j)
+
+                  # Drop inner when its bbox is fully inside outer's.
+                  if contained_in?(bboxes[j], bboxes[i]) && (inner.points.size <= outer.points.size)
+                    # Sanity: only drop if the point count is smaller —
+                    # a fully-contained contour with MORE points is
+                    # almost certainly the outer one in a malformed
+                    # source, and dropping it would lose data.
+                    drop << j
+                  end
+                end
+              end
+
+              return if drop.empty?
+
+              glyph.contours.reject!.with_index { |_c, i| drop.include?(i) }
+            end
+
+            def bounding_box(contour)
+              points = contour.points
+              return { x_min: 0, y_min: 0, x_max: 0, y_max: 0 } 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
+
+            def contained_in?(inner, outer)
+              inner[:x_min] >= outer[:x_min] &&
+                inner[:x_max] <= outer[:x_max] &&
+                inner[:y_min] >= outer[:y_min] &&
+                inner[:y_max] <= outer[:y_max]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/sort_contours.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Sorts the contours within each glyph + the points within
+        # each contour. Two distinct operations, both required for
+        # TrueType hinting compatibility:
+        #
+        # 1. **Start-point alignment**: rotate each contour's point
+        #    list so an on-curve point is first (TrueType hinting
+        #    programs expect this).
+        #
+        # 2. **Contour ordering**: order contours within each glyph
+        #    by their starting point's (Y descending, X ascending)
+        #    so the hint program processes outer contours before
+        #    inner ones (true-type convention for nested shapes).
+        #
+        # This is the fontTools/ufo2ft sort_contours filter, scoped
+        # to the contour-level concerns. Per-glyph sort across
+        # multiple glyphs is the caller's responsibility (callers
+        # typically sort glyphs by gid / post name).
+        module SortContours
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, **_opts)
+            glyphs.each do |glyph|
+              glyph.contours.each { |c| rotate_to_first_on_curve(c) }
+              glyph.contours.sort_by! { |c| sort_key(c) }
+            end
+            glyphs
+          end
+
+          class << self
+            private
+
+            # Rotate the point list so an on-curve point sits at
+            # index 0. If the contour is all off-curve (impossible
+            # for valid UFO but defensively handled), leave it
+            # unchanged.
+            def rotate_to_first_on_curve(contour)
+              points = contour.points
+              return if points.empty?
+              return if points.first.on_curve?
+
+              first_on = points.find_index(&:on_curve?)
+              return unless first_on
+
+              contour.points = points.rotate(first_on)
+            end
+
+            # Sort key: descending Y (outer contours typically start
+            # at the top), then ascending X (leftmost first when Y
+            # ties). Uses the first on-curve point's coordinates.
+            # Empty contours sort last (Float::INFINITY).
+            def sort_key(contour)
+              first = contour.points.find(&:on_curve?) || contour.points.first
+              return [Float::INFINITY, Float::INFINITY] unless first
+
+              [-first.y.to_f, first.x.to_f]
+            end
+          end
+        end
+      end
+    end
+  end
+end