fontisan 0.4.47 → 0.4.48

data/lib/fontisan/tables/layout_common.rb

@@ -68,6 +68,178 @@ module Fontisan
         array :lookup_list_indices, type: :uint16,
                                     initial_length: -> { lookup_index_count }
       end
+
+      # Scripts paired with their feature tags, from one parse of the
+      # ScriptList and FeatureList instead of re-reading both per script.
+      #
+      # Gives exactly the answers of calling `scripts` and then
+      # `features(script_tag:)` for each (the first record of a tag decides;
+      # any short read yields []), but its total LangSys work is capped at
+      # {WORK_PER_BYTE} x the table length, so a table whose scripts each
+      # re-walk thousands of overlapping LangSys arrays cannot take minutes.
+      # Scripts reached after the budget is gone read as failed ([]), the
+      # same outcome as any other bad read. Mirrors the native tiers'
+      # `LayoutTable::script_features`.
+      class ScriptFeatures
+        # Work units per byte of table; a well-formed font spends a small
+        # fraction of one.
+        WORK_PER_BYTE = 2
+
+        # A short read or an exhausted budget: the script reads as [].
+        class Failed < StandardError; end
+
+        # @param table [Gsub, Gpos]
+        def initialize(table)
+          @table = table
+          @data = table.table_data
+          @budget = @data.bytesize * WORK_PER_BYTE
+        end
+
+        # @return [Hash{String=>Array<String>}] script tag => feature tags,
+        #   in record order
+        def call
+          return {} if @table.script_list_offset.zero?
+
+          list_data = slice_from(@data, @table.script_list_offset - 10)
+          return {} if list_data.nil? || list_data.empty?
+
+          records = ScriptList.read(list_data).script_records
+          features = feature_tags
+          records.each_with_object({}) do |record, result|
+            tag = record.script_tag
+            next if result.key?(tag)
+
+            result[tag] = script_feature_tags(list_data, record.script_offset,
+                                              features)
+          end
+        rescue StandardError
+          {}
+        end
+
+        private
+
+        # Ruby `String#[start..]`: negative starts count from the end.
+        def slice_from(string, start)
+          string[start..]
+        end
+
+        # FeatureList tags, or nil when every script must read as [].
+        def feature_tags
+          return nil if @table.script_list_offset.zero? ||
+            @table.feature_list_offset.zero?
+
+          data = slice_from(@data, @table.feature_list_offset - 10)
+          return nil if data.nil? || data.empty?
+
+          FeatureList.read(data).feature_tags
+        rescue StandardError
+          nil
+        end
+
+        def script_feature_tags(list_data, offset, features)
+          return [] unless features
+
+          indices = feature_indices(list_data, offset)
+          indices.filter_map { |index| features[index] }.uniq
+        rescue StandardError
+          []
+        end
+
+        # Feature indices of one Script table: its default LangSys and every
+        # LangSys record, deduplicated in first-seen order.
+        def feature_indices(list_data, offset)
+          data = slice_from(list_data, offset)
+          return [] if data.nil? || data.empty?
+
+          default_offset, count = read_header(data)
+          spend(count)
+          offsets = lang_sys_offsets(data, count)
+          collector = IndexCollector.new(data)
+          ([default_offset] + offsets).each do |lang_offset|
+            next if lang_offset.zero? || lang_offset >= data.bytesize
+
+            collector.add(lang_offset) { |units| spend(units) }
+          end
+          collector.indices
+        end
+
+        def read_header(data)
+          raise Failed if data.bytesize < 4
+
+          data.unpack("nn")
+        end
+
+        def lang_sys_offsets(data, count)
+          raise Failed if data.bytesize < 4 + (6 * count)
+
+          Array.new(count) { |i| data.byteslice(8 + (6 * i), 2).unpack1("n") }
+        end
+
+        def spend(units)
+          raise Failed if units > @budget
+
+          @budget -= units
+        end
+      end
+
+      # Distinct feature indices of many LangSys tables in first-seen order,
+      # reading every u16 word once. A LangSys index array is a run of words at
+      # a fixed byte parity inside the Script table, so hostile overlapping
+      # arrays would otherwise re-read the same words again and again; a word
+      # already collected is skipped (a "next unread slot" union-find per
+      # parity), which leaves the result and its order unchanged.
+      class IndexCollector
+        attr_reader :indices
+
+        def initialize(data)
+          @data = data
+          @skip = [{}, {}]
+          @seen = {}
+          @indices = []
+        end
+
+        # LangSys at +offset+: reserved, required index, count, count x u16.
+        # Yields the work units it costs (1 per table, 1 per word read).
+        def add(offset)
+          raise ScriptFeatures::Failed if @data.bytesize < offset + 6
+
+          count = @data.byteslice(offset + 4, 2).unpack1("n")
+          raise ScriptFeatures::Failed if @data.bytesize < offset + 6 + (2 * count)
+
+          yield(1)
+          first = offset + 6
+          parity = first & 1
+          slot = find(parity, first >> 1)
+          limit = (first + (2 * count)) >> 1
+          while slot < limit
+            yield(1)
+            collect(@data.byteslice((slot * 2) + parity, 2).unpack1("n"))
+            @skip[parity][slot] = slot + 1
+            slot = find(parity, slot + 1)
+          end
+        end
+
+        private
+
+        def collect(index)
+          return if @seen.key?(index)
+
+          @seen[index] = true
+          @indices << index
+        end
+
+        def find(parity, slot)
+          skip = @skip[parity]
+          root = slot
+          root = skip[root] while skip.key?(root)
+          while slot != root
+            following = skip[slot]
+            skip[slot] = root
+            slot = following
+          end
+          root
+        end
+      end
     end
   end
 end

data/lib/fontisan/tables/name.rb

@@ -108,8 +108,14 @@ module Fontisan
       array :name_records, type: :name_record, initial_length: :record_count
       rest :string_storage
 
-      # Cache for decoded names
-      attr_accessor :decoded_names_cache
+      # Cache for decoded names. Created on first use: do_read does not set
+      # it up when the table is empty, and english_name then raised
+      # NoMethodError on nil.
+      attr_writer :decoded_names_cache
+
+      def decoded_names_cache
+        @decoded_names_cache ||= {}
+      end
 
       # Hook that gets called after all fields are read
       def after_read_hook
@@ -168,7 +174,7 @@ module Fontisan
       # @return [String, nil] The decoded string or nil if not found
       def english_name(name_id)
         # Check cache first
-        return @decoded_names_cache[name_id] if @decoded_names_cache.key?(name_id)
+        return decoded_names_cache[name_id] if decoded_names_cache.key?(name_id)
 
         # Find record (don't decode yet)
         record = find_name_record(
@@ -187,7 +193,7 @@ module Fontisan
 
         # Decode only this one record
         decoded = decode_name_record(record)
-        @decoded_names_cache[name_id] = decoded
+        decoded_names_cache[name_id] = decoded
         decoded
       end
 

data/lib/fontisan/utilities/brotli_wrapper.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "brotli"
-
 module Fontisan
   module Utilities
     # Wrapper for Brotli compression with consistent settings
@@ -19,6 +17,15 @@ module Fontisan
     # @example Decompress data
     #   decompressed = BrotliWrapper.decompress(compressed_data)
     class BrotliWrapper
+      # Raised when the optional `brotli` C extension cannot be loaded (the
+      # java-platform gem omits it; WOFF2 is then served by the :ffi tier).
+      class Unavailable < Fontisan::Error; end
+
+      MISSING_MESSAGE = "WOFF2 needs the `brotli` gem, which is not available " \
+                        "(java-platform fontisan omits it). Use " \
+                        "FONTISAN_ENGINE=ffi or auto with the bundled cdylib, " \
+                        "or install the brotli gem."
+
       # Default compression quality (0-11, higher = better but slower)
       # Quality 11 gives best compression for WOFF2
       DEFAULT_QUALITY = 11
@@ -29,6 +36,30 @@ module Fontisan
       # Maximum quality level
       MAX_QUALITY = 11
 
+      # Whether the `brotli` gem loads here. Memoised; never raises.
+      def self.available?
+        return @available if defined?(@available)
+
+        @available = begin
+          require "brotli"
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      # Forget the memoised probe (specs).
+      def self.reset!
+        remove_instance_variable(:@available) if defined?(@available)
+      end
+
+      # The ::Brotli module, or {Unavailable} with a clear message.
+      def self.library
+        raise Unavailable, MISSING_MESSAGE unless available?
+
+        ::Brotli
+      end
+
       # Compress data using Brotli
       #
       # @param data [String] Data to compress
@@ -48,7 +79,9 @@ module Fontisan
         validate_data!(data)
 
         begin
-          Brotli.deflate(data, quality: quality, mode: mode)
+          library.deflate(data, quality: quality, mode: mode)
+        rescue Unavailable
+          raise
         rescue StandardError => e
           raise Fontisan::Error,
                 "Brotli compression failed: #{e.message}"
@@ -67,7 +100,9 @@ module Fontisan
         validate_data!(data)
 
         begin
-          Brotli.inflate(data)
+          library.inflate(data)
+        rescue Unavailable
+          raise
         rescue StandardError => e
           raise Fontisan::Error,
                 "Brotli decompression failed: #{e.message}"

data/lib/fontisan/validators/opentype_validator.rb

@@ -90,6 +90,8 @@ module Fontisan
         # Check 35: Cmap glyph indices must be valid
         check_structure :cmap_glyph_indices, severity: :error do |font|
           cmap = font.table("cmap")
+          next true unless cmap
+
           maxp = font.table("maxp")
           cmap.valid_glyph_indices?(maxp.num_glyphs)
         end

data/lib/fontisan/variable/instancer.rb

@@ -45,6 +45,7 @@ module Fontisan
       # @example
       #   binary = instancer.instance({ "wght" => 700, "wdth" => 100 })
       def instance(user_coords, _options = {})
+        Fontisan::Engine.record_ruby(:instance)
         tables = Variation::Instancing::TrueTypeInstancer
           .new(@font.table_data, user_coords).call
         FontWriter.write_font(tables)

data/lib/fontisan/variable/static_font_builder.rb

@@ -40,6 +40,8 @@ module Fontisan
       #   { ascent: 2048, descent: -512, line_gap: 0 }
       # @param options [Hash] Build options
       # @option options [Boolean] :update_modified Update head modified timestamp
+      # @option options [Integer, Time] :timestamp Fixed value to stamp when
+      #   updating head.modified (nil = current time)
       # @return [String] Complete static font binary
       def build(varied_metrics = {}, font_metrics = {}, options = {})
         # Collect tables for static font
@@ -170,7 +172,8 @@ options = {})
         if options[:update_modified] == false
           original_data
         else
-          @table_updater.update_head_modified(original_data)
+          @table_updater.update_head_modified(original_data,
+                                              options[:timestamp])
         end
       end
 

data/lib/fontisan/variable/table_updater.rb

@@ -157,9 +157,11 @@ module Fontisan
       # Update head table's modified timestamp
       #
       # @param original_data [String] Original head table binary
-      # @param timestamp [Time] New modification time
+      # @param timestamp [Time, Integer, nil] New modification time (Time or
+      #   Unix seconds); nil uses the current time
       # @return [String] Updated head table binary
-      def update_head_modified(original_data, timestamp = Time.now)
+      def update_head_modified(original_data, timestamp = nil)
+        timestamp ||= Time.now
         io = StringIO.new(original_data)
         io.set_encoding(Encoding::BINARY)
 

data/lib/fontisan/variation/instancing/true_type_instancer.rb

@@ -9,6 +9,8 @@ module Fontisan
       # chosen location. cvar, GPOS/GDEF variations and MVAR are not applied.
       class TrueTypeInstancer
         DROPPED = %w[fvar gvar avar HVAR VVAR MVAR STAT cvar DSIG].freeze
+        # Tables read by #call besides the variation tables checked below.
+        REQUIRED = %w[head hhea hmtx maxp loca].freeze
         WIDTH_CLASSES = [50, 62.5, 75, 87.5, 100, 112.5, 125, 150, 200].freeze
 
         # @param tables [Hash{String=>String}] raw tables of the variable font
@@ -45,13 +47,19 @@ module Fontisan
           unless @tables["fvar"]
             raise MissingVariationTableError.new(table: "fvar")
           end
-          return if @tables["gvar"] && @tables["glyf"]
+          unless @tables["gvar"] && @tables["glyf"]
+            raise MissingVariationTableError.new(
+              table: "gvar",
+              message: "Static instancing needs TrueType outlines with gvar " \
+                       "(CFF2 variable fonts are not supported yet)",
+            )
+          end
+
+          REQUIRED.each do |tag|
+            next if @tables[tag]
 
-          raise MissingVariationTableError.new(
-            table: "gvar",
-            message: "Static instancing needs TrueType outlines with gvar " \
-                     "(CFF2 variable fonts are not supported yet)",
-          )
+            raise MissingTableError, "Font missing required #{tag} table"
+          end
         end
 
         def read_metrics(num_glyphs)

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/collection_decoder.rb

@@ -59,15 +59,29 @@ module Fontisan
         # the glyf was transformed.
         font_entries.map do |fe|
           font_tables = {}
+          glyf_transformed = false
           fe.table_indices.each do |idx|
             entry = table_entries.fetch(idx)
             font_tables[entry.tag] = entry.raw_bytes
+            glyf_transformed = !entry.transform_length.nil? if entry.tag == "glyf"
           end
-          reconstruct_glyf_loca!(font_tables) if font_tables.key?("glyf")
+          reconstruct_glyf_loca!(font_tables) if glyf_transformed
           { flavor: fe.flavor, tables: font_tables }
         end
       end
 
+      # Number of fonts, read from the CollectionDirectory alone: no Brotli
+      # inflate, so it works where the `brotli` gem is absent (JRuby).
+      #
+      # @return [Integer]
+      def font_count
+        validate_signature!
+        validate_collection_flavor!
+
+        _entries, post_dir_pos = read_table_directory
+        read_collection_directory(post_dir_pos).first.length
+      end
+
       private
 
       def validate_signature!

data/lib/fontisan/woff2/collection_encoder.rb

@@ -21,10 +21,15 @@ module Fontisan
     # adjacent (loca immediately follows glyf) in the directory.
     class CollectionEncoder
       TTC_FLAVOR = 0x74746366 # 'ttcf'
+      # Largest padded glyf a short (uint16, offset / 2) loca can index.
+      SHORT_LOCA_GLYF_MAX = 0x1FFFE
 
       # @param brotli_quality [Integer] 0-11
-      def initialize(brotli_quality: 11)
+      # @param timestamp [Integer, nil] Unix seconds stamped into every
+      #   head.modified; nil uses the clock
+      def initialize(brotli_quality: 11, timestamp: nil)
         @brotli_quality = brotli_quality
+        @timestamp = timestamp
       end
 
       # Encode an array of fonts as a WOFF2 collection.
@@ -58,7 +63,7 @@ module Fontisan
           tables[tag] = data
         end
 
-        EncoderRules.apply!(tables)
+        EncoderRules.apply!(tables, timestamp: @timestamp)
         loca_orig_length = apply_glyf_loca_transform!(tables, font)
 
         { index:, tables:, loca_orig_length: }
@@ -73,12 +78,30 @@ module Fontisan
         head = font.table("head")
         return nil unless maxp && head
 
-        loca_orig_length = tables["loca"].bytesize
+        glyf = tables["glyf"]
+        loca = tables["loca"]
+        index_format = head.index_to_loc_format
+        # The WOFF2 decoder pads every glyph to 4 bytes; a short loca
+        # (offset / 2 as uint16) wraps once that padded glyf passes
+        # SHORT_LOCA_GLYF_MAX, so such a member is re-emitted with a long loca.
+        if index_format.zero? &&
+            glyf.bytesize + 3 * maxp.num_glyphs > SHORT_LOCA_GLYF_MAX
+          canonical = GlyfCanonicalizer.new(
+            glyf_data: glyf, loca_data: loca, num_glyphs: maxp.num_glyphs,
+            source_format: 0, target_format: 1
+          ).canonical
+          glyf = canonical[:glyf]
+          loca = canonical[:loca]
+          index_format = 1
+          EncoderRules.set_head_index_to_loc_format!(tables, 1)
+        end
+
+        loca_orig_length = loca.bytesize
         tables["glyf"] = GlyfLocaTransform.new(
-          glyf_data: tables["glyf"],
-          loca_data: tables["loca"],
+          glyf_data: glyf,
+          loca_data: loca,
           num_glyphs: maxp.num_glyphs,
-          index_format: head.index_to_loc_format,
+          index_format:,
         ).transform
         tables.delete("loca")
         loca_orig_length

data/lib/fontisan/woff2/encoder_rules.rb

@@ -29,11 +29,13 @@ module Fontisan
       #
       # @param table_data [Hash{String => String}] Map of tag → binary
       #   table data. Mutated.
+      # @param timestamp [Integer, Time, nil] Fixed value for head.modified
+      #   (Unix seconds); nil stamps the current wall-clock time.
       # @return [Hash{String => String}] The same hash, for chaining.
-      def self.apply!(table_data)
+      def self.apply!(table_data, timestamp: nil)
         exclude_tables!(table_data)
         mark_lossless_modifying!(table_data)
-        touch_head_modified!(table_data)
+        touch_head_modified!(table_data, timestamp: timestamp)
         table_data
       end
 
@@ -94,11 +96,17 @@ module Fontisan
       # are included in the checksum.
       #
       # @param table_data [Hash{String => String}]
-      def self.touch_head_modified!(table_data)
+      # @param timestamp [Integer, Time, nil] Unix seconds to stamp instead of
+      #   the current time (reproducible output); nil keeps the clock.
+      def self.touch_head_modified!(table_data, timestamp: nil)
         return unless table_data.key?("head")
 
         head = Tables::Head.read(table_data["head"])
-        head.modified_raw = Tables::Head.now_longdatetime
+        head.modified_raw = if timestamp.nil?
+                              Tables::Head.now_longdatetime
+                            else
+                              Tables::Head.to_longdatetime(timestamp)
+                            end
         table_data["head"] = head.to_binary_s
       end
     end

data/lib/fontisan/woff2/glyf_loca_reconstruct.rb

@@ -378,7 +378,7 @@ module Fontisan
           end
           if count > 1
             out << (flag | FLAG_REPEAT).chr(Encoding::BINARY)
-            out << count.chr(Encoding::BINARY)
+            out << (count - 1).chr(Encoding::BINARY)
             i += count
           else
             out << flag.chr(Encoding::BINARY)

data/lib/fontisan/woff2_collection.rb

@@ -62,13 +62,14 @@ module Fontisan
     #
     # @param index [Integer] 0-based font index
     # @param _io [IO, nil] Ignored.
-    # @param _mode [Symbol] Ignored — full mode only (WOFF2 collections are
-    #   decoded eagerly).
+    # @param mode [Symbol] Loading mode, as for the TTC/OTC collections
+    #   (default: full). Decoding is eager, so mode only limits which tables
+    #   are kept on the returned font.
     # @return [TrueTypeFont, OpenTypeFont, nil] nil if index out of range
-    def font(index, _io = nil, _mode: LoadingModes::FULL)
+    def font(index, _io = nil, mode: LoadingModes::FULL)
       return nil if index >= num_fonts
 
-      build_font(decoded[index])
+      build_font(decoded[index], mode)
     end
 
     # Whether this object represents a font collection. WOFF2 collections
@@ -108,12 +109,13 @@ module Fontisan
     # Build a TrueTypeFont or OpenTypeFont from a decoded font entry.
     # Constructs an in-memory SFNT binary from the per-table data and
     # loads it through the normal font reader path.
-    def build_font(entry)
+    def build_font(entry, mode = LoadingModes::FULL)
       sfnt = SfntBuilder.build(flavor: entry[:flavor], tables: entry[:tables])
       sfnt_io = StringIO.new(sfnt)
       font_class = truetype_flavor?(entry[:flavor]) ? TrueTypeFont : OpenTypeFont
       font = font_class.read(sfnt_io)
       font.initialize_storage
+      font.loading_mode = mode
       font.read_table_data(StringIO.new(sfnt))
       font
     end

data/lib/fontisan/woff2_font.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "bindata"
-require "brotli"
 require "stringio"
 
 module Fontisan
@@ -266,7 +265,7 @@ module Fontisan
         File.open(@io_source.path, "rb") do |io|
           io.seek(@header.meta_offset)
           compressed_meta = io.read(@header.meta_length)
-          Brotli.inflate(compressed_meta)
+          Utilities::BrotliWrapper.library.inflate(compressed_meta)
         end
       rescue StandardError => e
         warn "Failed to decompress metadata: #{e.message}"
@@ -516,7 +515,7 @@ module Fontisan
       compressed_data = io.read(header.total_compressed_size)
 
       # Decompress entire data block with Brotli
-      decompressed_data = Brotli.inflate(compressed_data)
+      decompressed_data = inflate_brotli(compressed_data)
 
       # Split decompressed data into individual tables
       decompressed_tables = {}
@@ -533,6 +532,16 @@ module Fontisan
       decompressed_tables
     end
 
+    # Brotli-inflate the table block. A bad stream is the same InvalidFontError
+    # on every tier (the native tiers say "brotli stream is corrupt"); the
+    # binding's own message and class are not a contract.
+    def self.inflate_brotli(data)
+      Utilities::BrotliWrapper.library.inflate(data)
+    rescue StandardError
+      raise InvalidFontError.new("Invalid WOFF2 file: woff: brotli stream is corrupt"), cause: nil
+    end
+    private_class_method :inflate_brotli
+
     # Apply table transformations for glyf/loca/hmtx tables
     #
     # @param table_entries [Array<Woff2TableDirectoryEntry>] Table entries