fontisan 0.4.21 → 0.4.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55632b625474e82c1cf9573ad6fce2de32f5636823701023abee87fc8817d8fc
-  data.tar.gz: 5a26b3428874b792c101484dbed0468c25eb9f8eb7644a2c0ffff61c8f2baf6a
+  metadata.gz: 208fa8e2c44bdea2e800ecb13639d50e06e6914406822f6e3c92152d21414fd7
+  data.tar.gz: cdce57d3a157d5a5549b45104f93de38263697989bae6a66572907bc54b58bb0
 SHA512:
-  metadata.gz: e7334f4be856d9a86712a0215c3671c7148d623649d4b81d232aa5f70b8aee71e1e55047a2780f48a7018721026e13dc99f0fff6dcbeda49801f88a832cbf99e
-  data.tar.gz: a6432a0a4db97bdfedd597f5f79f40be36b0fd5d450f21e43319023a85b3e331377b2ee7e002fceb9f90c2e9e9a9ee4c1489ebd25e295058e5605d5be0482f57
+  metadata.gz: c87e9ec10e9cadd168dda76b38ef225c1e286bc63501b75268a7cd29fcdfbef3d86abacac211052d529d153aebf1f8db29aaab7445c51a5a83e3eb091f752ab4
+  data.tar.gz: 4632d882fe8ab4897ed32722ec17efb942819ded33e2005bf51c3032384466164d2c2c09a1a8f4388f1889b5c169f42b9dc14ae5cafce72ef5680c94d2333c02

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-07-08 06:50:36 UTC using RuboCop version 1.86.1.
+# on 2026-07-08 08:05:45 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -12,7 +12,7 @@ Gemspec/RequiredRubyVersion:
     - 'docs/node_modules/speakingurl/speakingurl-rails.gemspec'
     - 'fontisan.gemspec'
 
-# Offense count: 2110
+# Offense count: 2116
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -95,7 +95,7 @@ Lint/UselessConstantScoping:
     - 'lib/fontisan/conversion_options.rb'
     - 'lib/fontisan/type1/charstrings.rb'
 
-# Offense count: 704
+# Offense count: 705
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -221,7 +221,7 @@ RSpec/DescribeMethod:
     - 'spec/fontisan/type1/seac_expander_spec.rb'
     - 'spec/fontisan/type1_real_fonts_spec.rb'
 
-# Offense count: 1666
+# Offense count: 1673
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -298,7 +298,7 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 2103
+# Offense count: 2105
 RSpec/MultipleExpectations:
   Max: 19
 

data/lib/fontisan/stitcher/cbdt_propagator.rb

@@ -0,0 +1,151 @@
+# frozen_string: true
+
+module Fontisan
+  class Stitcher
+    # Owns every CBDT-specific concern in the stitch pipeline.
+    #
+    # The Stitcher has two distinct CBDT responsibilities that benefit
+    # from being in one place:
+    #
+    #   1. Detection: exactly one CBDT source per stitch is supported.
+    #      Multiple CBDT sources raise MultipleCbdtSourcesError.
+    #
+    #   2. Action: when a CBDT source exists, the stitcher
+    #      - injects empty CBDT placeholder glyphs into the target UFO
+    #        (the bitmap data lives in CBDT/CBLC tables, not in outlines),
+    #      - propagates the raw CBDT/CBLC tables into the compiled font
+    #        file so the bitmaps survive the round-trip.
+    #
+    # Both responsibilities are model-driven from the CBDT Source itself
+    # (`Source#bitmap_mode == :cbdt`), so the propagator is stateless
+    # given a list of sources. Tests can construct one with synthetic
+    # sources directly.
+    class CbdtPropagator
+      # @param sources [Array<Stitcher::Source>] all sources the stitcher
+      #   knows about, in label order (the propagator does not care
+      #   about labels).
+      def initialize(sources)
+        @sources = sources
+      end
+
+      # @return [Stitcher::Source, nil] the single CBDT source, or nil
+      #   if there is none.
+      # @raise [MultipleCbdtSourcesError] if more than one source is
+      #   marked :cbdt.
+      def cbdt_source
+        cbdts = @sources.select { |s| s.bitmap_mode == :cbdt }
+        return nil if cbdts.empty?
+
+        if cbdts.size > 1
+          raise MultipleCbdtSourcesError,
+                "multiple CBDT sources not supported (found #{cbdts.size})"
+        end
+
+        cbdts.first
+      end
+
+      # Safe variant: returns nil instead of raising when there are
+      # multiple CBDT sources. Used inside the per-subfont glyph-copy
+      # pass where raising mid-compile would leave partial state.
+      #
+      # @return [Stitcher::Source, nil]
+      def safe_cbdt_source
+        cbdt_source
+      rescue MultipleCbdtSourcesError
+        nil
+      end
+
+      # Inject empty CBDT placeholder glyphs from `source` into the
+      # target UFO. One placeholder per gid in the source's maxp/cmap.
+      # Outline data is intentionally absent — the bitmap lives in
+      # the CBDT table that #propagate_tables_into will copy later.
+      #
+      # Glyphs are NOT registered with the deduplicator: each CBDT
+      # glyph is unique to its source, and deduplication would
+      # incorrectly collapse distinct bitmaps.
+      #
+      # @param source [Stitcher::Source] the CBDT source
+      # @param target [Ufo::Font] target UFO font to receive placeholders
+      def add_placeholder_glyphs(source, target)
+        ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
+        if ufo
+          ufo.glyphs.each_value { |g| target.layers.default_layer.add(clone_glyph(g, name: g.name)) }
+          return
+        end
+
+        maxp = source.font.table("maxp")
+        num_glyphs = maxp&.num_glyphs || 0
+        cmap = source.font.table("cmap")
+        mappings = cmap&.unicode_mappings || {}
+
+        gid_cps = Hash.new { |h, k| h[k] = [] }
+        mappings.each { |cp, gid| gid_cps[gid] << cp }
+
+        num_glyphs.times do |gid|
+          name = gid.zero? ? ".notdef" : "gid#{gid}"
+          glyph = Ufo::Glyph.new(name: name)
+          glyph.width = 0
+          gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
+          target.layers.default_layer.add(glyph)
+        end
+      end
+
+      # Propagate the raw 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.
+      #
+      # @param source [Stitcher::Source, nil] the CBDT source
+      # @param path [String] compiled font file to rewrite
+      def propagate_tables_into(source, path)
+        return unless source
+
+        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
+
+        sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
+        FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
+      end
+
+      private
+
+      def clone_glyph(original, name:)
+        copy = Ufo::Glyph.new(name: name)
+        copy.width = original.width
+        copy.height = original.height
+        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+        original.components.each { |c| copy.add_component(c) }
+        original.anchors.each { |a| copy.add_anchor(a) }
+        original.guidelines.each { |g| copy.add_guideline(g) }
+        copy
+      end
+
+      def clone_contour(original)
+        points = original.points.map do |p|
+          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+        end
+        Ufo::Contour.new(points)
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_copier.rb

@@ -0,0 +1,139 @@
+# frozen_string: true
+
+module Fontisan
+  class Stitcher
+    # Owns the mechanical concerns of copying glyphs from donor sources
+    # into a target UFO font.
+    #
+    # The Stitcher's per-subfont build needs to:
+    #   - inject a `.notdef` glyph at GID 0
+    #   - copy outline glyphs from donor sources, optionally skipping
+    #     donors the caller names (e.g. the CBDT source, whose glyphs
+    #     take a different code path)
+    #   - register each copied glyph with the deduplicator so visually
+    #     identical glyphs from different donors share a gid
+    #
+    # GlyphCopier centralizes that logic in one stateless-per-call
+    # collaborator. The Stitcher constructs one with a deduplicator and
+    # calls its methods in the order the cmap contract requires
+    # (see Fontisan::Ufo::Compile::Cmap for first-wins semantics).
+    class GlyphCopier
+      # @param deduplicator [Stitcher::Deduplicator, nil] when non-nil,
+      #   visually identical glyphs share a gid in the target. Pass nil
+      #   to disable deduplication.
+      def initialize(deduplicator)
+        @deduplicator = deduplicator
+      end
+
+      # Inject a `.notdef` glyph at GID 0 of `target`.
+      #
+      # If a binding exists with `donor_gid == 0`, copy the donor's
+      # .notdef; otherwise synthesize an empty one. The injected glyph
+      # is registered with the deduplicator so subsequent .notdef
+      # references deduplicate against it.
+      #
+      # @param bindings [Array<Hash>] stitch bindings to search
+      # @param target [Ufo::Font] target UFO
+      def inject_notdef(bindings, target)
+        notdef_binding = bindings.find { |b| b[:donor_gid].zero? }
+        if notdef_binding
+          copy_glyph_into(target, name: ".notdef",
+                                  source: notdef_binding[:source],
+                                  donor_gid: 0)
+        else
+          target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
+        end
+        dedup_target = target.glyphs[".notdef"]
+        @deduplicator&.register(dedup_target, ".notdef") if dedup_target
+      end
+
+      # Copy outline glyphs from `bindings` into `target`, skipping any
+      # sources the caller names (e.g. the CBDT source).
+      #
+      # Bindings are sorted by `[codepoint, donor_gid]` for deterministic
+      # output. For each binding:
+      #   - if deduplicator has seen a visually identical glyph that's
+      #     already in the target, attach the codepoint to that glyph
+      #     (extra unicode mapping);
+      #   - otherwise copy the glyph under a unique name and register
+      #     with the deduplicator.
+      #
+      # @param bindings [Array<Hash>] stitch bindings
+      # @param target [Ufo::Font] target UFO
+      # @param skip_sources [Array<Stitcher::Source>] sources whose
+      #   bindings should be skipped (e.g. CBDT placeholder source)
+      def copy_outlines(bindings, target, skip_sources: [])
+        sorted_bindings(bindings).each do |binding|
+          next if binding[:donor_gid].zero?
+          next if skip_sources.any? { |s| s.equal?(binding[:source]) }
+
+          glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
+          next unless glyph
+
+          canonical = @deduplicator&.find(glyph)
+          if canonical && target.glyphs.key?(canonical)
+            add_extra_unicode(target, canonical, binding[:codepoint])
+          else
+            name = unique_target_name(target, glyph.name)
+            copy_glyph_into(target, name: name, source: binding[:source],
+                                    donor_gid: binding[:donor_gid],
+                                    codepoint: binding[:codepoint])
+            @deduplicator&.register(glyph, name)
+          end
+        end
+      end
+
+      private
+
+      def sorted_bindings(bindings)
+        bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
+      end
+
+      def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
+        original = source.glyph_for_gid(donor_gid)
+        return unless original
+
+        copy = clone_glyph(original, name: name)
+        copy.add_unicode(codepoint) if codepoint
+        target_font.layers.default_layer.add(copy)
+      end
+
+      def add_extra_unicode(target_font, glyph_name, codepoint)
+        return unless codepoint
+
+        glyph = target_font.glyph(glyph_name)
+        glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
+      end
+
+      def unique_target_name(target_font, base_name)
+        return base_name unless target_font.glyphs.key?(base_name)
+
+        suffix = 1
+        loop do
+          candidate = "#{base_name}.#{suffix}"
+          return candidate unless target_font.glyphs.key?(candidate)
+
+          suffix += 1
+        end
+      end
+
+      def clone_glyph(original, name:)
+        copy = Ufo::Glyph.new(name: name)
+        copy.width = original.width
+        copy.height = original.height
+        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+        original.components.each { |c| copy.add_component(c) }
+        original.anchors.each { |a| copy.add_anchor(a) }
+        original.guidelines.each { |g| copy.add_guideline(g) }
+        copy
+      end
+
+      def clone_contour(original)
+        points = original.points.map do |p|
+          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+        end
+        Ufo::Contour.new(points)
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher.rb

@@ -34,6 +34,8 @@ module Fontisan
     autoload :SubfontStats,     "fontisan/stitcher/collection_result"
     autoload :FormatMetadata,   "fontisan/stitcher/format_metadata"
     autoload :PartitionStrategy, "fontisan/stitcher/partition_strategy"
+    autoload :CbdtPropagator,   "fontisan/stitcher/cbdt_propagator"
+    autoload :GlyphCopier,      "fontisan/stitcher/glyph_copier"
 
     # Internal: pairs a compiled loaded font with its stats so
     # +write_collection+ can build the collection and the result from a
@@ -98,7 +100,7 @@ module Fontisan
       metadata = FormatMetadata.resolve(format)
       metadata.compiler_class.new(target).compile(output_path: path)
 
-      propagate_cbdt_tables(path) if cbdt_source
+      cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source, path)
       path
     end
 
@@ -129,25 +131,6 @@ module Fontisan
       end
     end
 
-    def cbdt_source
-      cbdts = @sources.values.select { |s| s.bitmap_mode == :cbdt }
-      if cbdts.size > 1
-        raise MultipleCbdtSourcesError,
-              "multiple CBDT sources not supported (found #{cbdts.size})"
-      end
-
-      cbdts.first
-    end
-
-    # Safe variant of #cbdt_source: returns nil instead of raising when
-    # the project has multiple CBDT sources. Used inside the per-subfont
-    # glyph-copy pass where raising mid-compile would leave partial state.
-    def safe_cbdt_source
-      cbdt_source
-    rescue MultipleCbdtSourcesError
-      nil
-    end
-
     def build_target_for(subfont_name)
       bindings = @subfonts[subfont_name] || []
       target = Ufo::Font.new
@@ -165,7 +148,7 @@ module Fontisan
       Dir.mktmpdir do |dir|
         sub_path = File.join(dir, "sub#{subfont_name}#{metadata.extension}")
         metadata.compiler_class.new(target).compile(output_path: sub_path)
-        propagate_cbdt_tables(sub_path) if cbdt_source
+        cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source, sub_path)
 
         loaded = Fontisan::FontLoader.load(sub_path)
         stats = SubfontStats.new(
@@ -178,152 +161,22 @@ module Fontisan
     end
 
     def assign_gids_and_copy_glyphs(bindings, target, deduplicator)
-      cbdt = safe_cbdt_source
+      cbdt = cbdt_propagator.safe_cbdt_source
+      copier = GlyphCopier.new(deduplicator)
 
       # Glyph ordering matters: Cmap.build uses first-wins semantics
       # (Cmap.build docstring), so outline donors must be stitched
       # before CBDT placeholders. Otherwise the empty CBDT placeholder
       # would land at a lower GID and win the cp→gid mapping for any
       # codepoint covered by both donors, hiding the real outline glyph.
-      # CBDT bitmap data still propagates via propagate_cbdt_tables.
-      add_notdef_from(bindings, target, deduplicator)
-      add_outline_glyphs(bindings, target, deduplicator,
-                         skip_sources: cbdt ? [cbdt] : [])
-      add_all_cbdt_glyphs(cbdt, target) if cbdt
-    end
-
-    def add_outline_glyphs(bindings, target, deduplicator, skip_sources:)
-      sorted_bindings(bindings).each do |binding|
-        next if binding[:donor_gid].zero?
-        next if skip_sources.any? { |s| s.equal?(binding[:source]) }
-
-        glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
-        next unless glyph
-
-        canonical = deduplicator&.find(glyph)
-        if canonical && target.glyphs.key?(canonical)
-          add_extra_unicode(target, canonical, binding[:codepoint])
-        else
-          name = unique_target_name(target, glyph.name)
-          copy_glyph_into(target, name: name, source: binding[:source],
-                                  donor_gid: binding[:donor_gid],
-                                  codepoint: binding[:codepoint])
-          deduplicator&.register(glyph, name)
-        end
-      end
-    end
-
-    def sorted_bindings(bindings)
-      bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
-    end
-
-    def add_notdef_from(bindings, target, deduplicator)
-      notdef_binding = bindings.find { |b| b[:donor_gid].zero? }
-      if notdef_binding
-        copy_glyph_into(target, name: ".notdef",
-                                source: notdef_binding[:source],
-                                donor_gid: 0)
-      else
-        target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
-      end
-      dedup_target = target.glyphs[".notdef"]
-      deduplicator&.register(dedup_target, ".notdef") if dedup_target
-    end
-
-    def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
-      original = source.glyph_for_gid(donor_gid)
-      return unless original
-
-      copy = clone_glyph(original, name: name)
-      copy.add_unicode(codepoint) if codepoint
-      target_font.layers.default_layer.add(copy)
-    end
-
-    def add_extra_unicode(target_font, glyph_name, codepoint)
-      return unless codepoint
-
-      glyph = target_font.glyph(glyph_name)
-      glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
+      # CBDT bitmap data still propagates via CbdtPropagator.
+      copier.inject_notdef(bindings, target)
+      copier.copy_outlines(bindings, target, skip_sources: cbdt ? [cbdt] : [])
+      cbdt_propagator.add_placeholder_glyphs(cbdt, target) if cbdt
     end
 
-    def unique_target_name(target_font, base_name)
-      return base_name unless target_font.glyphs.key?(base_name)
-
-      suffix = 1
-      loop do
-        candidate = "#{base_name}.#{suffix}"
-        return candidate unless target_font.glyphs.key?(candidate)
-
-        suffix += 1
-      end
-    end
-
-    def clone_glyph(original, name:)
-      copy = Ufo::Glyph.new(name: name)
-      copy.width = original.width
-      copy.height = original.height
-      original.contours.each { |c| copy.add_contour(clone_contour(c)) }
-      original.components.each { |c| copy.add_component(c) }
-      original.anchors.each { |a| copy.add_anchor(a) }
-      original.guidelines.each { |g| copy.add_guideline(g) }
-      copy
-    end
-
-    def clone_contour(original)
-      points = original.points.map do |p|
-        Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
-      end
-      Ufo::Contour.new(points)
-    end
-
-    def propagate_cbdt_tables(path)
-      source = cbdt_source
-      return unless source
-
-      compiled = Fontisan::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
-
-      sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
-      Fontisan::FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
-    end
-
-    def add_all_cbdt_glyphs(source, target)
-      ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
-      if ufo
-        ufo.glyphs.each_value { |g| target.layers.default_layer.add(clone_glyph(g, name: g.name)) }
-        return
-      end
-
-      maxp = source.font.table("maxp")
-      num_glyphs = maxp&.num_glyphs || 0
-      cmap = source.font.table("cmap")
-      mappings = cmap&.unicode_mappings || {}
-
-      gid_cps = Hash.new { |h, k| h[k] = [] }
-      mappings.each { |cp, gid| gid_cps[gid] << cp }
-
-      num_glyphs.times do |gid|
-        name = gid.zero? ? ".notdef" : "gid#{gid}"
-        glyph = Ufo::Glyph.new(name: name)
-        glyph.width = 0
-        gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
-        target.layers.default_layer.add(glyph)
-      end
+    def cbdt_propagator
+      @cbdt_propagator ||= CbdtPropagator.new(@sources.values)
     end
   end
 end

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.21
+  version: 0.4.22
 platform: ruby
 authors:
 - Ribose Inc.
@@ -436,9 +436,11 @@ files:
 - lib/fontisan/sfnt_font.rb
 - lib/fontisan/sfnt_table.rb
 - lib/fontisan/stitcher.rb
+- lib/fontisan/stitcher/cbdt_propagator.rb
 - lib/fontisan/stitcher/collection_result.rb
 - lib/fontisan/stitcher/deduplicator.rb
 - lib/fontisan/stitcher/format_metadata.rb
+- lib/fontisan/stitcher/glyph_copier.rb
 - lib/fontisan/stitcher/glyph_limit.rb
 - lib/fontisan/stitcher/glyph_signature.rb
 - lib/fontisan/stitcher/partition_strategy.rb