fontisan 0.4.29 → 0.4.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80a76c3d84f5bbd6f7750df7505b1d7c5c3e6f4396ebefe3238705cef8dece02
-  data.tar.gz: 96fa6ad2df65fd9e1c4ecaa1b15f1948b05537d63b708e4fde8ce9b72809cc0b
+  metadata.gz: 2a84b3003bce58bcd29e1ada7dd175235d6a57f90c062e70e8c6696f818b4a4a
+  data.tar.gz: e9890a2151d339ec8aee34bab3da816615afa1a19aade3739fb1928e2711158e
 SHA512:
-  metadata.gz: 8718892c5630fb4e3371e42d5cf942a1080d1dc7f54213d55ef778d897c6a46ae276739045c353e7ea76a1241709b27564b5983458ae21557d1192b86b004abc
-  data.tar.gz: 1831e3bdc8f2715559a41f036b2e6f20a54d5e941192fa1620fad0b3331c2fa0acc7495e61c1eebfa0e3c939d22fcbd852eddbf86a22b5b12604fed378bb0b06
+  metadata.gz: 0ee92245d86e3b325daa81caf2657c2dcad21c796a775ceea579482a85b5ba59e751f2f993e3ab9a5ac7af12ec8d6b1b698c4b8625fb968f44d5ebfc86434a7e
+  data.tar.gz: 5120ad6b71b8263c33fc0d22bf9a80d61377417aa95916ca2a205801aa1788fb8be958fa36c5e0cb428fa2ac4b7f155c83181c0a251d829a29fbfd6b9779d9c2

data/TODO.improvements/README.md

@@ -12,8 +12,8 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 
 ### P1 — High-value features
 - [03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)
-- [04 — UFO composite glyph encoding](04-ufo-composite-glyph-encoding.md)
-- [05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md) ← blocks TODO #15
+- [x] ~~[04 — UFO composite glyph encoding](04-ufo-composite-glyph-encoding.md)~~ ✓ Done
+- [x] ~~[05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md)~~ ✓ Already working (discovered in PR #117 — Cff.build produces real Type 2 charstrings; stale TODO marker removed)
 
 ### P2 — Specialist feature parity
 - [x] ~~[07 — CPAL v1 header fields](07-cpal-v1-header-fields.md)~~ ✓ Done (v0.4.25)
@@ -21,7 +21,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 - [06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)
 - [09 — Type 1 seac expansion](09-type1-seac-expansion.md)
 - [10 — UFO image set + feature writers](10-ufo-image-set-feature-writers.md)
-- [11 — kern groups.plist support](11-kern-groups-plist.md)
+- [x] ~~[11 — kern groups.plist support](11-kern-groups-plist.md)~~ ✓ Done (Groups model in PR #116 + GPOS group resolution in this PR)
 
 ### P3 — Code-quality cleanup
 - [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (v0.4.24)

data/lib/fontisan/stitcher/source.rb

@@ -213,6 +213,7 @@ module Fontisan
 
         hhea = @font.table("hhea")
         maxp = @font.table("maxp")
+        head = @font.table("head")
         num_h_metrics = hhea&.number_of_h_metrics || 1
         num_glyphs = maxp&.num_glyphs || 0
 
@@ -220,11 +221,22 @@ module Fontisan
           hmtx.parse_with_context(num_h_metrics, num_glyphs)
         end
 
+        # Fallback advance width when hmtx lookup fails for a GID.
+        # Per the OpenType spec, glyphs at GID >= numberOfHMetrics
+        # inherit the last LongHorMetric's advanceWidth. If the table
+        # is empty or corrupt, fall back to the font's unitsPerEm.
+        fallback_width = if hmtx.respond_to?(:h_metrics) && hmtx.h_metrics&.any?
+                           hmtx.h_metrics.last[:advance_width]
+                         else
+                           head&.units_per_em || 1000
+                         end
+
         num_glyphs.times do |gid|
-          metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
-          widths[gid] = metric ? metric[:advance_width] : 0
+          metric = hmtx&.metric_for(gid)
+          aw = metric ? metric[:advance_width] : nil
+          widths[gid] = aw&.positive? ? aw : fallback_width
         rescue StandardError
-          widths[gid] = 0
+          widths[gid] = fallback_width
         end
         widths
       end
@@ -278,12 +290,45 @@ module Fontisan
           flatten_compound_into(raw, glyph, cache, Set.new)
         end
 
+        normalize_glyph_metrics!(glyph, cache[:head])
         add_cmap_unicodes(gid, glyph)
         glyph
       rescue StandardError
         nil
       end
 
+      # Fix glyphs whose contours extend far left of the origin
+      # (massively negative LSB) or whose advance width was lost
+      # during donor hmtx extraction. Without this, Egyptian
+      # Hieroglyphs and similar donor glyphs overflow into the
+      # preceding character cell.
+      #
+      # Shifts all x-coordinates so xMin >= 0, then ensures the
+      # advance width covers the glyph's full visual extent.
+      def normalize_glyph_metrics!(glyph, head)
+        return if glyph.contours.empty?
+
+        bbox = glyph.bbox
+        return unless bbox
+
+        upm = head&.units_per_em || 1000
+        threshold = -(upm * 0.1).to_i
+
+        # Shift contours right if the glyph extends past the origin
+        if bbox.x_min < threshold
+          shift = -bbox.x_min.to_i
+          glyph.contours.each do |contour|
+            contour.points.each { |pt| pt.x = pt.x + shift }
+          end
+        end
+
+        # Ensure advance width is positive and covers the glyph
+        visual_width = glyph.bbox&.x_max&.to_i || upm
+        if glyph.width.to_i <= 0 || glyph.width.to_i < visual_width
+          glyph.width = [visual_width, upm].max
+        end
+      end
+
       # Copy a SimpleGlyph's contours + points into a Ufo::Glyph.
       def copy_simple_contours(simple, ufo_glyph)
         num_contours = simple.end_pts_of_contours&.size || 0

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

@@ -13,9 +13,8 @@ module Fontisan
         # 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).
+        # resolved to individual glyph pairs by the GPOS builder via
+        # the UFO's groups.plist data (font.groups).
         class Kern < Base
           # GPOS lookup type 2 — PairPos (pair-positioning).
           LOOKUP_TYPE = 2

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

@@ -23,11 +23,14 @@ module Fontisan
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
         # @return [Hash<String, String>] {"glyf" => bytes, "loca" => bytes}
         def self.build(_font, glyphs:)
+          name_to_gid = {}
+          glyphs.each_with_index { |g, i| name_to_gid[g.name] = i }
+
           glyf_bytes = +""
           offsets = [0]
 
           glyphs.each do |glyph|
-            glyf_bytes << encode_glyph(glyph)
+            glyf_bytes << encode_glyph(glyph, name_to_gid)
             glyf_bytes << "\x00" while glyf_bytes.bytesize.odd? # 2-byte align
             offsets << glyf_bytes.bytesize
           end
@@ -47,9 +50,9 @@ module Fontisan
 
         # Encode a single glyph into glyf bytes. Empty glyphs (no
         # contours, no components) produce zero bytes per spec.
-        def self.encode_glyph(glyph)
+        def self.encode_glyph(glyph, name_to_gid = {})
           return "" if glyph.contours.empty? && glyph.components.empty?
-          return encode_composite(glyph) if glyph.composite?
+          return encode_composite(glyph, name_to_gid) if glyph.composite?
 
           encode_simple(glyph)
         end
@@ -131,16 +134,72 @@ module Fontisan
           [flags, x_bytes, y_bytes]
         end
 
-        # Composite glyph encoding (component references with optional
-        # transformations). Out of scope for MVP — emits empty bytes.
-        def self.encode_composite(_glyph)
-          # TODO.full/07: implement composite glyph encoding when the
-          # spec needs it. For now, return empty (the glyph renders as
-          # nothing).
-          ""
+        # Composite glyph encoding per OpenType spec section 5.6.
+        # Emits a compound glyph record with one component entry per
+        # UFO component reference. Each component's base glyph name is
+        # resolved to a compiled GID via the name_to_gid map.
+        #
+        # Transform encoding:
+        #   - identity transform → no transform flags
+        #   - uniform scale (a=d, b=c=0) → WE_HAVE_A_SCALE (1 F2Dot14)
+        #   - non-uniform scale (b=c=0, a≠d) → WE_HAVE_AN_X_AND_Y_SCALE (2 F2Dot14)
+        #   - full 2×2 → WE_HAVE_A_TWO_BY_TWO (4 F2Dot14)
+        def self.encode_composite(glyph, name_to_gid)
+          header = [-1, 0, 0, 0, 0].pack("s>n4")
+
+          body = +""
+          components = glyph.components
+          components.each_with_index do |comp, idx|
+            gid = name_to_gid[comp.base_glyph]
+            next unless gid
+
+            flags = 0x0002 # ARGS_ARE_XY_VALUES (always for UFO)
+
+            dx = comp.transformation ? comp.transformation.e.to_i : 0
+            dy = comp.transformation ? comp.transformation.f.to_i : 0
+
+            flags |= 0x0001 if dx < -128 || dx > 127 || dy < -128 || dy > 127
+
+            t = comp.transformation
+            if t && !t.identity?
+              flags |= if t.b.zero? && t.c.zero? && (t.a - t.d).abs < 1e-6
+                0x0008 # WE_HAVE_A_SCALE
+                       elsif t.b.zero? && t.c.zero?
+                0x0040 # WE_HAVE_AN_X_AND_Y_SCALE
+                       else
+                0x0080 # WE_HAVE_A_TWO_BY_TWO
+                       end
+            end
+
+            flags |= 0x0020 if idx < components.size - 1 # MORE_COMPONENTS
+
+            body << [flags, gid].pack("n*")
+
+            body << if (flags & 0x0001).zero?
+              [dx, dy].pack("cc")
+                    else
+              [dx, dy].pack("s>s>")
+                    end
+
+            if flags & 0x0008 != 0
+              body << [to_f2dot14(t.a)].pack("s>")
+            elsif flags & 0x0040 != 0
+              body << [to_f2dot14(t.a), to_f2dot14(t.d)].pack("s>s>")
+            elsif flags & 0x0080 != 0
+              body << [to_f2dot14(t.a), to_f2dot14(t.b),
+                       to_f2dot14(t.c), to_f2dot14(t.d)].pack("s>4")
+            end
+          end
+
+          header + body
+        end
+
+        # Encode a float as F2Dot14 (2 integer + 14 fractional bits).
+        def self.to_f2dot14(value)
+          (value * 16_384).round
         end
         private_class_method :encode_glyph, :encode_simple, :encode_points,
-                             :encode_composite
+                             :encode_composite, :to_f2dot14
       end
     end
   end

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

@@ -40,7 +40,9 @@ module Fontisan
         # ---------- pair collection ----------
 
         # Collect kerning pairs from the UFO model. Each pair is
-        # (gid1, gid2, x_advance_delta).
+        # (gid1, gid2, x_advance_delta). Resolves class-based kerning
+        # keys (e.g. "@MMK_L_A @MMK_R_T") by expanding group members
+        # into individual glyph pairs via font.groups.
         # @return [Array<[Integer, Integer, Integer]>]
         def self.collect_kerning_pairs(font, glyphs)
           name_to_gid = {}
@@ -48,21 +50,40 @@ module Fontisan
 
           pairs = []
           font.kerning.each_pair do |key, value|
-            # UFO kerning key is "glyph1 glyph2" or a class name.
-            # We only handle individual glyph pairs (not classes).
             names = key.split
             next unless names.size == 2
 
-            gid1 = name_to_gid[names[0]]
-            gid2 = name_to_gid[names[1]]
-            next unless gid1 && gid2
+            left_names = resolve_kerning_side(names[0], font)
+            right_names = resolve_kerning_side(names[1], font)
 
-            pairs << [gid1, gid2, value.to_i]
+            left_names.each do |ln|
+              right_names.each do |rn|
+                gid1 = name_to_gid[ln]
+                gid2 = name_to_gid[rn]
+                next unless gid1 && gid2
+
+                pairs << [gid1, gid2, value.to_i]
+              end
+            end
           end
 
           pairs.sort_by { |a| [a[0], a[1]] }
         end
 
+        # Resolve a kerning key side to individual glyph names. If
+        # +name+ is a group reference (starts with "@"), returns all
+        # group members. Otherwise returns +[name]+ for an individual
+        # glyph.
+        # @param name [String] glyph name or group reference
+        # @param font [Fontisan::Ufo::Font]
+        # @return [Array<String>] glyph names
+        def self.resolve_kerning_side(name, font)
+          return [name] unless name.start_with?("@")
+
+          members = font.groups.glyphs(name)
+          members.empty? ? [] : members
+        end
+
         # ---------- GPOS binary assembly ----------
 
         def self.build_gpos_table(pairs)

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

@@ -14,15 +14,36 @@ module Fontisan
         def self.build(font, glyphs:)
           info = font.info
           widths = glyphs.map { |g| g.width.to_i }
+
+          # Calculate real LSB/RSB/extent from glyph bounding boxes
+          # instead of hardcoding 0. These values help layout engines
+          # optimize text rendering and detect clipping.
+          min_lsb = nil
+          min_rsb = nil
+          max_extent = nil
+
+          glyphs.each do |glyph|
+            w = glyph.width.to_i
+            bbox = glyph.bbox
+            next unless bbox
+
+            xmin = bbox.x_min.to_i
+            xmax = bbox.x_max.to_i
+            min_lsb = xmin if min_lsb.nil? || xmin < min_lsb
+            rsb = w - xmax
+            min_rsb = rsb if min_rsb.nil? || rsb < min_rsb
+            max_extent = xmax if max_extent.nil? || xmax > max_extent
+          end
+
           Fontisan::Tables::Hhea.new(
             version_raw: VERSION_1_0,
             ascent: info.ascender || 800,
             descent: info.descender || -200,
             line_gap: info.open_type_hhea_line_gap || 0,
             advance_width_max: widths.max || 0,
-            min_left_side_bearing: 0,
-            min_right_side_bearing: 0,
-            x_max_extent: widths.max || 0,
+            min_left_side_bearing: min_lsb || 0,
+            min_right_side_bearing: min_rsb || 0,
+            x_max_extent: max_extent || 0,
             caret_slope_rise: 1,
             caret_slope_run: 0,
             caret_offset: 0,

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

@@ -9,15 +9,26 @@ module Fontisan
       # No trailing "leftSideBearing" array (use numberOfHMetrics = numGlyphs).
       # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx
       module Hmtx
-        # @param _font [Fontisan::Ufo::Font]
+        # @param font [Fontisan::Ufo::Font]
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
         # @return [String] hmtx table bytes
-        def self.build(_font, glyphs:)
+        def self.build(font, glyphs:)
+          upm = font.info.units_per_em&.to_i || 1000
           data = +""
           glyphs.each do |glyph|
             bbox = glyph.bbox
             lsb = bbox ? bbox.x_min.to_i : 0
-            data << [glyph.width.to_i, lsb].pack("nn")
+            width = glyph.width.to_i
+
+            # Safety net: never emit advance_width=0 for a non-empty
+            # glyph. This happens when donor hmtx parsing fails during
+            # stitching and the width wasn't caught upstream.
+            if width <= 0
+              width = bbox ? (bbox.x_max.to_i - bbox.x_min.to_i) : upm
+              width = [width, upm].max
+            end
+
+            data << [width, lsb].pack("nn")
           end
           data
         end

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

@@ -5,11 +5,8 @@ module Fontisan
     module Compile
       # UFO → OTF. Uses CFF outlines (instead of TrueType glyf/loca).
       # Maxp version 0.5 (no TrueType metrics); sfnt version OTTO.
-      #
-      # TODO.full/10: this currently emits a placeholder CFF table
-      # that satisfies the OTTO signature but does NOT yet encode
-      # real charstrings. Full CFF construction lands when TODO 10
-      # ships.
+      # The CFF table is built by Compile::Cff which encodes real
+      # Type 2 charstrings from UFO contours via CharStringBuilder.
       class OtfCompiler < BaseCompiler
         SFNT_VERSION = SFNT_VERSION_OPEN_TYPE
 

data/lib/fontisan/ufo/point.rb

@@ -10,7 +10,8 @@ module Fontisan
     # "offcurve" is the UFO 1/2 name; UFO 3 uses "qcurve". Both are
     # accepted on read.
     class Point
-      attr_reader :x, :y, :type, :smooth
+      attr_accessor :x, :y
+      attr_reader :type, :smooth
 
       def initialize(x:, y:, type:, smooth: false)
         @x = x

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.29"
+  VERSION = "0.4.31"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.29
+  version: 0.4.31
 platform: ruby
 authors:
 - Ribose Inc.