fontisan 0.4.9 → 0.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b49343b74d1876d57ec13992fc49fdc2879a44d1f0fe3c6529bd3a2f8f7a75
-  data.tar.gz: cc69156566e86294177d9046f39ebde8334f87807da38a7a5dd83ddd2eea8247
+  metadata.gz: 1ed3f50509fb7f223b2cdcfdf7e59345e83b5ca2d11b2a0806574651687c4582
+  data.tar.gz: ccb6cabe8c99dfcc060acc7f46d26efd9961b5384365ab404552dad539dc4555
 SHA512:
-  metadata.gz: 2822ae02861c4183bbd42ded8005fa17d28d59175155767413f94b4400faaf28fb61dad38736f3fcd11235746e1b254151c8e8918480b5ccb146882742c3ec99
-  data.tar.gz: eefb0dbf8e3360e7b8aeb89dfcfbf62425c255075ee1a3d2c030cd2551f90f08d980f7ea7b8c56c382b0a1cb69933654a57fc4e57d069ebe6809ace84e7d0b42
+  metadata.gz: b977d4f9ac972020514daca43a14917784c713258f73223597c8a48dd2b32fcf3ccb9adbe2bd343db7ac43e63eaba8943a883580ec3c7bb7dec23f6a0f1e1fe9
+  data.tar.gz: 5c17de9dc3c60f44e472e94c19a1ca33435805ed81f261cc357dfcfd6d197f3109531ae8ad4b3a842e52f4f04de19501c0e860793212b87e874b63f01d99d8f3

data/Rakefile

@@ -12,24 +12,25 @@ RuboCop::RakeTask.new
 namespace :fixtures do
   # Load centralized fixture configuration
   require_relative "spec/support/fixture_fonts"
+  require "fontisan/tasks"
 
   # Helper method to download a single file
   def download_single_file(name, url, target_path)
-    require "open-uri"
-
     puts "[fixtures:download] Downloading #{name}..."
-    FileUtils.mkdir_p(File.dirname(target_path))
 
-    URI.open(url) do |remote|
-      File.binwrite(target_path, remote.read)
-    end
+    Fontisan::Tasks::FixtureDownloader.new(
+      url: url,
+      destination: target_path,
+    ).call
 
     puts "[fixtures:download] #{name} downloaded successfully"
+  rescue Fontisan::Tasks::FixtureDownloader::Error => e
+    warn "[fixtures:download] #{name} failed after retries: #{e.message}"
+    raise
   end
 
   # Helper method to download and extract a font archive
   def download_font(name, url, target_dir)
-    require "open-uri"
     require "zip"
 
     puts "[fixtures:download] Downloading #{name}..."
@@ -39,45 +40,58 @@ namespace :fixtures do
     temp_path = File.join(Dir.tmpdir,
                           "fontisan_#{name}_#{Process.pid}_#{rand(10000)}.zip")
 
-    # Download using IO.copy_stream for better Windows compatibility
-    URI.open(url, "rb") do |remote|
-      File.open(temp_path, "wb") do |file|
-        IO.copy_stream(remote, file)
-      end
-    end
-
-    puts "[fixtures:download] Extracting #{name}..."
-
-    # Open zip file and ensure it's fully closed before we're done
-    zip_file = Zip::File.open(temp_path)
     begin
-      zip_file.each do |entry|
-        # Skip macOS metadata files and directories
-        next if entry.name.start_with?("__MACOSX/") || entry.name.include?("/._")
-        next if entry.directory?
-
-        # Ensure entry.name is relative by stripping leading slashes
-        relative_name = entry.name.sub(%r{^/+}, "")
-
-        dest_path = File.join(target_dir, relative_name)
-        FileUtils.mkdir_p(File.dirname(dest_path))
-
-        # Skip if file already exists
-        next if File.exist?(dest_path)
-
-        # Write the file content directly using binary mode
-        File.open(dest_path, "wb") do |file|
-          IO.copy_stream(entry.get_input_stream, file)
+      Fontisan::Tasks::FixtureDownloader.new(
+        url: url,
+        destination: temp_path,
+      ).call
+
+      puts "[fixtures:download] Extracting #{name}..."
+
+      # Open zip file and ensure it's fully closed before we're done
+      zip_file = Zip::File.open(temp_path)
+      begin
+        zip_file.each do |entry|
+          # Skip macOS metadata files and directories
+          next if entry.name.start_with?("__MACOSX/") || entry.name.include?("/._")
+          next if entry.directory?
+
+          # Ensure entry.name is relative by stripping leading slashes
+          relative_name = entry.name.sub(%r{^/+}, "")
+
+          dest_path = File.join(target_dir, relative_name)
+          FileUtils.mkdir_p(File.dirname(dest_path))
+
+          # Skip if file already exists
+          next if File.exist?(dest_path)
+
+          # Write the file content directly using binary mode
+          File.open(dest_path, "wb") do |file|
+            IO.copy_stream(entry.get_input_stream, file)
+          end
         end
+      ensure
+        # Explicitly close the zip file to release file handle on Windows
+        zip_file&.close
       end
     ensure
-      # Explicitly close the zip file to release file handle on Windows
-      zip_file&.close
+      # Clean up the temp zip explicitly so the temp dir doesn't fill
+      # up on repeated runs. On Windows the just-closed zip file
+      # handle can briefly hold a lock that surfaces as
+      # Errno::EACCES; swallow that one error so the rake task can
+      # complete (OS will sweep the temp file later).
+      begin
+        File.delete(temp_path) if File.exist?(temp_path)
+      rescue Errno::EACCES
+        warn "[fixtures:download] could not delete temp zip #{temp_path}; " \
+             "OS will clean it up"
+      end
     end
 
-    # Temp file left in Dir.tmpdir - OS will clean it up automatically
-
     puts "[fixtures:download] #{name} downloaded successfully"
+  rescue Fontisan::Tasks::FixtureDownloader::Error => e
+    warn "[fixtures:download] #{name} failed after retries: #{e.message}"
+    raise
   rescue LoadError => e
     warn "[fixtures:download] Error: Required gem not installed. Please run: gem install rubyzip"
     raise e

data/docs/STITCHER_GUIDE.adoc

@@ -165,8 +165,18 @@ must either raise the cap, drop codepoints, or switch to a format
 with a higher glyph limit.
 
 The Unicode plane metadata used by ByPlane lives in
-`Fontisan::Unicode::Plane` (`Plane.of(cp)`, `Plane.label(n)`,
-`Plane::LARGE_CJK_BLOCKS`).
+`Fontisan::Unicode::Plane` (`Plane.of(cp)`, `Plane.label(n)`).
+
+The sub-plane block boundaries used for sub-splitting live on ByPlane
+itself:
+
+* `ByPlane::ATOMIC_BLOCKS` — five SIP CJK extension blocks that cannot
+  be sub-split; raise if one alone exceeds `cap`.
+* `ByPlane::CARVE_OUT_BLOCKS` — BMP-resident blocks (CJK Unified
+  Ideographs, Hangul Syllables) that get their own partition bucket
+  when BMP overflows `cap`; chunkable, never raised.
+* `ByPlane::RECOGNIZED_BLOCKS` — union of the two; the lookup table
+  the bucketing pass walks.
 
 === Partition / Blueprint
 

data/lib/fontisan/converters/svg_generator.rb

@@ -145,7 +145,7 @@ palette_index: 0)
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font
       # @param options [Hash] Extraction options
-      # @return [Hash] Glyph data map (glyph_id => {outline, unicode, name, advance})
+      # @return [Hash] Glyph data map (glyph_id => {outline, codepoints, name, advance})
       def extract_glyph_data(font, options = {})
         extractor = OutlineExtractor.new(font)
         cmap = font.table("cmap")
@@ -157,33 +157,20 @@ palette_index: 0)
         num_glyphs = maxp&.num_glyphs || 0
         max_glyphs = options[:max_glyphs] || num_glyphs
 
-        # Get unicode mappings
-        unicode_map = build_unicode_map(cmap)
+        gid_to_codepoints = build_glyph_to_codepoints(cmap)
+        glyph_names = post&.glyph_names || []
 
-        # Extract specified or all glyphs
         glyph_ids = options[:glyph_ids] || (0...num_glyphs).to_a
         glyph_ids = glyph_ids.take(max_glyphs) if max_glyphs
 
         glyph_ids.each do |glyph_id|
           next if glyph_id >= num_glyphs
 
-          # Extract outline
-          outline = extractor.extract(glyph_id)
-
-          # Get advance width
-          advance = extract_advance_width(hmtx, glyph_id)
-
-          # Get unicode character
-          unicode = unicode_map[glyph_id]
-
-          # Get glyph name
-          glyph_name = extract_glyph_name(post, glyph_id)
-
           glyph_data[glyph_id] = {
-            outline: outline,
-            unicode: unicode,
-            name: glyph_name,
-            advance: advance,
+            outline: extractor.extract(glyph_id),
+            codepoints: gid_to_codepoints[glyph_id] || [],
+            name: glyph_name_for(glyph_names, glyph_id),
+            advance: extract_advance_width(hmtx, glyph_id),
           }
         rescue StandardError => e
           warn "Failed to extract glyph #{glyph_id}: #{e.message}"
@@ -193,61 +180,38 @@ palette_index: 0)
         glyph_data
       end
 
-      # Build unicode to glyph ID map from cmap table
+      # Build reverse cmap: glyph_id => [codepoint, ...].
       #
-      # @param cmap [Tables::Cmap, nil] Cmap table
-      # @return [Hash<Integer, String>] Map of glyph_id to unicode character
-      def build_unicode_map(cmap)
+      # A glyph can be referenced by multiple codepoints (e.g. space
+      # and non-breaking space might share a glyph). Uses
+      # +cmap.unicode_mappings+ directly — that is the canonical
+      # {codepoint => gid} hash.
+      #
+      # @param cmap [Tables::Cmap, nil]
+      # @return [Hash<Integer, Array<Integer>>]
+      def build_glyph_to_codepoints(cmap)
         return {} unless cmap
 
-        unicode_map = {}
-
-        # Get best cmap subtable (prefer Unicode BMP or full)
-        subtable = find_best_cmap_subtable(cmap)
-        return {} unless subtable
-
-        # Build reverse map: glyph_id => unicode
-        subtable.each do |code_point, glyph_id|
-          # Store first unicode for each glyph
-          next if unicode_map[glyph_id]
-
-          unicode_map[glyph_id] = [code_point].pack("U")
-        rescue StandardError
-          # Skip invalid code points
-          next
+        cmap.unicode_mappings.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, gid), h|
+          h[gid] << cp
         end
-
-        unicode_map
       rescue StandardError => e
-        warn "Failed to build unicode map: #{e.message}"
+        warn "Failed to build glyph to codepoints map: #{e.message}"
         {}
       end
 
-      # Find best cmap subtable for unicode mapping
+      # Look up glyph name from the post table's per-gid name array.
       #
-      # @param cmap [Tables::Cmap] Cmap table
-      # @return [Hash, nil] Subtable or nil
-      def find_best_cmap_subtable(cmap)
-        # Try Unicode BMP (platform 3, encoding 1) - Windows Unicode BMP
-        subtable = cmap.subtable(3, 1)
-        return subtable if subtable
-
-        # Try Unicode full (platform 3, encoding 10) - Windows Unicode full
-        subtable = cmap.subtable(3, 10)
-        return subtable if subtable
-
-        # Try Unicode (platform 0, encoding 3) - Unicode 2.0+ BMP
-        subtable = cmap.subtable(0, 3)
-        return subtable if subtable
-
-        # Try Unicode (platform 0, encoding 4) - Unicode 2.0+ full
-        subtable = cmap.subtable(0, 4)
-        return subtable if subtable
-
-        # Fallback to any available subtable
-        cmap.subtables.first
-      rescue StandardError
-        nil
+      # Falls back to +"gidN"+ when the post table has no name for the
+      # given gid (post version 3.0 fonts omit per-glyph names, and
+      # version 2.0 may have gaps). Always returns a non-nil string so
+      # the SVG <glyph> element carries a useful glyph-name attribute.
+      #
+      # @param glyph_names [Array<String>] post.glyph_names
+      # @param glyph_id [Integer]
+      # @return [String]
+      def glyph_name_for(glyph_names, glyph_id)
+        glyph_names[glyph_id] || "gid#{glyph_id}"
       end
 
       # Extract advance width for glyph
@@ -265,22 +229,6 @@ palette_index: 0)
       rescue StandardError
         0
       end
-
-      # Extract glyph name from post table
-      #
-      # @param post [Tables::Post, nil] Post table
-      # @param glyph_id [Integer] Glyph ID
-      # @return [String, nil] Glyph name or nil
-      def extract_glyph_name(post, glyph_id)
-        return nil unless post
-
-        name = post.glyph_name_for(glyph_id)
-        return nil if name.nil? || name.empty?
-
-        name
-      rescue StandardError
-        nil
-      end
     end
   end
 end

data/lib/fontisan/sfnt_font.rb

@@ -59,8 +59,16 @@ module Fontisan
       header.num_tables
     }
 
-    # Table data is stored separately since it's at variable offsets
-    attr_accessor :table_data
+    # Table data is stored separately since it's at variable offsets.
+    # The setter normalizes all keys to UTF-8 so Hash lookups don't
+    # silently miss due to encoding mismatch — BinData-derived tag
+    # strings are ASCII-8BIT, literals callers pass are usually UTF-8,
+    # and String#eql? is encoding-sensitive.
+    attr_reader :table_data
+
+    def table_data=(hash)
+      @table_data = hash.transform_keys { |tag| normalize_tag(tag) }
+    end
 
     # Parsed table instances cache
     attr_accessor :parsed_tables
@@ -470,6 +478,8 @@ module Fontisan
     # @return [Tables::*, nil] Parsed table object or nil if not found
     # @raise [ArgumentError] if table is not available in current loading mode
     def table(tag)
+      tag = normalize_tag(tag)
+
       # Check mode restrictions
       unless table_available?(tag)
         if has_table?(tag)

data/lib/fontisan/stitcher/format_metadata.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Immutable metadata about a stitcher output format. Single source
+    # of truth for "given a format symbol, what compiler / collection
+    # format / file extension does it use?". Adding a new format =
+    # adding a +when+ branch in {resolve}; no other site in Stitcher
+    # needs to know the mapping.
+    class FormatMetadata
+      attr_reader :name, :compiler_class, :collection_format, :extension
+
+      # @param name [Symbol] canonical format name (:ttf, :otf, :otf2)
+      # @param compiler_class [Class] the +Ufo::Compile::*Compiler+ that
+      #   compiles a +Ufo::Font+ target into the format's binary
+      # @param collection_format [Symbol] :ttc or :otc — the
+      #   +Collection::Builder+ format used when packing multiple
+      #   subfonts of this format into a collection
+      # @param extension [String] file extension including the dot
+      def initialize(name:, compiler_class:, collection_format:, extension:)
+        @name = name
+        @compiler_class = compiler_class
+        @collection_format = collection_format
+        @extension = extension
+      end
+
+      # Resolve a format name (Symbol or String) to its metadata.
+      # Constants are referenced inside +when+ branches so autoload
+      # fires only for the requested format, not all of them.
+      #
+      # @param name [Symbol, String]
+      # @raise [ArgumentError] if +name+ is not a known stitcher format
+      # @return [FormatMetadata]
+      def self.resolve(name)
+        case name.to_sym
+        when :ttf
+          new(name: :ttf, compiler_class: Ufo::Compile::TtfCompiler,
+              collection_format: :ttc, extension: ".ttf")
+        when :otf
+          new(name: :otf, compiler_class: Ufo::Compile::OtfCompiler,
+              collection_format: :otc, extension: ".otf")
+        when :otf2
+          new(name: :otf2, compiler_class: Ufo::Compile::Otf2Compiler,
+              collection_format: :otc, extension: ".otf")
+        else
+          raise ArgumentError, "unknown format: #{name.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/partition_strategy/base.rb

@@ -6,9 +6,38 @@ module Fontisan
       # Abstract base. Concrete partitioners (ByPlane, ByBlock, …)
       # implement {#call} and return a {Blueprint}.
       class Base
-        # Default cap: 65,535 − .notdef − safety margin. Matches the
-        # Stitcher's own +GlyphLimit+ cap for TTF.
-        DEFAULT_CAP = 65_484
+        # Glyph-cap headroom below the format's hard cap
+        # (GlyphLimit::TTF_GLYPH_CAP / OTF_GLYPH_CAP = 65,535). The
+        # partitioner must keep each partition's *codepoint* count low
+        # enough that compile-time *glyph* expansion still fits under
+        # the hard cap.
+        #
+        # Reserved slots:
+        #   - .notdef (1 slot, mandated by OpenType — every font has it
+        #     at GID 0 even when no codepoint binds to it)
+        #   - composite expansion: compiling adds composites (ligatures,
+        #     decomposable glyphs, variant attachments) on top of the
+        #     source codepoint count. Empirically ~5% of typical BMP
+        #     size for CJK-heavy fonts (≈2,500 composites on a 50k-cp
+        #     BMP font). 5,534 slots covers that with margin.
+        NOTDEF_RESERVED = 1
+        COMPOSITE_HEADROOM = 5_534
+
+        # Derive the partition cap from a format's hard glyph limit.
+        # Mirrors GlyphLimit so a future bump (e.g. CFF2 card24 INDEX
+        # counts) cascades automatically — no second magic number to
+        # keep in sync.
+        #
+        # @param format [Symbol] :ttf, :otf, or :otf2
+        # @return [Integer]
+        def self.cap_for(format)
+          GlyphLimit.for_format(format) - NOTDEF_RESERVED - COMPOSITE_HEADROOM
+        end
+
+        # Default cap for the most common format (TTF, where the glyph
+        # cap equals 65,535). Use {.cap_for} when partitioning for a
+        # different format.
+        DEFAULT_CAP = cap_for(:ttf)
 
         # @param cp_map [Hash{Integer=>Object}] codepoint → donor label
         # @param cap [Integer] max codepoints per partition