fontisan 0.4.9 → 0.4.11

data/lib/fontisan/svg/glyph_generator.rb

@@ -20,7 +20,7 @@ module Fontisan
     #
     # @example Generate SVG glyph element
     #   generator = GlyphGenerator.new(calculator)
-    #   xml = generator.generate_glyph_xml(outline, unicode: "A", advance_width: 600)
+    #   xml = generator.generate_glyph_xml(outline, codepoints: [0x41], advance_width: 600)
     class GlyphGenerator
       # @return [ViewBoxCalculator] Coordinate calculator
       attr_reader :calculator
@@ -38,23 +38,30 @@ module Fontisan
       # Generate SVG glyph element
       #
       # @param outline [Models::GlyphOutline] Glyph outline
-      # @param unicode [String, nil] Unicode character
-      # @param glyph_name [String, nil] Glyph name
+      # @param codepoints [Array<Integer>] Unicode codepoints that cmap
+      #   maps to this glyph. Empty for unmapped glyphs (.notdef, raw
+      #   ligatures, etc.). Each codepoint is rendered per SVG Fonts
+      #   spec: printable ASCII as the character (XML-escaped), others
+      #   as &#xHEX; entities. Multiple codepoints are concatenated —
+      #   rare but valid (e.g. a glyph mapped from both space and
+      #   non-breaking space).
+      # @param glyph_name [String, nil] Glyph name from the post table
       # @param advance_width [Integer] Horizontal advance width
       # @param indent [String] Indentation string
       # @return [String] XML glyph element
-      def generate_glyph_xml(outline, unicode: nil, glyph_name: nil,
+      def generate_glyph_xml(outline, codepoints: [], glyph_name: nil,
 advance_width: 0, indent: "      ")
-        # Build attribute parts
         attr_parts = []
 
-        attr_parts << "unicode=\"#{escape_xml(unicode)}\"" if unicode
-        attr_parts << "glyph-name=\"#{escape_xml(glyph_name)}\"" if glyph_name
-        attr_parts << "horiz-adv-x=\"#{advance_width}\"" if advance_width&.positive?
+        unless codepoints.empty?
+          attr_parts << %(unicode="#{format_codepoints(codepoints)}")
+        end
+        attr_parts << %(glyph-name="#{escape_xml(glyph_name)}") if glyph_name
+        attr_parts << %(horiz-adv-x="#{advance_width}") if advance_width&.positive?
 
         # Generate SVG path with Y-axis transformation
         path_data = generate_svg_path(outline)
-        attr_parts << "d=\"#{path_data}\"" if path_data && !path_data.empty?
+        attr_parts << %(d="#{path_data}") if path_data && !path_data.empty?
 
         "#{indent}<glyph #{attr_parts.join(' ')}/>"
       end
@@ -88,6 +95,34 @@ advance_width: 0, indent: "      ")
 
       private
 
+      # Format an array of codepoints as the SVG `unicode=` attribute
+      # value. Returns the FINAL string — already escaped / entity-fied.
+      # The caller must not re-escape it (would double-escape the
+      # entities this method emits).
+      #
+      # Per SVG Fonts spec, each codepoint renders as either:
+      #   - printable ASCII (0x20..0x7E): the character itself, with
+      #     XML-special chars (&, <, >, ", ') escaped
+      #   - any other codepoint: a numeric entity &#xHEX;
+      #
+      # Multiple codepoints are concatenated in codepoint order. The
+      # SVG spec accepts this for ligature-style mappings.
+      def format_codepoints(codepoints)
+        codepoints.map { |cp| format_codepoint(cp) }.join
+      end
+
+      def format_codepoint(cp)
+        if printable_ascii?(cp)
+          escape_xml(cp.chr(Encoding::UTF_8))
+        else
+          "&#x#{cp.to_s(16).upcase};"
+        end
+      end
+
+      def printable_ascii?(cp)
+        (0x20..0x7E).cover?(cp)
+      end
+
       # Build SVG path for a contour with Y-axis transformation
       #
       # @param contour [Array<Hash>] Array of point hashes

data/lib/fontisan/tasks/fixture_downloader.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "net/http"
+require "fileutils"
+
+module Fontisan
+  # Tasks supporting the developer workflow: fixture downloads, etc.
+  # Lives under its own namespace so Rakefiles and other tooling can
+  # load just the task plumbing without pulling in the full fontisan
+  # stack (BinData tables, UFO, etc.).
+  module Tasks
+    # Downloads a single fixture file with retry on transient network
+    # failures. Used by `rake fixtures:download` so a single CDN blip
+    # (5xx, connection reset, OpenTimeout) doesn't sink a fresh
+    # checkout. Permanent failures (404, malformed URL) surface
+    # immediately.
+    #
+    # The downloader is a focused class, not a procedural Rakefile
+    # patch, so the retry logic is unit-testable in isolation.
+    #
+    # @example
+    #   Fontisan::Tasks::FixtureDownloader.new(
+    #     url: "https://github.com/.../font.ttf",
+    #     destination: "spec/fixtures/font.ttf",
+    #   ).call
+    class FixtureDownloader
+      RETRIABLE_ERRORS = [
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        Errno::ECONNRESET,
+        Errno::ECONNREFUSED,
+        Errno::EHOSTUNREACH,
+        Errno::ETIMEDOUT,
+        EOFError,
+        IOError,
+      ].freeze
+
+      # 5xx HTTP responses are transient server errors worth retrying.
+      # 4xx are permanent (404, 403) and must fail fast.
+      RETRIABLE_HTTP_STATUSES = (500..599)
+
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_BASE_BACKOFF = 0.5 # seconds; doubles per attempt
+
+      # Error raised after exhausting all retries. Carries the last
+      # underlying exception so callers can log the root cause.
+      class Error < StandardError
+        attr_reader :last_error
+
+        def initialize(url:, attempts:, last_error:)
+          @last_error = last_error
+          super("Failed to download #{url} after #{attempts} attempts: " \
+                "#{last_error.class}: #{last_error.message}")
+        end
+      end
+
+      attr_reader :url, :destination, :max_retries, :base_backoff, :sleep_method
+
+      # @param url [String] source URL.
+      # @param destination [String] path to write bytes to. Parent dir
+      #   is auto-created.
+      # @param max_retries [Integer] total attempts including the
+      #   first. 3 means: try, retry, retry.
+      # @param base_backoff [Float] seconds to sleep before the first
+      #   retry. Doubles per attempt.
+      # @param sleep_method [#call] injectable sleep (for tests).
+      #   Defaults to Kernel.sleep.
+      def initialize(url:, destination:, max_retries: DEFAULT_MAX_RETRIES,
+                     base_backoff: DEFAULT_BASE_BACKOFF, sleep_method: method(:sleep))
+        @url = url
+        @destination = destination
+        @max_retries = max_retries
+        @base_backoff = base_backoff
+        @sleep_method = sleep_method
+      end
+
+      # Performs the download. Returns the destination path on
+      # success. Raises {Error} after exhausting retries.
+      #
+      # @return [String] destination path
+      # @raise [Error]
+      def call
+        attempts = 0
+        nil
+
+        begin
+          attempts += 1
+          fetch_to_destination
+          destination
+        rescue StandardError => e
+          e
+          raise if permanent_failure?(e)
+          raise Error.new(url: url, attempts: attempts, last_error: e) if attempts >= max_retries
+
+          backoff = base_backoff * (2**(attempts - 1))
+          sleep_method.call(backoff)
+          retry
+        end
+      end
+
+      private
+
+      def fetch_to_destination
+        FileUtils.mkdir_p(File.dirname(destination))
+
+        # IO.copy_stream avoids loading the whole response into memory
+        # and is more Windows-compatible than remote.read + File.binwrite.
+        # URLs come from FixtureFonts config (version-controlled), not
+        # user input — same trust model as the previous inline URI.open
+        # call in the Rakefile.
+        #
+        # Parsing with URI.parse first satisfies CodeQL's "open with
+        # non-constant value" check: any string that isn't a valid URI
+        # raises URI::InvalidURIError before OpenURI can dispatch on
+        # it. The parsed URI's .open is OpenURI's standard entry.
+        # rubocop:disable Security/Open
+        URI.parse(url).open(open_uri_options) do |remote|
+          File.open(destination, "wb") do |file|
+            IO.copy_stream(remote, file)
+          end
+        end
+        # rubocop:enable Security/Open
+      end
+
+      # `open-uri` follows redirects by default and surfaces HTTP
+      # errors as `OpenURI::HTTPError` whose `io.status` is the `[code,
+      # message]` array. We re-raise non-retriable 4xx as
+      # `permanent-failure`-tagged exceptions so the retry loop exits.
+      def open_uri_options
+        {
+          "User-Agent" => "fontisan-fixtures/1.0",
+          redirect: true,
+          open_timeout: 30,
+          read_timeout: 120,
+        }
+      end
+
+      def permanent_failure?(error)
+        case error
+        when OpenURI::HTTPError
+          status = parse_http_status(error)
+          status && !RETRIABLE_HTTP_STATUSES.cover?(status)
+        else
+          RETRIABLE_ERRORS.none? { |klass| error.is_a?(klass) }
+        end
+      end
+
+      def parse_http_status(error)
+        io = error.io
+        return nil unless io
+
+        status = io.status
+        return nil unless status
+
+        status.first.to_i
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/fontisan/tasks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Tasks supporting the developer workflow: fixture downloads, etc.
+  # Lives under its own namespace so Rakefiles and other tooling can
+  # load just the task plumbing without pulling in the full fontisan
+  # stack (BinData tables, UFO, etc.).
+  module Tasks
+    autoload :FixtureDownloader, "fontisan/tasks/fixture_downloader"
+  end
+end

data/lib/fontisan/unicode/plane.rb

@@ -15,18 +15,6 @@ module Fontisan
       TIP = 3
       SSP = 14
 
-      # The handful of mega-blocks large enough to overflow a single
-      # plane's 65,535-glyph cap when partitioning by plane. Range +
-      # label only — full Unicode Blocks.txt data lives in +Block+
-      # (follow-up).
-      LARGE_CJK_BLOCKS = {
-        "CJK_Ext_B" => 0x2A700..0x2B73F,
-        "CJK_Ext_C" => 0x2B740..0x2B81F,
-        "CJK_Ext_D" => 0x2B820..0x2CEAF,
-        "CJK_Ext_E" => 0x2CEB0..0x2EBEF,
-        "CJK_Ext_F" => 0x2EBF0..0x2EE5F,
-      }.freeze
-
       # @param codepoint [Integer]
       # @return [Integer] plane number (0..16)
       def self.of(codepoint)

data/lib/fontisan/version.rb

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

data/lib/fontisan.rb

@@ -32,6 +32,7 @@ require "logger"
 require "bindata"
 require "zlib"
 require "stringio"
+require "tmpdir"
 require "lutaml/model"
 
 # Configure lutaml-model to use Nokogiri adapter for XML serialization
@@ -117,6 +118,7 @@ module Fontisan
   autoload :SfntTable, "fontisan/sfnt_table"
   autoload :Stitcher, "fontisan/stitcher"
   autoload :StitcherCli, "fontisan/stitcher_cli"
+  autoload :Tasks, "fontisan/tasks"
   autoload :TrueTypeCollection, "fontisan/true_type_collection"
   autoload :TrueTypeFont, "fontisan/true_type_font"
   autoload :TrueTypeFontExtensions, "fontisan/true_type_font_extensions"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.4.11
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-03 00:00:00.000000000 Z
+date: 2026-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -434,12 +434,15 @@ files:
 - lib/fontisan/stitcher.rb
 - lib/fontisan/stitcher/collection_result.rb
 - lib/fontisan/stitcher/deduplicator.rb
+- lib/fontisan/stitcher/format_metadata.rb
 - lib/fontisan/stitcher/glyph_limit.rb
 - lib/fontisan/stitcher/glyph_signature.rb
 - lib/fontisan/stitcher/partition_strategy.rb
 - lib/fontisan/stitcher/partition_strategy/base.rb
 - lib/fontisan/stitcher/partition_strategy/blueprint.rb
+- lib/fontisan/stitcher/partition_strategy/by_block.rb
 - lib/fontisan/stitcher/partition_strategy/by_plane.rb
+- lib/fontisan/stitcher/partition_strategy/by_script.rb
 - lib/fontisan/stitcher/partition_strategy/partition.rb
 - lib/fontisan/stitcher/selector.rb
 - lib/fontisan/stitcher/selector/codepoints.rb
@@ -546,6 +549,8 @@ files:
 - lib/fontisan/tables/svg.rb
 - lib/fontisan/tables/variation_common.rb
 - lib/fontisan/tables/vvar.rb
+- lib/fontisan/tasks.rb
+- lib/fontisan/tasks/fixture_downloader.rb
 - lib/fontisan/true_type_collection.rb
 - lib/fontisan/true_type_font.rb
 - lib/fontisan/true_type_font_extensions.rb