fontisan 0.4.26 → 0.4.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9d761c9308f66218312a055b752135a728413c634fba54caa309c37076a03f0
-  data.tar.gz: 8ec9394bfde51dec443f7b854ab29d698a9cb70c63543ea4067b0fc23ffd10fc
+  metadata.gz: bdd148825272b5984f48a9d7e83715161054702eaf84e1c270eff42151c6bcba
+  data.tar.gz: d701f78f818f4b49fbcc047094eadd872e01c5dcd2372516bfaed1098bfa9bf5
 SHA512:
-  metadata.gz: a123990197a2754d9039c7c12f9ed8432165ded5f1c8c1b10c6f150d03907ecd09bc0baf50d40e853ccbad4c340b0694718ea74759b6dacb7fe3796212e8c703
-  data.tar.gz: c0510eee21f156b9f9d7e0110da16372a4c8418774144294efa7fcfcb7b049da72b42f6d683b1a8043e91b2f5ce66d201f3ec84173eead40d5bdab36d8d41ca2
+  metadata.gz: 25d8d8fe6c8fed6067a068ac83aec0f737e627fb81775fdd2fd679a38007c72fbfae0554075f539637746d264b31eddd6125fbaeaee0c566a8b0947cb9ea15cf
+  data.tar.gz: 5a6b96d94af207136e925b0a8ed675688c387fbdae471fbbb6120e9703869a42142c598579d25164121a6fd57d009e4ccad760d6c2464c45fe1d711f8071cd63

data/TODO.improvements/15-cff-cff2-subsetter-strategy.md

@@ -0,0 +1,78 @@
+# 15 — CFF/CFF2 subsetter strategy
+
+## Priority
+P0
+
+## Problem
+
+The subsetter's `TableStrategy::REGISTRY` has entries for glyf/loca (TrueType outlines) but NOT for CFF or CFF2 (PostScript outlines). Both fall through to `PassThroughStrategy`, which copies the full source table verbatim.
+
+Two concrete failure modes:
+
+1. **Profiles drop CFF entirely.** The `web`, `pdf`, and `minimal` profiles list glyf/loca but not CFF/CFF2. A CFF-based OTF font subsetted to any of these profiles loses ALL outlines — the output has `cmap`/`head`/`hmtx`/`maxp` but no CFF. The font has no glyph data.
+
+2. **`full` profile includes CFF but doesn't subset it.** The full CFF table is copied verbatim while `maxp.numGlyphs` is updated to the subset count. The CFF CharStrings INDEX has the original glyph count; `maxp` says fewer. Invalid mismatch — fontTools and Chrome reject.
+
+This affects every CFF-based OpenType font (the majority of professional fonts — Adobe, Google Fonts OTFs, variable CFF2 fonts).
+
+## Goal
+
+Two new strategy classes:
+- `Subset::TableStrategy::Cff` — subsets CFF v1 tables
+- `Subset::TableStrategy::Cff2` — subsets CFF2 tables (variable-font aware)
+
+Both registered in the REGISTRY. The `web` and `pdf` profiles updated to include CFF/CFF2 (conditionally — only when the source font has them; the profile loader already handles this via "if table present").
+
+## Approach
+
+**Architecturally preferred path (TODO #05 + #10b dependency):**
+
+If the CFF → UFO conversion (`Ufo::Convert::FromBinData#extract_cff_glyphs`, currently stubbed as TODO #10b) is fully implemented, AND the OTF compiler emits real CFF charstrings (TODO #05), then CFF subsetting is trivial:
+
+```
+CFF font → Ufo::Convert::FromBinData → UFO (with contours)
+         → drop glyphs not in mapping
+         → Ufo::Compile::OtfCompiler → new CFF
+```
+
+No standalone INDEX rebuilder needed. The UFO model is the canonical representation; CFF is a serialization. This is DRY, MECE, OCP-compliant.
+
+**Fallback path (standalone CFF INDEX rebuilder):**
+
+If TODO #05 + #10b are not yet done, a standalone strategy can work at the binary level:
+
+1. Parse CFF header → Name INDEX → Top DICT INDEX → String INDEX → Global Subr INDEX
+2. Decode Top DICT operators → get charset offset, CharStrings offset, Private offset
+3. Parse CharStrings INDEX → get byte range per charstring
+4. Filter to subset GIDs
+5. Rebuild CharStrings INDEX with retained charstrings
+6. Rebuild charset to match new GID ordering
+7. Optionally prune GlobalSubrs/PrivateSubrs
+8. Recompute all offsets in Top DICT
+9. Reassemble CFF bytes
+
+This is more work than the UFO round-trip path and duplicates logic the compile pipeline already has. Prefer the UFO path.
+
+## Out of scope
+
+- CFF2 blend/vsindex ENCODING (TODO 06) — that's about generating new CFF2 from scratch, not subsetting existing CFF2.
+- OTF compiler real CFF (TODO 05) — that's about building CFF from UFO outlines.
+- Font-level outline conversion (TTF→OTF) — that's `Converters::OutlineConverter`.
+
+## Effort
+
+~1-2 days for CFF v1 (well-understood algorithm).
+~1 additional day for CFF2 (adds FDSelect + ItemVariationStore handling).
+
+## Dependencies
+
+None. The CFF/CFF2 BinData models already exist.
+
+## Acceptance criteria
+
+- A CFF-based OTF font subsetted to the `web` profile produces valid output (fontTools accepts it, Chrome OTS doesn't reject).
+- The subset CFF table has exactly `subset_glyph_count` charstrings (not the source's full count).
+- Subroutines referenced only by dropped glyphs are pruned.
+- CFF2 variable fonts retain their ItemVariationStore and variation deltas after subsetting.
+- New spec covers: CFF font → web subset → fontTools decode → glyph count matches.
+- Profile YAML updated: `web` and `pdf` profiles include CFF/CFF2 conditionally.

data/TODO.improvements/README.md

@@ -6,25 +6,26 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 ## Priorities
 
 ### P0 — Correctness gaps (open bugs / silent failures)
-- [01 — CBDT/CBLC GID-stable propagation](01-cbdt-cblc-gid-stable-propagation.md)
-- [02 — Collection-mode outline-priority regression](02-collection-outline-priority.md)
+- [x] ~~[01 — CBDT/CBLC GID-stable propagation](01-cbdt-cblc-gid-stable-propagation.md)~~ ✓ Done (PR #115)
+- [x] ~~[02 — Collection-mode outline-priority regression](02-collection-outline-priority.md)~~ ✓ Already fixed
+- [15 — CFF/CFF2 subsetter strategy](15-cff-cff2-subsetter-strategy.md) — Head crash fixed, profiles updated; CFF→UFO extraction done (TODO #10b); blocked on TODO #05 for full round-trip (PR #108 unskipped the test; now passing with TODO 01)
 
 ### 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)
+- [05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md) ← blocks TODO #15
 
 ### P2 — Specialist feature parity
-- [x] ~~[07 — CPAL v1 header fields](07-cpal-v1-header-fields.md)~~ ✓ Done
+- [x] ~~[07 — CPAL v1 header fields](07-cpal-v1-header-fields.md)~~ ✓ Done (v0.4.25)
+- [x] ~~[08 — CFF standard string table](08-cff-standard-string-table.md)~~ ✓ Partial (SID 0-95, ASCII subset)
 - [06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)
-- [08 — CFF standard string table](08-cff-standard-string-table.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)
 
 ### P3 — Code-quality cleanup
-- [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (commit `4c68f2a`)
-- [12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)
+- [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (v0.4.24)
+- [x] ~~[12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)~~ ✓ Partial (head/hhea/post converted; os2/name/hmtx/cmap remain)
 - [14 — Rubocop baseline chip (per-namespace)](14-rubocop-baseline-chip.md)
 
 ## Convention

data/lib/fontisan/config/subset_profiles.yml

@@ -38,6 +38,8 @@ pdf:
     - post
     - loca
     - glyf
+    - CFF
+    - CFF2
 
 # Web Profile: Tables required for web font usage
 web:
@@ -53,6 +55,8 @@ web:
     - post
     - loca
     - glyf
+    - CFF
+    - CFF2
     - GSUB
     - GPOS
     - CBDT

data/lib/fontisan/stitcher/cbdt_propagator.rb

@@ -80,6 +80,8 @@ module Fontisan
       # @param source [Stitcher::Source] the CBDT source
       # @param target [Ufo::Font] target UFO font to receive placeholders
       def add_placeholder_glyphs(source, target)
+        @placeholder_names = {}
+
         ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
         if ufo
           ufo.glyphs.each_value do |g|
@@ -104,43 +106,28 @@ module Fontisan
           glyph.width = 0
           gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
           target.layers.default_layer.add(glyph)
+          @placeholder_names[gid] = name
         end
       end
 
-      # Propagate the raw CBDT/CBLC tables from the CBDT source into
-      # the compiled font at `path`, rewriting the file in place.
+      # Propagate CBDT/CBLC tables from the CBDT source into the
+      # compiled font at `path`, rewriting the file in place.
       #
       # Reads every table from the compiled font as raw bytes (bypassing
       # BinData #table because some tables — notably CFF2 — don't yet
-      # have round-trippable BinData models), splices in CBDT/CBLC,
-      # and rewrites the file.
-      #
-      # No-op when called with a non-CBDT source or nil.
+      # have round-trippable BinData models), splices in CBDT/CBLC
+      # rebuilt with compiled-font GIDs, and rewrites the file.
       #
-      # == Limitation: GID stability
+      # The CBDT/CBLC rebuild uses Subset::TableStrategy::ColorBitmapSubsetter
+      # to remap every bitmap block from source GID to compiled GID.
+      # This ensures CBLC's IndexSubTableArray references the compiled
+      # font's actual GIDs, not the source's.
       #
-      # The propagation copies CBDT/CBLC bytes verbatim. CBLC indexes
-      # glyphs by SOURCE GID — the GIDs of the CBDT donor. The compiled
-      # font's GIDs may differ because:
+      # Falls back to raw-byte copy when the GID mapping can't be
+      # resolved (no placeholder names recorded, or compiled post table
+      # is v3.0 with no glyph names).
       #
-      #   1. +add_placeholder_glyphs+ renames CBDT placeholders via
-      #      UniqueGlyphName when their default "gid{N}" name collides
-      #      with outline glyphs sharing the same donor-gid scheme
-      #      (see Layer's naming contract).
-      #   2. The compiler assigns GIDs in target-namespace order, which
-      #      is not the same as source-GID order once renaming happens.
-      #
-      # The bitmaps line up correctly only when the CBDT source and
-      # every outline source cover disjoint codepoint ranges (the
-      # Essenfont TTC case: emoji vs CJK Ext G). When ranges overlap,
-      # CBLC's source-GID-indexed bitmaps may point at the wrong
-      # compiled glyphs and the colour rendering for affected
-      # codepoints will fall back to outlines.
-      #
-      # A proper fix requires a CBLC rebuild pass: walk the compiled
-      # font's cmap to find the new GID for every CBDT-covered source
-      # glyph, then rewrite CBLC's IndexSubTableArray + IndexSubTable
-      # offsets to match. Tracked as a follow-up.
+      # No-op when called with a non-CBDT source or nil.
       #
       # @param source [Stitcher::Source, nil] the CBDT source
       # @param path [String] compiled font file to rewrite
@@ -149,25 +136,77 @@ module Fontisan
 
         compiled = FontLoader.load(path)
 
-        # Read every table as raw bytes straight from the file's table
-        # directory. We deliberately bypass #table (which parses via
-        # BinData) because some tables — notably CFF2 — don't yet have
-        # round-trippable BinData models; calling #table on them returns
-        # nil and would silently drop them from the rewritten font.
         tables = {}
         compiled.table_names.each do |tag|
           raw = compiled.table_data[tag]
           tables[tag] = raw if raw
         end
 
-        cbdt_bytes = source.raw_table_bytes("CBDT")
-        cblc_bytes = source.raw_table_bytes("CBLC")
-        tables["CBDT"] = cbdt_bytes if cbdt_bytes
-        tables["CBLC"] = cblc_bytes if cblc_bytes
+        rebuilt = rebuild_color_tables(source, compiled)
+        tables["CBDT"] = rebuilt[:cbdt] if rebuilt[:cbdt]
+        tables["CBLC"] = rebuilt[:cblc] if rebuilt[:cblc]
 
         sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
         FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
       end
+
+      private
+
+      # Rebuild CBDT/CBLC bytes with compiled-font GIDs instead of
+      # source GIDs. Delegates to Subset::TableStrategy::ColorBitmapSubsetter
+      # which already implements the offset-remap algorithm for the
+      # subsetter — the Stitcher case is the same algorithm with a
+      # different GID mapping (source → compiled instead of source →
+      # sequential subset GID).
+      #
+      # Falls back to raw-byte copy when the GID mapping can't be
+      # resolved (no placeholder names recorded, or compiled post/cmap
+      # can't reverse-map them).
+      def rebuild_color_tables(source, compiled)
+        source_cbdt = source.raw_table_bytes("CBDT")
+        source_cblc = source.raw_table_bytes("CBLC")
+        return {} unless source_cbdt && source_cblc
+
+        gid_map = resolve_gid_mapping(compiled)
+        return raw_bytes_fallback(source_cbdt, source_cblc) unless gid_map
+
+        mapping = Subset::GlyphMapping.new(mapping: gid_map)
+        subsetter = Subset::TableStrategy::ColorBitmapSubsetter.new(
+          font: source.font, mapping: mapping,
+        ).build
+
+        { cbdt: subsetter.cbdt_bytes, cblc: subsetter.cblc_bytes }
+      end
+
+      # Build {source_gid => compiled_gid} from the placeholder names
+      # recorded during add_placeholder_glyphs. Walks the compiled
+      # font's post table to find each placeholder's compiled GID.
+      # Returns nil when the mapping can't be resolved (e.g., no
+      # placeholders recorded, or post v3.0 with no names).
+      def resolve_gid_mapping(compiled)
+        return nil unless @placeholder_names && !@placeholder_names.empty?
+
+        post = compiled.table("post")
+        return nil unless post
+
+        names = post.glyph_names
+        return nil unless names
+
+        name_to_gid = {}
+        names.each_with_index { |name, gid| name_to_gid[name] = gid }
+
+        gid_map = {}
+        @placeholder_names.each do |source_gid, placeholder_name|
+          compiled_gid = name_to_gid[placeholder_name]
+          gid_map[source_gid] = compiled_gid if compiled_gid
+        end
+
+        gid_map.empty? ? nil : gid_map
+      end
+
+      def raw_bytes_fallback(cbdt_bytes, cblc_bytes)
+        { cbdt: cbdt_bytes, cblc: cblc_bytes }
+      end
     end
   end
 end

data/lib/fontisan/subset/glyph_mapping.rb

@@ -52,12 +52,17 @@ module Fontisan
       #
       # @example Create mapping that retains GIDs
       #   mapping = GlyphMapping.new([0, 3, 5, 10], retain_gids: true)
-      def initialize(old_glyph_ids, retain_gids: false)
+      def initialize(old_glyph_ids = [], retain_gids: false, mapping: nil)
         @old_to_new = {}
         @new_to_old = {}
         @retain_gids = retain_gids
 
-        build_mappings(old_glyph_ids)
+        if mapping
+          @old_to_new = mapping
+          @new_to_old = mapping.invert
+        else
+          build_mappings(old_glyph_ids)
+        end
       end
 
       # Get new glyph ID for an old glyph ID

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

@@ -28,6 +28,7 @@ module Fontisan
 
         def self.ensure_glyf_built!(context)
           return if context.state.glyf_data
+          return unless context.font.table_data["glyf"]
 
           builder = GlyfLocaBuilder.new(font: context.font,
                                         mapping: context.mapping).build

data/lib/fontisan/tables/cff.rb

@@ -408,30 +408,134 @@ module Fontisan
         true
       end
 
+      # Adobe Standard Encoding glyph names that map 1:1 to CFF SIDs
+      # 0..95. Source: Adobe CFF Specification 1.0 (TN 5176), Appendix A.
+      # These cover the printable ASCII range plus .notdef — the most
+      # common glyph names encountered in CFF fonts.
+      STANDARD_STRINGS_ASCII = [
+        ".notdef", # SID 0
+        "space", # SID 1 (code 32)
+        "exclam", # SID 2 (code 33)
+        "quotedbl", # SID 3 (code 34)
+        "numbersign", # SID 4 (code 35)
+        "dollar", # SID 5 (code 36)
+        "percent", # SID 6 (code 37)
+        "ampersand", # SID 7 (code 38)
+        "quoteright", # SID 8 (code 39)
+        "parenleft", # SID 9 (code 40)
+        "parenright", # SID 10 (code 41)
+        "asterisk", # SID 11 (code 42)
+        "plus", # SID 12 (code 43)
+        "comma", # SID 13 (code 44)
+        "hyphen", # SID 14 (code 45)
+        "period", # SID 15 (code 46)
+        "slash", # SID 16 (code 47)
+        "zero", # SID 17 (code 48)
+        "one", # SID 18 (code 49)
+        "two", # SID 19 (code 50)
+        "three", # SID 20 (code 51)
+        "four", # SID 21 (code 52)
+        "five", # SID 22 (code 53)
+        "six", # SID 23 (code 54)
+        "seven", # SID 24 (code 55)
+        "eight", # SID 25 (code 56)
+        "nine", # SID 26 (code 57)
+        "colon", # SID 27 (code 58)
+        "semicolon", # SID 28 (code 59)
+        "less", # SID 29 (code 60)
+        "equal", # SID 30 (code 61)
+        "greater", # SID 31 (code 62)
+        "question", # SID 32 (code 63)
+        "at", # SID 33 (code 64)
+        "A", # SID 34 (code 65)
+        "B", # SID 35 (code 66)
+        "C", # SID 36 (code 67)
+        "D", # SID 37 (code 68)
+        "E", # SID 38 (code 69)
+        "F", # SID 39 (code 70)
+        "G", # SID 40 (code 71)
+        "H", # SID 41 (code 72)
+        "I", # SID 42 (code 73)
+        "J", # SID 43 (code 74)
+        "K", # SID 44 (code 75)
+        "L", # SID 45 (code 76)
+        "M", # SID 46 (code 77)
+        "N", # SID 47 (code 78)
+        "O", # SID 48 (code 79)
+        "P", # SID 49 (code 80)
+        "Q", # SID 50 (code 81)
+        "R", # SID 51 (code 82)
+        "S", # SID 52 (code 83)
+        "T", # SID 53 (code 84)
+        "U", # SID 54 (code 85)
+        "V", # SID 55 (code 86)
+        "W", # SID 56 (code 87)
+        "X", # SID 57 (code 88)
+        "Y", # SID 58 (code 89)
+        "Z", # SID 59 (code 90)
+        "bracketleft", # SID 60 (code 91)
+        "backslash", # SID 61 (code 92)
+        "bracketright", # SID 62 (code 93)
+        "asciicircum", # SID 63 (code 94)
+        "underscore", # SID 64 (code 95)
+        "quoteleft", # SID 65 (code 96)
+        "a", # SID 66 (code 97)
+        "b", # SID 67 (code 98)
+        "c", # SID 68 (code 99)
+        "d", # SID 69 (code 100)
+        "e", # SID 70 (code 101)
+        "f", # SID 71 (code 102)
+        "g", # SID 72 (code 103)
+        "h", # SID 73 (code 104)
+        "i", # SID 74 (code 105)
+        "j", # SID 75 (code 106)
+        "k", # SID 76 (code 107)
+        "l", # SID 77 (code 108)
+        "m", # SID 78 (code 109)
+        "n", # SID 79 (code 110)
+        "o", # SID 80 (code 111)
+        "p", # SID 81 (code 112)
+        "q", # SID 82 (code 113)
+        "r", # SID 83 (code 114)
+        "s", # SID 84 (code 115)
+        "t", # SID 85 (code 116)
+        "u", # SID 86 (code 117)
+        "v", # SID 87 (code 118)
+        "w", # SID 88 (code 119)
+        "x", # SID 89 (code 120)
+        "y", # SID 90 (code 121)
+        "z", # SID 91 (code 122)
+        "braceleft", # SID 92 (code 123)
+        "bar", # SID 93 (code 124)
+        "braceright", # SID 94 (code 125)
+        "asciitilde", # SID 95 (code 126)
+      ].freeze
+
+      # First SID outside the ASCII subset. SIDs in
+      # EXTENDED_STRINGS_START..390 cover ligatures, currency symbols,
+      # Cyrillic (afii*), etc. Resolving those requires the full
+      # Adobe CFF spec Appendix A table; tracked as a follow-up to
+      # avoid embedding unverified data.
+      EXTENDED_STRINGS_START = STANDARD_STRINGS_ASCII.length
+
       private
 
-      # Get a standard CFF string by SID
-      #
-      # This is a placeholder that returns a generic string.
-      # A complete implementation would include all 391 standard strings
-      # from CFF spec Appendix A.
+      # Get a standard CFF string by SID (0-390).
       #
-      # TODO: Implement complete standard string table in follow-up task
+      # The ASCII subset (SID 0-95) is fully covered. Extended SIDs
+      # (96-390) cover ligatures, currency, Cyrillic, etc., and
+      # require the full Adobe CFF spec Appendix A table to fill in
+      # correctly. Until that follow-up lands, extended SIDs return
+      # nil so callers can detect the gap and fall back to the
+      # custom string index.
       #
       # @param sid [Integer] String ID (0-390)
-      # @return [String] Standard string
+      # @return [String, nil] standard string, or nil for uncovered SIDs
       def standard_string(sid)
-        # Placeholder implementation
-        # Full implementation should include all standard strings
-        # from CFF specification Appendix A
-        case sid
-        when 0 then ".notdef"
-        when 1 then "space"
-        when 2 then "exclam"
-        # ... (388 more standard strings)
-        else
-          ".notdef" # Fallback
-        end
+        return nil if sid.negative?
+        return STANDARD_STRINGS_ASCII[sid] if sid < EXTENDED_STRINGS_START
+
+        nil
       end
 
       # Get the Charset for a specific font

data/lib/fontisan/ufo/convert/from_bin_data.rb

@@ -215,18 +215,78 @@ module Fontisan
           end
         end
 
-        # OTF: extract outlines from CFF charstrings. TODO.full/10b —
-        # for now, stub with advance widths only (no contours).
+        # OTF: extract outlines from CFF charstrings.
         def self.extract_cff_glyphs(font, ufo, cmap, widths, num_glyphs)
+          cff = font.table("CFF ")
+          return extract_cff_glyphs_stub(font, ufo, cmap, widths, num_glyphs) unless cff
+
           num_glyphs.times do |gid|
-            glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"
+            glyph_name = glyph_name_for(font, gid) || "gid#{gid}"
             ufo_glyph = Ufo::Glyph.new(name: glyph_name)
             ufo_glyph.width = widths.fetch(gid, 0).to_f
             cmap.fetch(gid, []).each { |cp| ufo_glyph.add_unicode(cp) }
+
+            charstring = cff.charstring_for_glyph(gid)
+            convert_cff_path_to_ufo(charstring.path, ufo_glyph) if charstring
+
             ufo.layers.default_layer.add(ufo_glyph)
           end
         end
 
+        # Fallback: widths only, no contours (used when CFF table can't
+        # be parsed — e.g., corrupted or unsupported variant).
+        def self.extract_cff_glyphs_stub(font, ufo, cmap, widths, num_glyphs)
+          num_glyphs.times do |gid|
+            glyph_name = glyph_name_for(font, gid) || "gid#{gid}"
+            ufo_glyph = Ufo::Glyph.new(name: glyph_name)
+            ufo_glyph.width = widths.fetch(gid, 0).to_f
+            cmap.fetch(gid, []).each { |cp| ufo_glyph.add_unicode(cp) }
+            ufo.layers.default_layer.add(ufo_glyph)
+          end
+        end
+
+        # Convert a CFF CharString path (array of command hashes) to
+        # UFO contours. Each :move_to starts a new contour; :line_to
+        # and :curve_to append points to the current contour. Cubic
+        # bezier curves produce 2 offcurve + 1 curve points per
+        # segment (GLIF convention).
+        def self.convert_cff_path_to_ufo(path, glyph)
+          return if path.empty?
+
+          current_contour = nil
+
+          path.each do |cmd|
+            case cmd[:type]
+            when :move_to
+              glyph.add_contour(current_contour) if current_contour
+              current_contour = Ufo::Contour.new
+              current_contour.points << Ufo::Point.new(
+                x: cmd[:x].to_i, y: cmd[:y].to_i, type: "move",
+              )
+            when :line_to
+              next unless current_contour
+
+              current_contour.points << Ufo::Point.new(
+                x: cmd[:x].to_i, y: cmd[:y].to_i, type: "line",
+              )
+            when :curve_to
+              next unless current_contour
+
+              current_contour.points << Ufo::Point.new(
+                x: cmd[:x1].to_i, y: cmd[:y1].to_i, type: "offcurve",
+              )
+              current_contour.points << Ufo::Point.new(
+                x: cmd[:x2].to_i, y: cmd[:y2].to_i, type: "offcurve",
+              )
+              current_contour.points << Ufo::Point.new(
+                x: cmd[:x].to_i, y: cmd[:y].to_i, type: "curve",
+              )
+            end
+          end
+
+          glyph.add_contour(current_contour) if current_contour
+        end
+
         # Look up a glyph name from the post table (v2.0) or synthesize.
         def self.glyph_name_for(font, gid)
           post = font.table("post")

data/lib/fontisan/ufo/font.rb

@@ -11,7 +11,7 @@ module Fontisan
     # The class is the read/write API; serialization is handled by
     # Fontisan::Ufo::Reader and Fontisan::Ufo::Writer.
     class Font
-      attr_accessor :path, :info, :features, :kerning, :lib, :ufo_version
+      attr_accessor :path, :info, :features, :kerning, :groups, :lib, :ufo_version
       attr_reader :layers, :data, :images
 
       def initialize
@@ -21,6 +21,7 @@ module Fontisan
         @layers = LayerSet.new
         @features = Features.new
         @kerning = Kerning.new
+        @groups = Groups.new
         @lib = Lib.new
         @data = nil # DataSet needs the Font ref, set by Reader
         @images = ImageSet.new

data/lib/fontisan/ufo/groups.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Group definitions parsed from `groups.plist`. Maps a group name
+    # to a list of glyph names belonging to that group:
+    #
+    #   { "MMK_L_A" => ["A", "Agrave", "Aacute", ...],
+    #     "MMK_R_T" => ["T", "Tcommaaccent", ...] }
+    #
+    # Group pair keys in `kerning.plist` (e.g. `"MMK_L_A MMK_R_T"`)
+    # reference these names — kern writer + GPOS builder resolve them
+    # to glyph sets before emitting PairPos records.
+    class Groups
+      attr_reader :groups
+
+      def initialize(values = {})
+        @groups = values
+      end
+
+      # All group names.
+      def names
+        @groups.keys
+      end
+
+      # Glyph names belonging to +name+. Empty array if unknown.
+      def glyphs(name)
+        @groups[name] || []
+      end
+
+      # Whether +name+ is a known group.
+      def include?(name)
+        @groups.key?(name)
+      end
+
+      def empty?
+        @groups.empty?
+      end
+
+      def to_plist
+        @groups
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/reader.rb

@@ -32,6 +32,7 @@ module Fontisan
         read_layercontents
         read_glyphs_contents
         read_kerning
+        read_groups
         read_features
         read_lib
         @font
@@ -123,6 +124,14 @@ module Fontisan
         @font.kerning = Kerning.new(data)
       end
 
+      def read_groups
+        path = join(@font.path, "groups.plist")
+        return unless File.exist?(path)
+
+        data = Plist.parse(File.read(path))
+        @font.groups = Groups.new(data)
+      end
+
       def read_features
         path = join(@font.path, "features.fea")
         return unless File.exist?(path)

data/lib/fontisan/ufo.rb

@@ -33,6 +33,7 @@ module Fontisan
     autoload :Kerning,     "fontisan/ufo/kerning"
     autoload :Features,    "fontisan/ufo/features"
     autoload :Lib,         "fontisan/ufo/lib"
+    autoload :Groups,      "fontisan/ufo/groups"
     autoload :DataSet,     "fontisan/ufo/data_set"
     autoload :ImageSet,    "fontisan/ufo/image_set"
     autoload :Plist,       "fontisan/ufo/plist"

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.26
+  version: 0.4.28
 platform: ruby
 authors:
 - Ribose Inc.
@@ -147,6 +147,7 @@ files:
 - TODO.improvements/12-cbdt-fixture-bindata-conversion.md
 - TODO.improvements/13-split-octokit-fetcher.md
 - TODO.improvements/14-rubocop-baseline-chip.md
+- TODO.improvements/15-cff-cff2-subsetter-strategy.md
 - TODO.improvements/README.md
 - benchmark/compile_benchmark.rb
 - benchmark/variation_quick_bench.rb
@@ -704,6 +705,7 @@ files:
 - lib/fontisan/ufo/font.rb
 - lib/fontisan/ufo/glyph.rb
 - lib/fontisan/ufo/glyph_exists_error.rb
+- lib/fontisan/ufo/groups.rb
 - lib/fontisan/ufo/guideline.rb
 - lib/fontisan/ufo/image.rb
 - lib/fontisan/ufo/image_set.rb