fontisan 0.4.28 → 0.4.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdd148825272b5984f48a9d7e83715161054702eaf84e1c270eff42151c6bcba
-  data.tar.gz: d701f78f818f4b49fbcc047094eadd872e01c5dcd2372516bfaed1098bfa9bf5
+  metadata.gz: 5dd9aa72ac0517bcfbfed3d6eb3528af3e0b65a52bc721d14ba5fb545198e48f
+  data.tar.gz: be1d6d7379a3bd0cda435d02b91e5d7fc213736483e3aac66b93280d63261669
 SHA512:
-  metadata.gz: 25d8d8fe6c8fed6067a068ac83aec0f737e627fb81775fdd2fd679a38007c72fbfae0554075f539637746d264b31eddd6125fbaeaee0c566a8b0947cb9ea15cf
-  data.tar.gz: 5a6b96d94af207136e925b0a8ed675688c387fbdae471fbbb6120e9703869a42142c598579d25164121a6fd57d009e4ccad760d6c2464c45fe1d711f8071cd63
+  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/docs/guide/cli/subset.md

@@ -93,9 +93,9 @@ The `--profile` option controls which font tables the subset retains. The right
 
 | Profile | When to use | Notable tables dropped |
 |---------|-------------|------------------------|
-| `pdf` (default) | PDF embedding, smallest valid output | GSUB, GPOS, CBDT, CBLC |
-| `web` | Browser/web font, **retains color-emoji bitmaps** | nothing that browsers need |
-| `minimal` | Absolute smallest core that still renders | glyf/loca, CBDT/CBLC, GSUB/GPOS |
+| `pdf` (default) | PDF embedding, smallest valid output | GSUB, GPOS |
+| `web` | Browser/web font, **retains color-emoji bitmaps + CFF outlines** | nothing that browsers need |
+| `minimal` | Absolute smallest core that still renders | glyf/loca, CFF/CFF2, GSUB/GPOS |
 | `full` | Lossless re-export | (none) |
 
 ```bash

data/lib/fontisan/config/subset_profiles.yml

@@ -38,7 +38,7 @@ pdf:
     - post
     - loca
     - glyf
-    - CFF
+    - "CFF "
     - CFF2
 
 # Web Profile: Tables required for web font usage
@@ -55,7 +55,7 @@ web:
     - post
     - loca
     - glyf
-    - CFF
+    - "CFF "
     - CFF2
     - GSUB
     - GPOS
@@ -98,7 +98,7 @@ full:
     - GDEF
     - BASE
     - JSTF
-    - CFF
+    - "CFF "
     - CFF2
     - VORG
     - kern

data/lib/fontisan/subset/table_strategy/cff.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CFF (Compact Font Format) subsetter strategy.
+      #
+      # Subsets CFF tables by routing through the UFO model:
+      #
+      #   source font → Ufo::Convert::FromBinData → UFO (with contours)
+      #                → filter glyphs to mapping →
+      #                → Ufo::Compile::Cff.build → new CFF bytes
+      #
+      # This is the architecturally preferred path: the UFO model is
+      # the canonical representation, CFF is a serialization. The
+      # strategy reuses the existing compile pipeline rather than
+      # reimplementing CFF INDEX arithmetic.
+      #
+      # Glyphs not in the mapping are dropped from the UFO before
+      # compilation. The Cff.build pipeline generates the correct
+      # charset (GID → SID mapping) from the retained glyph names.
+      #
+      # See TODO #15 for the full design rationale and the CFF2
+      # extension path.
+      class Cff
+        # @param context [SubsetContext]
+        # @param tag [String] "CFF "
+        # @param table [Object] parsed CFF table (unused — we work
+        #   from the source font directly)
+        # @return [String] subset CFF table bytes
+        def self.call(context:, tag:, table:)
+          source_font = context.font
+          mapping = context.mapping
+
+          ufo = Ufo::Convert::FromBinData.convert(source_font)
+          filter_ufo_glyphs!(ufo, mapping)
+
+          # Rename the first glyph (source GID 0) to .notdef so the
+          # CFF compiler's charset generation produces a valid .notdef
+          # entry at GID 0.
+          first_name = ufo.glyphs.keys.first
+          if first_name && first_name != ".notdef"
+            notdef = ufo.glyphs.delete(first_name)
+            notdef = Ufo::Glyph.new(name: ".notdef") if notdef.nil?
+            ufo.glyphs[".notdef"] = notdef
+          end
+
+          glyphs = ufo.layers.default_layer.each.to_a
+          Fontisan::Ufo::Compile::Cff.build(ufo, glyphs: glyphs)
+        end
+
+        # Drop glyphs from the UFO that are not in the mapping's
+        # new-id set. Keeps .notdef (GID 0) regardless of mapping.
+        #
+        # @param ufo [Ufo::Font]
+        # @param mapping [GlyphMapping]
+        def self.filter_ufo_glyphs!(ufo, mapping)
+          retained_old_ids = Set.new(mapping.old_ids)
+
+          # The UFO doesn't carry GID info after conversion; we rely
+          # on the mapping's old_ids. Since the UFO was converted
+          # from the same source font, the UFO glyph order matches
+          # the source GID order. So GID N in the source = Nth glyph
+          # added to the UFO default layer.
+          all_names = ufo.glyphs.keys
+          names_to_keep = all_names.each_with_index.with_object(Set.new) do |(name, gid), keep|
+            keep << name if retained_old_ids.include?(gid)
+          end
+
+          # Always keep .notdef
+          names_to_keep << ".notdef" if all_names.any?(".notdef")
+
+          ufo.glyphs.select! { |name, _| names_to_keep.include?(name) }
+        end
+
+        # Ensure .notdef is present at GID 0. The CFF compiler
+        # expects it.
+        #
+        # @param ufo [Ufo::Font]
+        def self.ensure_notdef_present!(ufo)
+          return if ufo.glyphs.key?(".notdef")
+
+          notdef = Ufo::Glyph.new(name: ".notdef")
+          notdef.width = 0
+          ufo.layers.default_layer.add(notdef)
+        end
+
+        private_class_method :filter_ufo_glyphs!, :ensure_notdef_present!
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy.rb

@@ -16,6 +16,7 @@ module Fontisan
     module TableStrategy
       autoload :Cblc, "fontisan/subset/table_strategy/cblc"
       autoload :Cbdt, "fontisan/subset/table_strategy/cbdt"
+      autoload :Cff, "fontisan/subset/table_strategy/cff"
       autoload :Cmap, "fontisan/subset/table_strategy/cmap"
       autoload :ColorBitmapPlacement,
                "fontisan/subset/table_strategy/color_bitmap_placement"
@@ -55,6 +56,7 @@ module Fontisan
         "name" => :Name,
         "head" => :Head,
         "OS/2" => :Os2,
+        "CFF " => :Cff,
         "CBDT" => :Cbdt,
         "CBLC" => :Cblc,
       }.freeze

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.28"
+  VERSION = "0.4.30"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.28
+  version: 0.4.30
 platform: ruby
 authors:
 - Ribose Inc.
@@ -485,6 +485,7 @@ files:
 - lib/fontisan/subset/table_strategy.rb
 - lib/fontisan/subset/table_strategy/cbdt.rb
 - lib/fontisan/subset/table_strategy/cblc.rb
+- lib/fontisan/subset/table_strategy/cff.rb
 - lib/fontisan/subset/table_strategy/cmap.rb
 - lib/fontisan/subset/table_strategy/color_bitmap_placement.rb
 - lib/fontisan/subset/table_strategy/color_bitmap_strike_plan.rb