fontisan 0.4.29 → 0.4.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80a76c3d84f5bbd6f7750df7505b1d7c5c3e6f4396ebefe3238705cef8dece02
-  data.tar.gz: 96fa6ad2df65fd9e1c4ecaa1b15f1948b05537d63b708e4fde8ce9b72809cc0b
+  metadata.gz: 5dd9aa72ac0517bcfbfed3d6eb3528af3e0b65a52bc721d14ba5fb545198e48f
+  data.tar.gz: be1d6d7379a3bd0cda435d02b91e5d7fc213736483e3aac66b93280d63261669
 SHA512:
-  metadata.gz: 8718892c5630fb4e3371e42d5cf942a1080d1dc7f54213d55ef778d897c6a46ae276739045c353e7ea76a1241709b27564b5983458ae21557d1192b86b004abc
-  data.tar.gz: 1831e3bdc8f2715559a41f036b2e6f20a54d5e941192fa1620fad0b3331c2fa0acc7495e61c1eebfa0e3c939d22fcbd852eddbf86a22b5b12604fed378bb0b06
+  metadata.gz: b889fec5459a0d420ffe21d3ec792f107c69060eeddba8cf357e1a83b1e37669c3b6d017b41921b6d5be28519d51ef13ef2ab4da2d00e9ccfb9a31c204310150
+  data.tar.gz: 69952d13b5c18685c8b22d92b5f56c8ed2cfc89da8a5324080a9f206823d1999baf947718fbf56e77e239de422dcbf21033e9a7d060a30e5e5e5df6482727ce0

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/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/version.rb

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

metadata

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