fontisan 0.4.46 → 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

@@ -44,7 +44,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf # Skip if CFF font
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
           glyf.all_glyphs_accessible?(loca, head, maxp.num_glyphs)
@@ -55,7 +55,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
           glyf.no_clipped_glyphs?(loca, head, maxp.num_glyphs)
@@ -66,7 +66,7 @@ module Fontisan
           glyf = font.table("glyf")
           next true unless glyf
 
-          loca = font.table("loca")
+          loca = parsed_loca(font)
           head = font.table("head")
           maxp = font.table("maxp")
 
@@ -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
@@ -101,6 +103,16 @@ module Fontisan
           true # Placeholder - actual checksum validation if desired
         end
       end
+
+      # loca must be parsed with head/maxp context before glyf can read it.
+      def parsed_loca(font)
+        loca = font.table("loca")
+        return loca if loca.parsed?
+
+        loca.parse_with_context(font.table("head").index_to_loc_format,
+                                font.table("maxp").num_glyphs)
+        loca
+      end
     end
   end
 end

data/lib/fontisan/variable/instancer.rb

@@ -25,12 +25,6 @@ module Fontisan
       # @return [Object] The variable font object
       attr_reader :font
 
-      # @return [DeltaApplicator] Delta applicator
-      attr_reader :delta_applicator
-
-      # @return [StaticFontBuilder] Static font builder
-      attr_reader :static_font_builder
-
       # Initialize the instancer
       #
       # @param font [TrueTypeFont, OpenTypeFont] Variable font object
@@ -38,9 +32,6 @@ module Fontisan
       def initialize(font)
         @font = font
         validate_variable_font!
-
-        @delta_applicator = DeltaApplicator.new(font)
-        @static_font_builder = StaticFontBuilder.new(font)
       end
 
       # Generate static font instance at specified coordinates
@@ -53,21 +44,11 @@ module Fontisan
       #
       # @example
       #   binary = instancer.instance({ "wght" => 700, "wdth" => 100 })
-      def instance(user_coords, options = {})
-        # Apply deltas to get all varied data
-        delta_result = @delta_applicator.apply(user_coords)
-
-        # Collect varied metrics for all glyphs
-        varied_metrics = collect_varied_glyph_metrics(
-          delta_result[:normalized_coords],
-          delta_result[:region_scalars],
-        )
-
-        # Extract font-level metrics
-        font_metrics = delta_result[:font_metrics]
-
-        # Build static font
-        @static_font_builder.build(varied_metrics, font_metrics, options)
+      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)
       end
 
       # Generate static font instance and write to file
@@ -117,23 +98,16 @@ module Fontisan
       # @return [Array<Hash>] Array of named instance information
       #   [{ name: "Bold", coords: { "wght" => 700 } }, ...]
       def named_instances
-        fvar = load_fvar_table
-        return [] unless fvar
-
-        # Get name table for instance names
-        name_table = load_name_table
-
-        fvar.instances.map do |instance|
-          coords = extract_instance_coords(instance, fvar)
-          name = if name_table
-                   get_instance_name(instance[:name_id],
-                                     name_table)
-                 end
-
+        fvar = @font.table_data["fvar"]
+        names = if @font.table_data["name"]
+                  Variation::Instancing::NameRewriter.new(@font.table_data["name"])
+                end
+        tags = axis_tags
+        Variation::Instancing::AxisSpace.named_instances(fvar).map do |inst|
           {
-            name_id: instance[:name_id],
-            name: name || "Instance #{instance[:name_id]}",
-            coordinates: coords,
+            name_id: inst[:name_id],
+            name: names&.lookup(inst[:name_id]) || "Instance #{inst[:name_id]}",
+            coordinates: tags.zip(inst[:values]).to_h,
           }
         end
       end
@@ -142,21 +116,21 @@ module Fontisan
       #
       # @return [Boolean] True if variable font
       def variable_font?
-        @delta_applicator.variable_font?
+        true
       end
 
       # Get available axis information
       #
-      # @return [Hash] Axis information
+      # @return [Array<Variation::Instancing::AxisSpace::Axis>]
       def axes
-        @delta_applicator.axes
+        axis_space.axes
       end
 
       # Get available axis tags
       #
       # @return [Array<String>] Array of axis tags
       def axis_tags
-        @delta_applicator.axis_tags
+        axis_space.tags
       end
 
       private
@@ -165,60 +139,16 @@ module Fontisan
       #
       # @raise [ArgumentError] If not a variable font
       def validate_variable_font!
-        fvar_data = @font.table_data("fvar")
+        fvar_data = @font.table_data["fvar"]
         return unless fvar_data.nil? || fvar_data.empty?
 
         raise ArgumentError, "Font is not a variable font (missing fvar table)"
       end
 
-      # Collect varied metrics for all glyphs
-      #
-      # @param normalized_coords [Hash] Normalized coordinates
-      # @param region_scalars [Array<Float>] Region scalars
-      # @return [Hash<Integer, Hash>] Varied metrics by glyph ID
-      def collect_varied_glyph_metrics(normalized_coords, _region_scalars)
-        varied_metrics = {}
-
-        # Get number of glyphs
-        maxp = load_maxp_table
-        return varied_metrics unless maxp
-
-        num_glyphs = maxp.num_glyphs
-
-        # Get original hmtx metrics
-        hmtx = load_hmtx_table
-        return varied_metrics unless hmtx
-
-        # For each glyph, calculate varied metrics
-        num_glyphs.times do |glyph_id|
-          original_metric = hmtx.metric_for(glyph_id)
-          next unless original_metric
-
-          # Get deltas from delta applicator
-          deltas = @delta_applicator.apply_glyph(glyph_id, normalized_coords)
-          metric_deltas = deltas[:metric_deltas]
-
-          # Calculate varied values
-          varied_metric = {
-            advance_width: original_metric[:advance_width],
-            lsb: original_metric[:lsb],
-          }
-
-          # Apply horizontal deltas if present
-          if metric_deltas[:horizontal]
-            if metric_deltas[:horizontal][:advance_width]
-              varied_metric[:advance_width] += metric_deltas[:horizontal][:advance_width]
-            end
-
-            if metric_deltas[:horizontal][:lsb]
-              varied_metric[:lsb] += metric_deltas[:horizontal][:lsb]
-            end
-          end
-
-          varied_metrics[glyph_id] = varied_metric
-        end
-
-        varied_metrics
+      def axis_space
+        @axis_space ||= Variation::Instancing::AxisSpace.new(
+          @font.table_data["fvar"], @font.table_data["avar"]
+        )
       end
 
       # Find coordinates for a named instance
@@ -237,105 +167,6 @@ module Fontisan
 
         instance[:coordinates]
       end
-
-      # Extract coordinates from instance record
-      #
-      # @param instance [Hash] Instance record
-      # @param fvar [Fvar] fvar table
-      # @return [Hash<String, Float>] Coordinates by axis tag
-      def extract_instance_coords(instance, fvar)
-        coords = {}
-        instance[:coordinates].each_with_index do |value, index|
-          axis = fvar.axes[index]
-          coords[axis.axis_tag.to_s] = value if axis
-        end
-        coords
-      end
-
-      # Get instance name from name table
-      #
-      # @param name_id [Integer] Name table ID
-      # @param name_table [Name] name table
-      # @return [String, nil] Instance name
-      def get_instance_name(name_id, name_table)
-        # Try to get English name
-        record = name_table.records.find do |r|
-          r.name_id == name_id && r.language_id == 0x0409 # English (US)
-        end
-
-        record ||= name_table.records.find { |r| r.name_id == name_id }
-        record&.value
-      rescue StandardError
-        nil
-      end
-
-      # Load fvar table
-      #
-      # @return [Fvar, nil] fvar table or nil
-      def load_fvar_table
-        data = @font.table_data("fvar")
-        return nil if data.nil? || data.empty?
-
-        Tables::Fvar.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load name table
-      #
-      # @return [Name, nil] name table or nil
-      def load_name_table
-        data = @font.table_data("name")
-        return nil if data.nil? || data.empty?
-
-        Tables::Name.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load maxp table
-      #
-      # @return [Maxp, nil] maxp table or nil
-      def load_maxp_table
-        data = @font.table_data("maxp")
-        return nil if data.nil? || data.empty?
-
-        Tables::Maxp.read(data)
-      rescue StandardError
-        nil
-      end
-
-      # Load hmtx table
-      #
-      # @return [Hmtx, nil] hmtx table or nil
-      def load_hmtx_table
-        data = @font.table_data("hmtx")
-        return nil if data.nil? || data.empty?
-
-        hmtx = Tables::Hmtx.read(data)
-
-        # Parse with context
-        hhea = load_hhea_table
-        maxp = load_maxp_table
-        return nil unless hhea && maxp
-
-        hmtx.parse_with_context(hhea.number_of_h_metrics, maxp.num_glyphs)
-        hmtx
-      rescue StandardError
-        nil
-      end
-
-      # Load hhea table
-      #
-      # @return [Hhea, nil] hhea table or nil
-      def load_hhea_table
-        data = @font.table_data("hhea")
-        return nil if data.nil? || data.empty?
-
-        Tables::Hhea.read(data)
-      rescue StandardError
-        nil
-      end
     end
   end
 end

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)