fontisan 0.4.27 → 0.4.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa4e6e2127d519f9f74aaf89b3d94e675ac09306d6d99eff7735e4789830bd26
-  data.tar.gz: a1f2188729497aff910dcc70e59856e3c72858e33323b4871f626d8443ff505a
+  metadata.gz: bdd148825272b5984f48a9d7e83715161054702eaf84e1c270eff42151c6bcba
+  data.tar.gz: d701f78f818f4b49fbcc047094eadd872e01c5dcd2372516bfaed1098bfa9bf5
 SHA512:
-  metadata.gz: '09ec3032389068dd5870d82c03a89f1b318ad3b76b9b26c1f509d33419fc8728b6d8ff4f3c0e16798380312b003f79118501c9155f581f2f031c9d9893d0baba'
-  data.tar.gz: a5a3cc828bbbd463fda1b74fa7e85b110bc83c55d058a5c484f44213ea4052001c0cf958d73c3b95ec1a3564f4e4ed1cf7901cf6002e7cde8b0ad0c43e98cc04
+  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

@@ -7,12 +7,13 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 
 ### P0 — Correctness gaps (open bugs / silent failures)
 - [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 (PR #108 unskipped the test; now passing with TODO 01)
+- [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 (v0.4.25)

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/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/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.27"
+  VERSION = "0.4.28"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.27
+  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