fontisan 0.4.45 → 0.4.47

data/lib/fontisan/tables/gpos/pair_position.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "fontisan"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Checked views share physical identity without copying table suffixes.
+      class BinaryView
+        def initialize(data, offset: 0, cache: {})
+          @data = data
+          @offset = offset
+          @cache = cache
+        end
+
+        def bytes(offset, length)
+          if offset.negative? || length.negative? || @offset + offset + length > @data.bytesize
+            raise ParseError, "Truncated GPOS data at byte #{offset}"
+          end
+
+          @data.byteslice(@offset + offset, length)
+        end
+
+        def uint16(offset)
+          bytes(offset, 2).unpack1("n")
+        end
+
+        def uint32(offset)
+          bytes(offset, 4).unpack1("N")
+        end
+
+        def array(offset, count)
+          bytes(offset, count * 2).unpack("n*")
+        end
+
+        def child(offset, minimum:)
+          raise ParseError, "Invalid GPOS offset #{offset}" if offset < minimum
+
+          bytes(offset, 1)
+          self.class.new(@data, offset: @offset + offset, cache: @cache)
+        end
+
+        def record(type, header:, count_offset:, item_size:)
+          bytes(0, header + uint16(count_offset) * item_size)
+          type.read(@data.byteslice(@offset..))
+        end
+
+        def cached(context)
+          key = [@offset, context]
+          @cache.fetch(key) { @cache[key] = yield }
+        end
+
+        def freeze
+          @cache.freeze
+          super
+        end
+      end
+
+      # Coverage ranges remain compact, including the full glyph-ID domain.
+      class Coverage
+        include Enumerable
+
+        attr_reader :size
+
+        def initialize(view)
+          format = view.uint16(0)
+          count = view.uint16(2)
+          case format
+          when 1
+            @glyphs = view.array(4, count).freeze
+            unless @glyphs.each_cons(2).all? { |first, second| first < second }
+              raise ParseError, "Unsorted or duplicate GPOS glyph IDs"
+            end
+
+            @size = count
+          when 2
+            @ranges = view.array(4, count * 3).each_slice(3).map(&:freeze).freeze
+            @size = 0
+            previous = -1
+            @ranges.each do |first, last, index|
+              if first > last || index != @size || first <= previous
+                raise ParseError, "Invalid GPOS coverage range"
+              end
+
+              @size += last - first + 1
+              previous = last
+            end
+          else
+            raise ParseError, "Unsupported Coverage format #{format}"
+          end
+          freeze
+        end
+
+        def include?(glyph)
+          return @glyphs.bsearch { |candidate| candidate >= glyph } == glyph if @glyphs
+
+          record = @ranges.bsearch { |_first, last, _index| last >= glyph }
+          record && record[0] <= glyph
+        end
+
+        def each(&block)
+          return enum_for(:each) unless block
+
+          if @glyphs
+            @glyphs.each(&block)
+          else
+            @ranges.each do |first, last, _index|
+              (first..last).each(&block)
+            end
+          end
+          self
+        end
+      end
+
+      # Class arrays support direct glyph indexing without singleton ranges.
+      class ClassDefinition
+        attr_reader :maximum
+
+        def initialize(view)
+          @view = view
+          case view.uint16(0)
+          when 1
+            @first = view.uint16(2)
+            @count = view.uint16(4)
+            raise ParseError, "Invalid GPOS class definition" if @first + @count > 65536
+
+            @maximum = view.array(6, @count).max || 0
+          when 2
+            @ranges = view.array(4, view.uint16(2) * 3).each_slice(3).map(&:freeze).freeze
+            previous = -1
+            @maximum = 0
+            @ranges.each do |first, last, value|
+              if first <= previous || first > last
+                raise ParseError, "Invalid GPOS class definition"
+              end
+
+              @maximum = [@maximum, value].max
+              previous = last
+            end
+          else
+            raise ParseError, "Unsupported ClassDef format #{view.uint16(0)}"
+          end
+          freeze
+        end
+
+        def [](glyph)
+          if @ranges
+            record = @ranges.bsearch { |_first, last, _value| last >= glyph }
+            record && record[0] <= glyph ? record[2] : 0
+          else
+            index = glyph - @first
+            index.between?(0, @count - 1) ? @view.uint16(6 + index * 2) : 0
+          end
+        end
+      end
+
+      # Compact PairPos data; class matrices stay in their binary representation.
+      class PairPosition
+        attr_reader :left_glyphs
+
+        def initialize(view)
+          @view = view
+          @format = view.uint16(0)
+          raise ParseError, "Unsupported PairPos format #{@format}" unless [1, 2].include?(@format)
+
+          @first_format = view.uint16(4)
+          @second_format = view.uint16(6)
+          @first_size = value_size(@first_format)
+          @record_size = @first_size + value_size(@second_format)
+          @advance_offset = value_size(@first_format & 3)
+          @coverage = coverage
+          @left_glyphs = @coverage
+          @format == 1 ? parse_pairs : parse_classes
+          freeze
+        end
+
+        def class_based?
+          @format == 2
+        end
+
+        def covers?(glyph)
+          @coverage.include?(glyph)
+        end
+
+        def adjustment(left, right)
+          return unless covers?(left)
+          return @pairs.fetch(left)[right] unless class_based?
+
+          row = @first_classes[left]
+          column = @second_classes[right]
+          advance(@matrix, (row * @second_count + column) * @record_size)
+        end
+
+        def right_glyphs(left)
+          @pairs.fetch(left).each_key
+        end
+
+        private
+
+        def value_size(format)
+          raise ParseError, "Reserved GPOS ValueFormat bits" unless (format & 0xff00).zero?
+
+          format.digits(2).sum * 2
+        end
+
+        def advance(view, offset)
+          return 0 if (@first_format & 4).zero?
+
+          value = view.uint16(offset + @advance_offset)
+          value >= 0x8000 ? value - 0x10000 : value
+        end
+
+        def coverage
+          minimum = @format == 1 ? 10 + @view.uint16(8) * 2 : 16 + matrix_size
+          view = @view.child(@view.uint16(2), minimum: minimum)
+          view.cached(:coverage) { Coverage.new(view) }
+        end
+
+        def parse_pairs
+          count = @view.uint16(8)
+          raise ParseError, "GPOS PairSet count differs from coverage" unless count == left_glyphs.size
+
+          offsets = @view.array(10, count)
+          @pairs = {}
+          left_glyphs.each_with_index do |left, index|
+            view = @view.child(offsets[index], minimum: 10 + count * 2)
+            @pairs[left] = view.cached([:pair_set, @first_format, @second_format]) { pair_set(view) }
+          end
+          @pairs.freeze
+        end
+
+        def pair_set(view)
+          count = view.uint16(0)
+          view.bytes(2, count * (2 + @record_size))
+          previous = -1
+          pairs = {}
+          count.times do |index|
+            start = 2 + index * (2 + @record_size)
+            glyph = view.uint16(start)
+            raise ParseError, "Unsorted or duplicate GPOS glyph IDs" if glyph <= previous
+
+            pairs[glyph] = advance(view, start + 2)
+            previous = glyph
+          end
+          pairs.freeze
+        end
+
+        def matrix_size
+          @view.uint16(12) * @view.uint16(14) * @record_size
+        end
+
+        def parse_classes
+          first_count = @view.uint16(12)
+          @second_count = @view.uint16(14)
+          raise ParseError, "Empty GPOS class matrix" if first_count.zero? || @second_count.zero?
+
+          @matrix = BinaryView.new(@view.bytes(16, matrix_size).freeze).freeze
+          @first_classes = class_definition(@view.uint16(8), first_count)
+          @second_classes = class_definition(@view.uint16(10), @second_count)
+        end
+
+        def class_definition(offset, class_count)
+          view = @view.child(offset, minimum: 16 + matrix_size)
+          definition = view.cached(:class_definition) { ClassDefinition.new(view) }
+          raise ParseError, "Invalid GPOS class definition" if definition.maximum >= class_count
+
+          definition
+        end
+      end
+
+      private_constant :BinaryView, :Coverage, :ClassDefinition, :PairPosition
+    end
+  end
+end

data/lib/fontisan/tables/gpos.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fontisan"
+
 module Fontisan
   module Tables
     # GPOS (Glyph Positioning) table parser
@@ -55,6 +57,25 @@ module Fontisan
         []
       end
 
+      # Read PairPos value1.xAdvance in font units, directly or via extensions.
+      # The returned Enumerable supports pairs[[left_glyph_id, right_glyph_id]];
+      # unmatched pairs return zero. Use glyph_count: font.table("maxp").num_glyphs.to_i
+      # to enumerate class-based pairs, including implicit class zero, with to_h.
+      # Selects the script's default language system, with no script fallback.
+      # First matching subtables take precedence; distinct lookups are summed.
+      # Supports PairPos formats 1 and 2 in lookup types 2 and 9. Pass raw GDEF
+      # bytes with gdef: font.table_data["GDEF"] for glyph-filtering lookups.
+      # Lazy SFNT fonts can use font.sfnt_table("GDEF").load_data!.data instead.
+      # Filters apply to supplied pair endpoints; this does not shape a stream.
+      # Other lookup types, device corrections and variations are not applied.
+      # @return [Enumerable] nonzero glyph-ID pairs and signed advances
+      # @raise [ParseError] malformed selected positioning data
+      # @raise [UnsupportedFormatError] selected filtering requires missing GDEF data
+      def kern_pairs(script_tag: "latn", feature_tag: "kern", glyph_count: nil, gdef: nil)
+        KerningPairs.new(self, script_tag: script_tag, feature_tag: feature_tag,
+                               glyph_count: glyph_count, gdef: gdef)
+      end
+
       private
 
       # Get feature indices for a given script
@@ -107,3 +128,5 @@ module Fontisan
     end
   end
 end
+
+require "fontisan/tables/gpos/kerning_pairs"

data/lib/fontisan/tables/post.rb

@@ -14,7 +14,7 @@ module Fontisan
 
       register_tag "post"
       # Standard Mac glyph names for version 1.0 (258 glyphs)
-      # rubocop:disable Metrics/CollectionLiteralLength
+      # rubocop:disable-next Metrics/CollectionLiteralLength
       STANDARD_NAMES = %w[
         .notdef .null nonmarkingreturn space exclam quotedbl numbersign
         dollar percent ampersand quotesingle parenleft parenright asterisk
@@ -48,7 +48,6 @@ module Fontisan
         Gbreve gbreve Idotaccent Scedilla scedilla Cacute cacute Ccaron
         ccaron dcroat
       ].freeze
-      # rubocop:enable Metrics/CollectionLiteralLength
 
       # Version 2.0 as Fixed 16.16 constant
       VERSION_2_0_RAW = 131_072 # 2.0 * 65536
@@ -99,7 +98,7 @@ module Fontisan
       #
       # Version 2.0 uses a combination of standard Mac names (indices 0-257)
       # and custom names (indices >= 258) stored as Pascal strings.
-      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/PerceivedComplexity
       def parse_version_2_names
         return [] unless version_raw == VERSION_2_0_RAW
         return [] if remaining_data.empty?
@@ -145,7 +144,6 @@ module Fontisan
           end
         end
       end
-      # rubocop:enable Metrics/PerceivedComplexity
 
       public
 

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")
 
@@ -101,6 +101,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,10 @@ 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 = {})
+        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 +97,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 +115,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 +138,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 +166,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