fontisan 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58c1e2768684af1fcdc55fdc2d5b3e47bbd89b0277794dc64ff627ef8d571c3d
-  data.tar.gz: 8d1da959f850b3872acb01e96deb098ea2cbb0d596a0923b5db4960edfd818bf
+  metadata.gz: 14c31b390c5721b221f5c04239baf1d2330b668d142addd3e321b3bd868f7b7a
+  data.tar.gz: 726fe81623ef7f410aa09e3b7a7838b8e0df1c2304cf9b36d1ad0727bdcf03e8
 SHA512:
-  metadata.gz: 3e46507d14358098c09f5ee2a3584c601e3d28e6a762f506962007445fb9fcd4432db7f591601575fac87d9cad93ae7c57d2c464728888e33dd6b242387c5611
-  data.tar.gz: 1e2dc941fe06dc9769aad1477c970ac48e799d62f3340a08448c0528290562ce2f9ccfd0e021615ebc57a26bcdd19773fd51135d4d214ef31e2a927576c7d06f
+  metadata.gz: f4c11a54cd876590a4e52df790eeadc490da5b3bad9ef2a0ff6186f560ff2b584c29bc2f7fac1881f25771a3a7031b1d1db5d7cf5c0c67c057ec254165d6b2ac
+  data.tar.gz: 556737df14831d0bf14a82ed34e27f9438f93fe0d1c51b6324d0e3f938de3b7ce136bcb0b4a3a8a50698e7e603a02227fd87ee74de530df60e81fcbd5d3a4e5b

data/lib/fontisan/stitcher/source.rb

@@ -185,14 +185,39 @@ module Fontisan
 
       # 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
+        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

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.1"
+  VERSION = "0.4.2"
 end

metadata

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