fontisan 0.4.46 → 0.4.48

data/lib/fontisan/scan.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Fontisan
+  # Builds the scan rows served by {Fontisan::Reference.scan}: one row per font
+  # face, carrying everything fontist's `FontFile`, `CollectionFile` and
+  # indexability check read from a font, so the same rows can be produced by
+  # any engine tier.
+  #
+  # The field set and the name-decoding rules are taken from fontist at
+  # 85e904c96fff60f60781ae0eb11a8c06e0c73816 (`lib/fontist/font_file.rb`,
+  # `collection_file.rb`). This class never raises for a bad font: the failure
+  # that fontist would raise or show is recorded in the row's `errors`.
+  #
+  # Rows are plain Hashes with Symbol keys (see docs/reference-facade.md for
+  # the schema). Every call builds its own state, so concurrent calls on
+  # different paths are safe.
+  class Scan
+    NAME_FIELDS = {
+      full_name: Tables::Name::FULL_NAME,
+      family_name: Tables::Name::FAMILY,
+      subfamily_name: Tables::Name::SUBFAMILY,
+      preferred_family: Tables::Name::PREFERRED_FAMILY,
+      preferred_subfamily: Tables::Name::PREFERRED_SUBFAMILY,
+      postscript_name: Tables::Name::POSTSCRIPT_NAME,
+    }.freeze
+
+    RIBBI = ["regular", "bold", "italic", "bold italic"].freeze
+
+    FONT_FILE_ERROR = "Fontist::Errors::FontFileError"
+    INDEXABILITY_ERROR = "Fontist::Errors::FontIndexabilityValidationError"
+    # CollectionFile raises this inside the method whose blanket rescue wraps
+    # every non-indexability failure, so it surfaces as "could not be loaded"
+    # with the original FontFileError as its cause.
+    NOT_A_COLLECTION = {
+      class: FONT_FILE_ERROR,
+      message: "Font collection could not be loaded: " \
+               "File is not a recognized font collection (TTC/OTC/dfont)",
+      cause: { class: FONT_FILE_ERROR,
+               message: "File is not a recognized font collection (TTC/OTC/dfont)" },
+    }.freeze
+
+    # @param paths [Array<String>] font file paths
+    # @return [Array<Hash>] rows in input order, faces in index order
+    def self.call(paths)
+      Array(paths).flat_map { |path| new(path).rows }
+    end
+
+    # @param path [String]
+    def initialize(path)
+      @path = path.to_s
+    end
+
+    # @return [Array<Hash>] one row per face; one row with
+    #   `collection_index: nil` when no face could be enumerated
+    def rows
+      facts = file_facts
+      return [failed_file_row(facts)] if facts[:fatal]
+
+      if facts[:is_collection]
+        collection_rows(facts)
+      else
+        [face_row(facts, nil, 1)]
+      end
+    end
+
+    private
+
+    # ---- file level -----------------------------------------------------
+
+    # What FontFile reads first: collection?, detect_format, sha256.
+    def file_facts
+      facts = { sha256: nil, format: nil, is_collection: false, fatal: nil }
+      facts[:sha256] = Digest::SHA256.file(@path).hexdigest
+      facts[:is_collection] = FontLoader.collection?(@path)
+      facts[:format] = detect_format
+      facts
+    rescue StandardError => e
+      facts[:fatal] = e
+      facts
+    end
+
+    def detect_format
+      format = FontLoader.detect_format(@path)
+      format&.to_s
+    rescue StandardError
+      nil
+    end
+
+    def failed_file_row(facts)
+      error = facts[:fatal]
+      row = base_row(facts, nil, 0)
+      row[:errors][:font_file] = font_file_error(error)
+      row[:errors][:collection_file] = load_error(error)
+      row
+    end
+
+    # ---- collections ----------------------------------------------------
+
+    def collection_rows(facts)
+      collection = begin
+        FontLoader.load_collection(@path)
+      rescue StandardError => e
+        e
+      end
+
+      if collection.is_a?(StandardError)
+        row = base_row(facts, nil, 0)
+        row[:errors][:font_file] = font_file_error(collection)
+        row[:errors][:collection_file] = load_error(collection)
+        return [row]
+      end
+
+      count = collection.num_fonts
+      return [empty_collection_row(facts)] if count.zero?
+
+      Array.new(count) { |index| face_row(facts, index, count) }
+    end
+
+    # A collection without faces has no row to hold what fontist raises for it
+    # (the first face cannot be loaded), so it gets one of its own.
+    def empty_collection_row(facts)
+      row = base_row(facts, nil, 0)
+      first = load_face(0, lazy: true)
+      row[:errors][:font_file] = font_file_error(first) if first.is_a?(StandardError)
+      row[:errors][:collection_file] = first_face_error
+      row
+    end
+
+    # ---- one face -------------------------------------------------------
+
+    def face_row(facts, index, num_faces)
+      row = base_row(facts, index, num_faces)
+      fontist_face = index.nil? || index.zero?
+
+      meta = load_face(index, lazy: true)
+      if meta.is_a?(StandardError)
+        row[:errors][:font_file] = font_file_error(meta) if fontist_face
+      else
+        begin
+          fill_from_face(row, meta, index)
+        rescue StandardError => e
+          row[:errors][:font_file] = font_file_error(e) if fontist_face
+        ensure
+          meta.close if meta.respond_to?(:close)
+        end
+      end
+
+      if index.nil?
+        row[:errors][:collection_file] = NOT_A_COLLECTION
+      else
+        fill_collection_errors(row, index)
+      end
+      row
+    end
+
+    # FontFile flow: validate -> names (with fallback) -> fvar -> instances.
+    def fill_from_face(row, font, index)
+      row[:validation] = validate(font)
+      row[:names] = names_with_fallback(font)
+      row[:has_fvar] = font.has_table?("fvar")
+      row[:variable_instances] = variable_instances(index) if row[:has_fvar] && row[:names][:family_name]
+    end
+
+    # CollectionFile flow: metadata, lazy: false, english names only; and the
+    # indexability check of the first face, which gates build_collection for
+    # the whole file (so every row of the file carries the same value).
+    def fill_collection_errors(row, index)
+      member = load_face(index, lazy: false)
+      if member.is_a?(StandardError)
+        row[:errors][:collection_member] = error_info(member)
+      else
+        begin
+          row[:english_names] = english_names(member)
+        rescue StandardError => e
+          row[:errors][:collection_member] = error_info(e)
+        ensure
+          member.close if member.respond_to?(:close)
+        end
+      end
+      row[:errors][:collection_file] = first_face_error
+    end
+
+    def first_face_error
+      return @first_face_error if defined?(@first_face_error)
+
+      @first_face_error = compute_first_face_error
+    end
+
+    def compute_first_face_error
+      first = load_face(0, lazy: true)
+      return load_error(first) if first.is_a?(StandardError)
+
+      begin
+        report = validate(first)
+        report[:valid] ? nil : indexability_error(report)
+      rescue StandardError => e
+        load_error(e)
+      ensure
+        first.close if first.respond_to?(:close)
+      end
+    end
+
+    def indexability_error(report)
+      { class: INDEXABILITY_ERROR,
+        message: "Font collection failed indexability validation " \
+                 "(first font): #{report[:error_summary]}",
+        cause: nil }
+    end
+
+    # CollectionFile wraps every non-indexability failure this way.
+    def load_error(error)
+      wrapped("Font collection could not be loaded: #{error.message}",
+              FONT_FILE_ERROR, error)
+    end
+
+    def load_face(index, lazy:)
+      args = { mode: :metadata, lazy: lazy }
+      args[:font_index] = index unless index.nil?
+      FontLoader.load(@path, **args)
+    rescue StandardError => e
+      e
+    end
+
+    # ---- names ----------------------------------------------------------
+
+    def names_with_fallback(font)
+      name_table = font.table(Constants::NAME_TAG)
+      return {} unless name_table
+
+      NAME_FIELDS.transform_values do |id|
+        name_table.english_name(id) || any_name(name_table, id)
+      end
+    end
+
+    def english_names(font)
+      name_table = font.table(Constants::NAME_TAG)
+      return {} unless name_table
+
+      NAME_FIELDS.transform_values { |id| name_table.english_name(id) }
+    end
+
+    # fontist's extract_any_name / decode_name_record_manually.
+    def any_name(name_table, name_id)
+      records = name_table.name_records.select { |r| r.name_id == name_id }
+      records.each do |record|
+        decoded = decode_record(name_table, record)
+        return decoded unless decoded.nil? || decoded.empty?
+      end
+      nil
+    end
+
+    def decode_record(name_table, record)
+      storage = name_table.string_storage.to_s.b
+      offset = record.string_offset
+      length = record.string_length
+      return nil if offset + length > storage.bytesize || length.zero?
+
+      data = storage.byteslice(offset, length)
+      case record.platform_id
+      when 0, 3
+        data.dup.force_encoding("UTF-16BE")
+          .encode("UTF-8", invalid: :replace, undef: :replace)
+      when 1
+        data.dup.force_encoding("ASCII-8BIT")
+          .encode("UTF-8", invalid: :replace, undef: :replace)
+      else
+        data.dup.force_encoding("UTF-8")
+      end
+    end
+
+    # ---- variable instances (fontist FontFile.extract_variable_instances) -
+
+    # fvar data is gated out of metadata mode, so this is the second load.
+    def variable_instances(index)
+      font = if index.nil?
+               FontLoader.load(@path, mode: :full, lazy: true)
+             else
+               FontLoader.load(@path, font_index: index, mode: :full, lazy: true)
+             end
+      instances_of(font)
+    rescue StandardError
+      []
+    ensure
+      font.close if font.respond_to?(:close)
+    end
+
+    def instances_of(font)
+      return [] unless font.has_table?("fvar")
+
+      fvar = font.table("fvar")
+      name_table = font.table(Constants::NAME_TAG)
+      return [] unless name_table
+
+      base = name_table.english_name(Tables::Name::PREFERRED_FAMILY) ||
+        any_name(name_table, Tables::Name::PREFERRED_FAMILY) ||
+        name_table.english_name(Tables::Name::FAMILY)
+      return [] unless base
+
+      fvar.instances.filter_map do |instance|
+        style = name_table.english_name(instance[:name_id]) ||
+          any_name(name_table, instance[:name_id])
+        next unless style
+
+        instance_entry(base, style)
+      end
+    rescue StandardError
+      []
+    end
+
+    def instance_entry(base, style)
+      if RIBBI.include?(style.downcase)
+        { family: base, style: style, full_name: "#{base} #{style}" }
+      else
+        family = "#{base} #{style}"
+        { family: family, style: "Regular", full_name: family }
+      end
+    end
+
+    # ---- validation -----------------------------------------------------
+
+    # The raw indexability result, with fontist's joined message string.
+    def validate(font)
+      report = Validators::ProfileLoader.load(:indexability).validate(font)
+      errors = report.errors
+      {
+        profile: "indexability",
+        valid: report.valid? || false,
+        status: report.status,
+        issues: report.issues.map do |i|
+          { severity: i.severity, category: i.category, message: i.message,
+            location: i.location }
+        end,
+        error_summary: errors.map { |e| "#{e.category}: #{e.message}" }.join("; "),
+      }
+    end
+
+    # ---- rows and errors ------------------------------------------------
+
+    def base_row(facts, index, num_faces)
+      {
+        path: @path,
+        collection_index: index,
+        sha256: facts[:sha256],
+        format: facts[:format],
+        is_collection: facts[:is_collection],
+        num_faces: num_faces,
+        has_fvar: false,
+        names: nil,
+        english_names: nil,
+        variable_instances: [],
+        validation: nil,
+        errors: { font_file: nil, collection_file: nil, collection_member: nil },
+      }
+    end
+
+    # `FontFile.raise_font_file_error`: "Font file could not be parsed: <inspect>."
+    def font_file_error(error)
+      wrapped("Font file could not be parsed: #{error.inspect}.",
+              FONT_FILE_ERROR, error)
+    end
+
+    def wrapped(message, klass, cause)
+      { class: klass, message: message, cause: error_info(cause) }
+    end
+
+    def error_info(error)
+      { class: error.class.name, message: error.message }
+    end
+  end
+end

data/lib/fontisan/sfnt_directory.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Bounds check of a plain sfnt (TrueType or OpenType) table directory, run
+  # before a conversion reads it.
+  #
+  # fontisan-rs rejects a directory that runs past the end of the file, or a
+  # table that does, with "invalid sfnt table directory". Without this check
+  # the Ruby tier fails the same files with whatever BinData or the converters
+  # raise: "End of file reached" for a truncated directory, and an internal
+  # NoMethodError text for a bad table offset. This gives every tier one error
+  # for the same input (fontist/fontisan#159).
+  module SfntDirectory
+    # Raised for a malformed directory; the converter adds its own prefix.
+    class Malformed < Error; end
+
+    MESSAGE = "Transformation failed: invalid sfnt table directory"
+    HEADER_SIZE = 12
+    ENTRY_SIZE = 16
+
+    module_function
+
+    # @param data [String] the whole file, binary
+    # @raise [Malformed] when the directory or a table is out of range
+    # @return [void]
+    def check!(data)
+      size = data.bytesize
+      malformed! if size < HEADER_SIZE
+      num_tables = data.byteslice(4, 2).unpack1("n")
+      malformed! if HEADER_SIZE + (num_tables * ENTRY_SIZE) > size
+      num_tables.times do |index|
+        offset, length = data.byteslice(HEADER_SIZE + (index * ENTRY_SIZE) + 8, 8).unpack("NN")
+        malformed! if offset + length > size
+      end
+    end
+
+    def malformed!
+      raise Malformed, MESSAGE
+    end
+  end
+end

data/lib/fontisan/sfnt_font.rb

@@ -66,7 +66,15 @@ module Fontisan
     # 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
+    # Raw table bytes: the Hash of all tables, or one table's bytes when a
+    # tag is given (the WOFF classes already accept a tag; StaticFontBuilder
+    # calls it that way).
+    #
+    # @param tag [String, nil]
+    # @return [Hash{String=>String}, String, nil]
+    def table_data(tag = nil)
+      tag.nil? ? @table_data : @table_data&.[](tag)
+    end
 
     def table_data=(hash)
       @table_data = hash.transform_keys { |tag| normalize_tag(tag) }
@@ -271,7 +279,9 @@ module Fontisan
 
       # Get metadata tables sorted by offset for sequential access
       metadata_entries = tables.select { |entry| LoadingModes::METADATA_TABLES_SET.include?(entry.tag) }
-      metadata_entries.sort_by!(&:offset)
+      # Tables may share an offset (a zero-length table sits where the next one
+      # starts) and sort_by is not stable, so tie-break on the directory order.
+      metadata_entries = metadata_entries.each_with_index.sort_by { |entry, idx| [entry.offset, idx] }.map(&:first)
 
       return if metadata_entries.empty?
 
@@ -279,18 +289,18 @@ module Fontisan
       i = 0
       while i < metadata_entries.size
         batch_start = metadata_entries[i]
-        batch_end = batch_start
+        batch_end_pos = batch_start.offset + batch_start.table_length
         batch_entries = [batch_start]
 
         # Extend batch while next table is within page threshold
         j = i + 1
         while j < metadata_entries.size
           next_entry = metadata_entries[j]
-          gap = next_entry.offset - (batch_end.offset + batch_end.table_length)
+          gap = next_entry.offset - batch_end_pos
 
           # If gap is small (within page threshold), include in batch
           if gap <= page_threshold
-            batch_end = next_entry
+            batch_end_pos = [batch_end_pos, next_entry.offset + next_entry.table_length].max
             batch_entries << next_entry
             j += 1
           else
@@ -307,7 +317,7 @@ module Fontisan
         else
           # Multiple tables, read contiguous segment
           batch_offset = batch_start.offset
-          batch_length = (batch_end.offset + batch_end.table_length) - batch_start.offset
+          batch_length = batch_end_pos - batch_start.offset
 
           io.seek(batch_offset)
           batch_data = io.read(batch_length)

data/lib/fontisan/subset/builder.rb

@@ -91,6 +91,7 @@ module Fontisan
       #   subset_binary = builder.build
       #   File.binwrite('subset.ttf', subset_binary)
       def build
+        Fontisan::Engine.record_ruby(:subset)
         validate_input!
         calculate_closure
         build_mapping
@@ -133,7 +134,7 @@ module Fontisan
       #
       # @raise [Fontisan::MissingTableError] If required tables are missing
       def validate_required_tables!
-        required = %w[head maxp]
+        required = %w[head hhea maxp]
         required.each do |tag|
           table = font.table(tag)
           next if table

data/lib/fontisan/tables/cff/charstring.rb

@@ -107,6 +107,11 @@ module Fontisan
           [12, 37] => :flex1,
         }.freeze
 
+        # Total operators and operands one CharString (subroutines included)
+        # may execute. Real glyphs need hundreds; this only stops exponential
+        # subroutine fan-out. Matches the native tiers' `MAX_OPS` (1 << 20).
+        MAX_OPS = 1 << 20
+
         # Initialize and interpret a CharString
         #
         # @param data [String] Binary CharString data
@@ -128,6 +133,7 @@ module Fontisan
           @transient_array = []
           @subroutine_bias = calculate_bias(local_subrs)
           @global_subroutine_bias = calculate_bias(global_subrs)
+          @ops = 0
 
           parse!
         end
@@ -184,6 +190,7 @@ module Fontisan
           width_parsed = false
 
           until io.eof?
+            count_op
             byte = io.getbyte
 
             if byte <= 31 && byte != 28
@@ -207,6 +214,14 @@ module Fontisan
                 "Failed to parse CharString: #{e.message}"
         end
 
+        # Count one operator or operand against the budget.
+        def count_op
+          @ops += 1
+          return if @ops <= MAX_OPS
+
+          raise CorruptedTableError, "charstring operation budget exceeded"
+        end
+
         # Read an operator from the CharString
         #
         # @param io [StringIO] Input stream
@@ -836,6 +851,7 @@ module Fontisan
 
           # Process subroutine until return or end
           until @io.eof?
+            count_op
             byte = @io.getbyte
 
             if byte <= 31 && byte != 28

data/lib/fontisan/tables/cff.rb

@@ -370,14 +370,10 @@ module Fontisan
       #   puts charstring.bounding_box
       #   charstring.to_commands.each { |cmd| puts cmd.inspect }
       def charstring_for_glyph(glyph_index, font_index = 0)
-        charstrings = charstrings_index(font_index)
+        charstrings, priv_dict, local_subr_index = glyph_sources(font_index)
         return nil unless charstrings
-
-        priv_dict = private_dict(font_index)
         return nil unless priv_dict
 
-        local_subr_index = local_subrs(font_index)
-
         charstrings.charstring_at(
           glyph_index,
           priv_dict,
@@ -482,6 +478,20 @@ module Fontisan
       rescue StandardError => e
         raise CorruptedTableError, "Failed to parse Encoding: #{e.message}"
       end
+
+      private
+
+      # CharStrings INDEX, Private DICT and Local Subr INDEX of one font,
+      # parsed once. charstring_for_glyph is called per glyph, and re-parsing
+      # the whole INDEX each time made it quadratic in the glyph count.
+      def glyph_sources(font_index)
+        @glyph_sources ||= {}
+        @glyph_sources[font_index] ||= begin
+          charstrings = charstrings_index(font_index)
+          priv_dict = charstrings && private_dict(font_index)
+          [charstrings, priv_dict, priv_dict && local_subrs(font_index)]
+        end
+      end
     end
   end
 end

data/lib/fontisan/tables/cmap.rb

@@ -22,6 +22,9 @@ module Fontisan
       PLATFORM_MACINTOSH = 1
       PLATFORM_MICROSOFT = 3
 
+      # Last Unicode scalar; bounds format 12 group spans.
+      MAX_CODEPOINT = 0x10FFFF
+
       # Microsoft Encoding IDs
       ENC_MS_UNICODE_BMP = 1    # Unicode BMP (UCS-2)
       ENC_MS_UNICODE_UCS4 = 10  # Unicode full repertoire (UCS-4)
@@ -198,6 +201,10 @@ module Fontisan
           id_delta = id_deltas[i]
           id_range_offset = id_range_offsets[i]
 
+          # A segmentCount past the arrays inside the declared length leaves
+          # the later arrays short: skip the cut segment (was NoMethodError).
+          next if [start_code, end_code, id_delta, id_range_offset].any?(&:nil?)
+
           # Skip the final segment (0xFFFF)
           next if start_code == 0xFFFF
 
@@ -272,8 +279,11 @@ module Fontisan
       end
 
       # Map a range of characters to glyphs
+      # The end is clamped to the last Unicode scalar: a fuzzed group spanning
+      # the u32 range would otherwise loop for minutes (same bound as the Rust
+      # engine's cmap parser).
       def map_character_range(start_char, end_char, start_glyph, mappings)
-        (start_char..end_char).each do |code|
+        (start_char..[end_char, MAX_CODEPOINT].min).each do |code|
           glyph_index = start_glyph + (code - start_char)
           mappings[code] = glyph_index if glyph_index != 0
         end

data/lib/fontisan/tables/glyf.rb

@@ -241,13 +241,11 @@ module Fontisan
         glyph = glyph_for(glyph_id, loca, head)
         return true if glyph.nil? # Empty glyphs are OK
 
-        # Simple glyphs: contours should be >= 0
-        # Compound glyphs: numberOfContours = -1
+        # Simple glyphs: contours must be >= 0. Compound glyphs always have
+        # numberOfContours = -1; CompoundGlyph.parse rejects anything else.
         case glyph
-        when SimpleGlyph, CompoundGlyph
-          glyph.num_contours >= -1
-        else
-          true
+        when SimpleGlyph then glyph.num_contours >= 0
+        else true
         end
       rescue StandardError
         false

data/lib/fontisan/tables/gpos.rb

@@ -28,6 +28,13 @@ module Fontisan
         []
       end
 
+      # Every script with its feature tags, parsed once and work-budgeted
+      # (see {LayoutCommon::ScriptFeatures}).
+      # @return [Hash{String=>Array<String>}] script tag => feature tags
+      def script_features
+        LayoutCommon::ScriptFeatures.new(self).call
+      end
+
       # Get all feature tags for a given script
       # @param script_tag [String] 4-character script tag (e.g., 'latn')
       # @return [Array<String>] Array of 4-character feature tags

data/lib/fontisan/tables/gsub.rb

@@ -26,6 +26,13 @@ module Fontisan
         []
       end
 
+      # Every script with its feature tags, parsed once and work-budgeted
+      # (see {LayoutCommon::ScriptFeatures}).
+      # @return [Hash{String=>Array<String>}] script tag => feature tags
+      def script_features
+        LayoutCommon::ScriptFeatures.new(self).call
+      end
+
       # Get all feature tags for a given script
       # @param script_tag [String] 4-character script tag (e.g., 'latn')
       # @return [Array<String>] Array of 4-character feature tags