fontisan 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '020862878eef5569b82edb88989afdc3b7c21d3f01d19b605132af70cabe524f'
-  data.tar.gz: d8d685a687c94f987835e440619aca344a615368ea78d6caf6a882c34c2900d3
+  metadata.gz: 14c31b390c5721b221f5c04239baf1d2330b668d142addd3e321b3bd868f7b7a
+  data.tar.gz: 726fe81623ef7f410aa09e3b7a7838b8e0df1c2304cf9b36d1ad0727bdcf03e8
 SHA512:
-  metadata.gz: a98055b753907dedfd44fd89c61fd3d5d797d405d702e65730bae1e3299665354f385b135529ca6b48708672e37cfa0e10a7b518ce0b624ccb46fae9459cfb22
-  data.tar.gz: 46af4e780f4a1786501e2b874d4b439614c212b839b0b398316806a2baa9348b67c8e4db3e63b85142d79ae015df3f093db957f055ddbd3f4955268caa2c1dfa
+  metadata.gz: f4c11a54cd876590a4e52df790eeadc490da5b3bad9ef2a0ff6186f560ff2b584c29bc2f7fac1881f25771a3a7031b1d1db5d7cf5c0c67c057ec254165d6b2ac
+  data.tar.gz: 556737df14831d0bf14a82ed34e27f9438f93fe0d1c51b6324d0e3f938de3b7ce136bcb0b4a3a8a50698e7e603a02227fd87ee74de530df60e81fcbd5d3a4e5b

data/README.adoc

@@ -2475,6 +2475,36 @@ fontisan stitch \
   --output stitched.ttf
 ----
 
+=== Color emoji (CBDT/CBLC passthrough)
+
+Sources with CBDT/CBLC tables (e.g. NotoColorEmoji) can be used as
+Stitcher sources. The bitmap data is propagated byte-for-byte from the
+source into the output. The Stitcher automatically detects the source's
+storage mode via `bitmap_mode`:
+
+[source,ruby]
+----
+stitcher = Fontisan::Stitcher.new
+stitcher.add_source(:text, Fontisan::FontLoader.load("NotoSans.ttf"))
+stitcher.add_source(:emoji, Fontisan::FontLoader.load("NotoColorEmoji.ttf"))
+
+# All emoji glyphs from the CBDT source are added; the CBLC table
+# is copied byte-for-byte and references the right GIDs.
+stitcher.include_range(0x41..0x5A, from: :text)
+stitcher.include_range(0x1F600..0x1F64F, from: :emoji)
+
+stitcher.write_to("out.ttf", format: :ttf)
+# → out.ttf has glyf + CBDT + CBLC, emoji renders correctly
+----
+
+**Constraints:**
+- Only ONE CBDT source per Stitcher (multiple raise
+  `Fontisan::MultipleCbdtSourcesError`)
+- The CBDT source is processed first (GIDs 0..N-1) so the CBLC's GID
+  references remain valid in the output
+- Multi-source CBDT merge is tracked as TODO (REVIEW
+  `TODO.full/ufo/23-cbdt-passthrough.md`)
+
 
 == Testing
 

data/lib/fontisan/stitcher/source.rb

@@ -6,10 +6,10 @@ module Fontisan
     # extraction API used by the selectors.
     #
     # For UFO sources, glyphs are accessed by name directly. For TTF
-    # or OTF sources, the source is lazily converted to a UFO::Font
-    # via Ufo::Convert::FromBinData on first glyph access, then cached.
-    # This is O(n) in donor glyph count but amortized across all
-    # codepoint extractions from that donor.
+    # or OTF sources, individual glyphs are extracted on demand from
+    # the BinData tables (glyf/loca/head for TTF, CFF for OTF). This
+    # is O(1) per glyph rather than the previous O(n) full-donor
+    # conversion.
     #
     # CBDT/CBLC sources (e.g. NotoColorEmoji) are detected via
     # #bitmap_mode. When a source is :cbdt, the Stitcher propagates
@@ -20,7 +20,7 @@ module Fontisan
 
       def initialize(font)
         @font = font
-        @ufo_cache = nil
+        @bin_data_cache = nil
       end
 
       # @return [Symbol] :ufo, :ttf, :otf
@@ -66,14 +66,19 @@ module Fontisan
 
       # Extract a glyph by gid.
       #
+      # For TTF/OTF sources, this is O(1) per glyph: it parses just
+      # the requested glyph from glyf/CFF on demand, not the entire
+      # donor. The full-donor conversion is avoided entirely.
+      #
       # For CBDT sources, returns a placeholder glyph (no contours)
-      # since the glyph data lives in the bitmap tables, not outlines.
+      # since the glyph data is in the bitmap tables, not outlines.
+      #
       # @param gid [Integer]
       # @return [Fontisan::Ufo::Glyph, nil]
       def glyph_for_gid(gid)
         case @font
         when Fontisan::Ufo::Font then ufo_glyph_at(gid)
-        else converted_ufo_glyph_at(gid)
+        else extract_single_glyph_from_bindata(gid)
         end
       end
 
@@ -89,6 +94,15 @@ module Fontisan
         nil
       end
 
+      # Width of a specific glyph (extracted from hmtx).
+      # Falls back to 0 if hmtx is missing.
+      # @param gid [Integer]
+      # @return [Integer]
+      def glyph_width(gid)
+        widths = bin_data_widths
+        widths[gid] || 0
+      end
+
       private
 
       # ---------- UFO source ----------
@@ -108,7 +122,7 @@ module Fontisan
         @font.glyph(name)
       end
 
-      # ---------- TTF/OTF source ----------
+      # ---------- TTF/OTF source: O(1) per-glyph extraction ----------
 
       def bin_data_gid_for(codepoint)
         cmap = @font.table("cmap")
@@ -117,22 +131,137 @@ module Fontisan
         cmap.unicode_mappings[codepoint]
       end
 
-      # Lazily convert the loaded TTF/OTF to a UFO::Font, then
-      # extract glyphs from the cached UFO model.
-      def converted_ufo
-        return @ufo_cache if @ufo_cache
+      # Lazily parse the relevant BinData tables. Cached so we only
+      # pay the parse cost once per source.
+      def bin_data_cache
+        @bin_data_cache ||= parse_bin_data_tables
+      end
+
+      def parse_bin_data_tables
+        cache = { head: @font.table("head") }
+
+        if @font.has_table?("glyf")
+          cache[:loca] = @font.table("loca")
+          cache[:glyf] = @font.table("glyf")
+          # loca needs head's index_to_loc_format to size its offsets
+          if cache[:loca].respond_to?(:parse_with_context) && cache[:head]
+            cache[:loca].parse_with_context(
+              cache[:head].index_to_loc_format,
+              @font.table("maxp")&.num_glyphs || 0,
+            )
+          end
+        end
+
+        cache
+      end
 
-        @ufo_cache = Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      # Build {gid → advance_width} from hmtx (cached).
+      def bin_data_widths
+        @bin_data_widths ||= build_bin_data_widths
       end
 
-      def converted_ufo_glyph_at(gid)
+      def build_bin_data_widths
+        widths = {}
+        hmtx = @font.table("hmtx")
+        return widths unless hmtx
+
+        hhea = @font.table("hhea")
+        maxp = @font.table("maxp")
+        num_h_metrics = hhea&.number_of_h_metrics || 1
+        num_glyphs = maxp&.num_glyphs || 0
+
+        if hmtx.respond_to?(:parse_with_context)
+          hmtx.parse_with_context(num_h_metrics, num_glyphs)
+        end
+
+        num_glyphs.times do |gid|
+          metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+          widths[gid] = metric ? metric[:advance_width] : 0
+        rescue StandardError
+          widths[gid] = 0
+        end
+        widths
+      end
+
+      # Extract a single glyph by gid, parsing just the relevant bytes.
+      # O(1) per call (after the first call's table-parsing overhead).
+      #
+      # For TTF (glyf) sources: reads one glyph from glyf/loca.
+      # For OTF (CFF) sources: falls back to the full-donor conversion
+      # BUT uses a proper gid→name map (not array index) to avoid the
+      # gid-misalignment bug that dropped Plane 1 codepoints.
+      def extract_single_glyph_from_bindata(gid)
+        cache = bin_data_cache
+
+        if cache[:glyf] && cache[:loca] && cache[:head]
+          extract_truetype_glyph(gid, cache)
+        elsif @font.has_table?("CFF ")
+          extract_cff_glyph_safe(gid)
+        end
+      end
+
+      # CFF glyph extraction: uses the full UFO conversion. After the
+      # fix in FromBinData (no more `next unless simple`), every gid
+      # gets a glyph, so array index = gid.
+      def extract_cff_glyph_safe(gid)
         ufo = converted_ufo
         names = ufo.glyphs.keys
-        name = names[gid]
-        return nil unless name
+        return nil if gid >= names.size
 
+        name = names[gid]
         ufo.glyph(name)
       end
+
+      # Lazily convert the loaded TTF/OTF to a UFO::Font (for CFF
+      # sources and as a fallback).
+      def converted_ufo
+        @converted_ufo ||= Fontisan::Ufo::Convert::FromBinData.convert(@font)
+      end
+
+      def extract_truetype_glyph(gid, cache)
+        simple = cache[:glyf].glyph_for(gid, cache[:loca], cache[:head])
+        return nil unless simple
+        return nil unless simple.respond_to?(:simple?) && simple.simple?
+
+        name = gid.zero? ? ".notdef" : "gid#{gid}"
+        glyph = Fontisan::Ufo::Glyph.new(name: name)
+        glyph.width = glyph_width(gid)
+        copy_simple_contours(simple, glyph)
+        add_cmap_unicodes(gid, glyph)
+        glyph
+      rescue StandardError
+        nil
+      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
+        return if num_contours.zero?
+
+        num_contours.times do |ci|
+          points = simple.points_for_contour(ci)
+          next unless points && !points.empty?
+
+          ufo_points = points.map do |pt|
+            x = pt[:x] || pt["x"]
+            y = pt[:y] || pt["y"]
+            on_curve = pt[:on_curve].nil? || pt[:on_curve]
+            type = on_curve ? "line" : "offcurve"
+            Fontisan::Ufo::Point.new(x: x.to_f, y: y.to_f, type: type)
+          end
+          ufo_glyph.add_contour(Fontisan::Ufo::Contour.new(ufo_points))
+        end
+      end
+
+      # Add Unicode codepoints from the cmap that map to this gid.
+      def add_cmap_unicodes(gid, glyph)
+        cmap = @font.table("cmap")
+        return unless cmap
+
+        (cmap.unicode_mappings || {}).each do |cp, g|
+          glyph.add_unicode(cp) if g == gid
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `GPOS` (Glyph Positioning) table from UFO
+      # kerning data. Emits a minimal but valid GPOS with:
+      #
+      #   - ScriptList: DFLT script, default language system
+      #   - FeatureList: `kern` feature (feature tag "kern")
+      #   - LookupList: one PairPos lookup (format 1, individual pairs)
+      #
+      # Each kerning pair from the UFO source becomes a PairPosRecord
+      # with an x-advance adjustment on the first glyph.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/gpos
+      module Gpos
+        FEATURE_KERN = "kern"
+        SCRIPT_DFLT = "DFLT"
+        LANGSYS_DEFAULT = 0
+
+        # ValueFormat flags (which fields are present in a ValueRecord)
+        VALUE_X_PLACEMENT = 0x0001
+        VALUE_Y_PLACEMENT = 0x0002
+        VALUE_X_ADVANCE = 0x0004
+        VALUE_Y_ADVANCE = 0x0008
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String, nil] GPOS table bytes, or nil if no kerning
+        def self.build(font, glyphs:)
+          pairs = collect_kerning_pairs(font, glyphs)
+          return nil if pairs.empty?
+
+          build_gpos_table(pairs)
+        end
+
+        # ---------- pair collection ----------
+
+        # Collect kerning pairs from the UFO model. Each pair is
+        # (gid1, gid2, x_advance_delta).
+        # @return [Array<[Integer, Integer, Integer]>]
+        def self.collect_kerning_pairs(font, glyphs)
+          name_to_gid = {}
+          glyphs.each_with_index { |g, gid| name_to_gid[g.name] = gid }
+
+          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
+
+            pairs << [gid1, gid2, value.to_i]
+          end
+
+          pairs.sort_by { |a| [a[0], a[1]] }
+        end
+
+        # ---------- GPOS binary assembly ----------
+
+        def self.build_gpos_table(pairs)
+          # Group pairs by first glyph (gid1)
+          by_first = {}
+          pairs.each do |gid1, gid2, delta|
+            by_first[gid1] ||= []
+            by_first[gid1] << [gid2, delta]
+          end
+
+          first_gids = by_first.keys.sort
+
+          # --- Build subtables bottom-up ---
+
+          # 1. PairSets (one per first glyph)
+          pair_sets_data = {}
+          pair_set_offsets = {}
+          pair_sets_blob = +""
+
+          first_gids.each do |gid1|
+            pair_set_offsets[gid1] = pair_sets_blob.bytesize
+
+            second_pairs = by_first[gid1].sort_by { |gid2, _| gid2 }
+            data = [second_pairs.size].pack("n") # pairValueCount
+            second_pairs.each do |gid2, delta|
+              data << [gid2, delta, 0].pack("nnn") # secondGlyph + valRec1(xAdvance) + valRec2(0)
+            end
+
+            pair_sets_data[gid1] = data
+            pair_sets_blob << data
+          end
+
+          # 2. Coverage table (Format 1: individual glyphs)
+          coverage = build_coverage_format1(first_gids)
+
+          # 3. PairPosFormat1 subtable
+          value_format1 = VALUE_X_ADVANCE
+          value_format2 = 0
+
+          pairpos_header_size = 10 # format(2) + coverageOffset(2) + valueFormat1(2) + valueFormat2(2) + pairSetCount(2)
+          pairset_array_size = first_gids.size * 2 # one uint16 offset per first glyph
+
+          coverage_offset = pairpos_header_size + pairset_array_size
+          pairset_base = coverage_offset + coverage.bytesize
+
+          pairpos = +""
+          pairpos << [1].pack("n") # posFormat = 1
+          pairpos << [coverage_offset].pack("n") # coverageOffset
+          pairpos << [value_format1].pack("n") # valueFormat1
+          pairpos << [value_format2].pack("n") # valueFormat2
+          pairpos << [first_gids.size].pack("n") # pairSetCount
+
+          # PairSet offsets (relative to start of PairPos subtable)
+          first_gids.each do |gid1|
+            pairpos << [pairset_base + pair_set_offsets[gid1]].pack("n")
+          end
+
+          pairpos << coverage
+          pairpos << pair_sets_blob
+
+          # 4. Lookup table (type 2 = PairPos, flag 0)
+          lookup_header = [
+            2,   # lookupType = PairPos
+            0,   # lookupFlag
+            1,   # subTableCount
+          ].pack("nnn")
+
+          subtable_offset = lookup_header.bytesize + 2 # +2 for the offset array
+          lookup = lookup_header + [subtable_offset].pack("n") + pairpos
+
+          # 5. Assemble GPOS header + ScriptList + FeatureList + LookupList
+
+          # ScriptList (minimal: DFLT script, default LangSys)
+          script_list = build_script_list
+
+          # FeatureList (minimal: kern feature)
+          feature_list = build_feature_list
+
+          # LookupList (minimal: one lookup)
+          lookup_list_header = [1].pack("n") # lookupCount
+          lookup_offset_in_list = lookup_list_header.bytesize + 2 # +2 for the offset
+          lookup_list = lookup_list_header + [lookup_offset_in_list].pack("n") + lookup
+
+          # GPOS header (version 1.0)
+          header_size = 10 # version(4) + scriptListOffset(2) + featureListOffset(2) + lookupListOffset(2)
+          script_list_offset = header_size
+          feature_list_offset = script_list_offset + script_list.bytesize
+          lookup_list_offset = feature_list_offset + feature_list.bytesize
+
+          header = [
+            0x00010000, # version 1.0
+            script_list_offset,
+            feature_list_offset,
+            lookup_list_offset,
+          ].pack("Nnnn")
+
+          header + script_list + feature_list + lookup_list
+        end
+
+        # Coverage Format 1: list of individual glyph IDs.
+        def self.build_coverage_format1(gids)
+          [1, gids.size].pack("nn") + gids.pack("n*")
+        end
+
+        # ScriptList: DFLT script with a single default LangSys.
+        # The LangSys references feature index 0 (kern).
+        def self.build_script_list
+          # ScriptList header: scriptCount(2)
+          # ScriptRecord: scriptTag(4) + scriptOffset(2)
+          # Script table: defaultLangSysOffset(2) + langSysCount(2) = 0
+          # LangSys: lookupOrder(2)=0 + reqFeatureIndex(2)=0xFFFF + featureIndexCount(2)=1 + featureIndex(2)=0
+
+          script_list_header_size = 2 + (4 + 2) # scriptCount + 1 ScriptRecord
+          script_offset = script_list_header_size
+          langsys_offset = script_offset + 4 # script table size (defaultLangSysOffset + langSysCount)
+
+          script_list = +""
+          script_list << [1].pack("n") # scriptCount
+          script_list << SCRIPT_DFLT # scriptTag
+          script_list << [script_offset].pack("n") # scriptOffset
+
+          # Script table
+          script_list << [langsys_offset - script_offset].pack("n") # defaultLangSysOffset (relative)
+          script_list << [0].pack("n") # langSysCount
+
+          # Default LangSys
+          script_list << [0].pack("n") # lookupOrder (reserved)
+          script_list << [0xFFFF].pack("n") # reqFeatureIndex (none)
+          script_list << [1].pack("n") # featureIndexCount
+          script_list << [0].pack("n") # featureIndex[0] = kern
+
+          script_list
+        end
+
+        # FeatureList: one feature record (kern) referencing lookup 0.
+        def self.build_feature_list
+          # FeatureList header: featureCount(2)
+          # FeatureRecord: featureTag(4) + featureOffset(2)
+          # Feature table: featureParams(2)=0 + lookupIndexCount(2)=1 + lookupIndex(2)=0
+
+          feature_list_header_size = 2 + (4 + 2) # featureCount + 1 FeatureRecord
+          feature_offset = feature_list_header_size
+
+          feature_list = +""
+          feature_list << [1].pack("n") # featureCount
+          feature_list << FEATURE_KERN # featureTag
+          feature_list << [feature_offset].pack("n") # featureOffset
+
+          # Feature table
+          feature_list << [0].pack("n") # featureParams (null)
+          feature_list << [1].pack("n") # lookupIndexCount
+          feature_list << [0].pack("n") # lookupIndex[0]
+
+          feature_list
+        end
+
+        private_class_method :build_gpos_table, :build_coverage_format1,
+                             :build_script_list, :build_feature_list
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile.rb

@@ -33,6 +33,7 @@ module Fontisan
       autoload :TtfCompiler,  "fontisan/ufo/compile/ttf_compiler"
       autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
       autoload :Filters,      "fontisan/ufo/compile/filters"
+      autoload :Gpos,         "fontisan/ufo/compile/gpos"
       autoload :Head,         "fontisan/ufo/compile/head"
       autoload :Hhea,         "fontisan/ufo/compile/hhea"
       autoload :Maxp,         "fontisan/ufo/compile/maxp"

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

@@ -179,12 +179,15 @@ module Fontisan
             rescue StandardError
               nil
             end
-            next unless simple
 
             if simple.is_a?(Fontisan::Tables::SimpleGlyph)
               extract_simple_contours(simple, ufo_glyph)
             end
 
+            # Always add the glyph, even if it has no contours. This
+            # ensures gid → array index alignment (no gaps from skipped
+            # glyphs). Without this, high-gid Plane 1 codepoints are
+            # silently dropped because the array is shorter than maxp.
             ufo.layers.default_layer.add(ufo_glyph)
           end
         end

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -564,6 +564,7 @@ files:
 - lib/fontisan/ufo/compile/filters/flatten_components.rb
 - lib/fontisan/ufo/compile/filters/reverse_contour_direction.rb
 - lib/fontisan/ufo/compile/glyf_loca.rb
+- lib/fontisan/ufo/compile/gpos.rb
 - lib/fontisan/ufo/compile/head.rb
 - lib/fontisan/ufo/compile/hhea.rb
 - lib/fontisan/ufo/compile/hmtx.rb