fontisan 0.4.43 → 0.4.44

data/lib/fontisan/utilities/padding.rb

@@ -10,6 +10,9 @@ module Fontisan
     # across nine call sites before extraction; this module is the
     # single source of truth.
     #
+    # All public methods take an Integer size. Callers with a String
+    # compute `.bytesize` first.
+    #
     # @example Get padding length
     #   Padding.boundary(13)              # => 3
     #   Padding.boundary(13, boundary: 4) # => 3
@@ -21,14 +24,13 @@ module Fontisan
     module Padding
       # Count of trailing pad bytes needed to align `size` to `boundary`.
       #
-      # @param size [Integer, #bytesize] Either an Integer size, or any
-      #   object responding to `#bytesize` (e.g. a String).
+      # @param size [Integer] Size in bytes (callers with a String
+      #   compute `.bytesize` first).
       # @param boundary [Integer] Alignment boundary in bytes (default
       #   `Constants::TABLE_ALIGNMENT`).
       # @return [Integer] Number of pad bytes in 0...boundary-1
       def self.boundary(size, boundary: Constants::TABLE_ALIGNMENT)
-        length = size.respond_to?(:bytesize) ? size.bytesize : size
-        (boundary - (length % boundary)) % boundary
+        (boundary - (size % boundary)) % boundary
       end
 
       # Return `bytes` followed by null padding to the requested boundary.
@@ -38,7 +40,7 @@ module Fontisan
       # @return [String] The original string if already aligned, else a
       #   new binary string with trailing nulls.
       def self.pad(bytes, boundary: Constants::TABLE_ALIGNMENT)
-        pad_count = boundary(bytes, boundary:)
+        pad_count = boundary(bytes.bytesize, boundary:)
         return bytes if pad_count.zero?
 
         out = bytes.dup.force_encoding(Encoding::BINARY)
@@ -48,12 +50,11 @@ module Fontisan
 
       # Aligned size of `size` after padding to `boundary`.
       #
-      # @param size [Integer, #bytesize] Original size or bytes-like.
+      # @param size [Integer] Original size in bytes.
       # @param boundary [Integer] Alignment boundary in bytes.
       # @return [Integer] Size after alignment (multiple of `boundary`).
       def self.aligned_size(size, boundary: Constants::TABLE_ALIGNMENT)
-        length = size.respond_to?(:bytesize) ? size.bytesize : size
-        length + boundary(length, boundary:)
+        size + boundary(size, boundary:)
       end
     end
   end

data/lib/fontisan/validation/collection_validator.rb

@@ -246,7 +246,7 @@ module Fontisan
       # @param font [Object] Font object
       # @return [Boolean] true if TrueType
       def truetype_font?(font)
-        return false unless font.respond_to?(:has_table?)
+        return false unless font.is_a?(SfntSource)
 
         font.has_table?("glyf")
       end
@@ -256,7 +256,7 @@ module Fontisan
       # @param font [Object] Font object
       # @return [Boolean] true if CFF
       def cff_font?(font)
-        return false unless font.respond_to?(:has_table?)
+        return false unless font.is_a?(SfntSource)
 
         font.has_table?("CFF ") || font.has_table?("CFF2")
       end

data/lib/fontisan/validators/validator.rb

@@ -290,10 +290,10 @@ module Fontisan
           }
         end
 
-        # Get field value
-        value = if table.respond_to?(field_key)
-                  table.public_send(field_key)
-                end
+        # Get field value via the table's snapshot hash (BinData records
+        # expose all declared fields through #snapshot).
+        snapshot = table.is_a?(BinData::Record) ? table.snapshot : {}
+        value = snapshot[field_key.to_s] || snapshot[field_key.to_sym]
 
         result = check_def[:block].call(table, value)
         passed = result != false && !result.nil?

data/lib/fontisan/variable/delta_applicator.rb

@@ -260,20 +260,13 @@ module Fontisan
       # @param tag [String] Table tag
       # @return [Object, nil] Table object or nil
       def load_table(tag)
-        return nil unless @font.respond_to?(:table_data)
+        return nil unless @font.is_a?(SfntSource)
 
         data = @font.table_data(tag)
         return nil if data.nil? || data.empty?
 
-        # Map tag to table class
-        table_class = case tag
-                      when "fvar" then Tables::Fvar
-                      when "gvar" then Tables::Gvar
-                      when "HVAR" then Tables::Hvar
-                      when "VVAR" then Tables::Vvar
-                      when "MVAR" then Tables::Mvar
-                      else return nil
-                      end
+        table_class = Tables::Registry.for(tag)
+        return nil unless table_class
 
         table_class.read(data)
       rescue StandardError => e
@@ -293,7 +286,7 @@ module Fontisan
         end
 
         # Try VVAR
-        if @vvar.respond_to?(:item_variation_store) && @vvar.item_variation_store
+        if @vvar.is_a?(Tables::Vvar) && @vvar.item_variation_store
           return @vvar.item_variation_store.variation_region_list
         end
 

data/lib/fontisan/variable/metric_delta_processor.rb

@@ -221,17 +221,17 @@ module Fontisan
 
         # Similar to HVAR but for vertical metrics
         # VVAR has the same structure as HVAR
-        if @vvar.respond_to?(:advance_height_delta_set) && (delta_set = @vvar.advance_height_delta_set(glyph_id))
+        if (delta_set = @vvar.advance_height_delta_set(glyph_id))
           accumulated = calculate_accumulated_delta(delta_set, region_scalars)
           result[:advance_height] = apply_rounding(accumulated)
         end
 
-        if @vvar.respond_to?(:tsb_delta_set) && (delta_set = @vvar.tsb_delta_set(glyph_id))
+        if (delta_set = @vvar.tsb_delta_set(glyph_id))
           accumulated = calculate_accumulated_delta(delta_set, region_scalars)
           result[:tsb] = apply_rounding(accumulated)
         end
 
-        if @vvar.respond_to?(:bsb_delta_set) && (delta_set = @vvar.bsb_delta_set(glyph_id))
+        if (delta_set = @vvar.bsb_delta_set(glyph_id))
           accumulated = calculate_accumulated_delta(delta_set, region_scalars)
           result[:bsb] = apply_rounding(accumulated)
         end

data/lib/fontisan/variable/static_font_builder.rb

@@ -65,19 +65,22 @@ options = {})
         File.binwrite(output_path, binary)
       end
 
+      # Per-tag table update dispatch. Each entry maps a tag to
+      # [method_name, context_key] for looking up the right args.
+      TABLE_UPDATERS = {
+        "hmtx" => %i[update_hmtx_table varied_metrics],
+        "hhea" => %i[update_hhea_table font_metrics],
+        "OS/2" => %i[update_os2_table font_metrics],
+        "head" => %i[update_head_table options],
+      }.freeze
+
       private
 
-      # Collect all tables for static font
-      #
-      # @param varied_metrics [Hash] Varied glyph metrics
-      # @param font_metrics [Hash] Varied font metrics
-      # @param options [Hash] Build options
-      # @return [Hash<String, String>] Map of table tag to binary data
       def collect_tables(varied_metrics, font_metrics, options)
         tables = {}
 
         # Get all table tags from font
-        table_tags = @font.respond_to?(:tables) ? @font.tables.keys : []
+        table_tags = @font.is_a?(SfntSource) ? @font.table_names : []
 
         table_tags.each do |tag|
           # Skip variation tables
@@ -88,17 +91,14 @@ options = {})
           next if original_data.nil? || original_data.empty?
 
           # Update specific tables with varied data
-          tables[tag] = case tag
-                        when "hmtx"
-                          update_hmtx_table(original_data, varied_metrics)
-                        when "hhea"
-                          update_hhea_table(original_data, font_metrics)
-                        when "OS/2"
-                          update_os2_table(original_data, font_metrics)
-                        when "head"
-                          update_head_table(original_data, options)
+          updater = TABLE_UPDATERS[tag]
+          tables[tag] = if updater
+                          method_name, ctx_key = updater
+                          ctx = { varied_metrics: varied_metrics,
+                                  font_metrics: font_metrics,
+                                  options: options }
+                          method(method_name).call(original_data, ctx[ctx_key])
                         else
-                          # Copy unchanged
                           original_data
                         end
         end
@@ -182,12 +182,8 @@ options = {})
         data = @font.table_data(tag)
         return nil if data.nil? || data.empty?
 
-        table_class = case tag
-                      when "hhea" then Tables::Hhea
-                      when "maxp" then Tables::Maxp
-                      when "head" then Tables::Head
-                      else return nil
-                      end
+        table_class = Tables::Registry.for(tag)
+        return nil unless table_class
 
         table_class.read(data)
       rescue StandardError

data/lib/fontisan/variation/instance_font_wrapper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Fontisan
+  module Variation
+    # Wraps a variable font to substitute specific table tags with
+    # instance-generated equivalents while forwarding everything else
+    # to the original font. Used by VariableSvgGenerator to feed the
+    # SVG generator an instance-shaped font without rewriting it.
+    #
+    # Delegation uses SimpleDelegator so the wrapper is transparent:
+    # the original font's interface is preserved verbatim. Only
+    # #has_table? is overridden to also report instance-supplied tags.
+    #
+    # NOTE: #table currently delegates to the original font for any tag
+    # not in the instance map. The previous implementation always
+    # delegated regardless of @table_data contents, which SvgGenerator
+    # depended on (it expects parsed BinData records, not raw bytes).
+    # Until SvgGenerator can consume raw instance bytes, this wrapper
+    # preserves that behavior. The @table_data map is still exposed so
+    # downstream code that wants the raw bytes can read them.
+    class InstanceFontWrapper < SimpleDelegator
+      # @return [Hash<String, String>] instance-generated table bytes by tag
+      attr_reader :table_data
+
+      # @param original_font [TrueTypeFont, OpenTypeFont] the variable font
+      # @param instance_tables [Hash<String, String>] instance-generated bytes
+      def initialize(original_font, instance_tables)
+        super(original_font)
+        @table_data = instance_tables
+      end
+
+      # @param tag [String] table tag
+      # @return [Boolean]
+      def has_table?(tag)
+        @table_data.key?(tag) || __getobj__.has_table?(tag)
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instance_writer.rb

@@ -251,24 +251,26 @@ module Fontisan
       # Parse table data into table object
       #
       # @param tag [String] Table tag
-      # @param data [String] Table binary data
-      # @return [Object] Parsed table object
+      public
+
+      # Per-tag table parser dispatch. Each entry maps tag → [class, init_mode].
+      # :parse means call obj.parse(data); :data= means call obj.data = data.
+      TABLE_PARSERS = {
+        "head" => [Tables::Head, :parse],
+        "maxp" => [Tables::Maxp, :parse],
+        "loca" => [Tables::Loca, :data_assign],
+        "glyf" => [Tables::Glyf, :data_assign],
+        "CFF " => [Tables::Cff, :parse],
+        "CFF2" => [Tables::Cff2, :parse],
+      }.freeze
+
       def parse_table(tag, data)
-        # For OutlineConverter, we need head, maxp, loca, glyf for TTF
-        # and CFF for OTF
-        case tag
-        when "head"
-          Tables::Head.new.tap { |t| t.parse(data) }
-        when "maxp"
-          Tables::Maxp.new.tap { |t| t.parse(data) }
-        when "loca"
-          Tables::Loca.new.tap { |t| t.data = data }
-        when "glyf"
-          Tables::Glyf.new.tap { |t| t.data = data }
-        when "CFF "
-          Tables::Cff.new.tap { |t| t.parse(data) }
-        when "CFF2"
-          Tables::Cff2.new.tap { |t| t.parse(data) }
+        entry = TABLE_PARSERS[tag]
+        if entry
+          klass, init_mode = entry
+          obj = klass.new
+          init_mode == :parse ? obj.parse(data) : obj.data = data
+          obj
         else
           # For other tables, return a simple object that just holds data
           Object.new.tap do |obj|

data/lib/fontisan/variation/metrics_adjuster.rb

@@ -213,26 +213,23 @@ module Fontisan
         end
       end
 
-      # Get base metric value by tag
-      #
-      # @param tag [String] Metric tag (e.g., "hasc", "hdsc")
-      # @return [Integer, nil] Base metric value
+      public
+
+      # Maps MVAR metric tags to [table_tag, method] for base value lookup.
+      METRIC_SOURCES = {
+        "hasc" => ["hhea", :ascender],
+        "hdsc" => ["hhea", :descender],
+        "hlgp" => ["hhea", :line_gap],
+        "xhgt" => ["OS/2", :sx_height],
+        "cpht" => ["OS/2", :s_cap_height],
+      }.freeze
+
       def get_base_metric_value(tag)
-        case tag
-        when "hasc"
-          variation_table("hhea")&.ascender
-        when "hdsc"
-          variation_table("hhea")&.descender
-        when "hlgp"
-          variation_table("hhea")&.line_gap
-        when "xhgt"
-          os2 = variation_table("OS/2")
-          os2&.s_x_height if os2.respond_to?(:s_x_height)
-        when "cpht"
-          os2 = variation_table("OS/2")
-          os2&.s_cap_height if os2.respond_to?(:s_cap_height)
-          # Add more metrics as needed
-        end
+        source = METRIC_SOURCES[tag]
+        return nil unless source
+
+        table_tag, method = source
+        variation_table(table_tag)&.public_send(method)
       end
 
       # Update font metric in appropriate table
@@ -307,7 +304,7 @@ module Fontisan
         return unless hhea
 
         # Update the field if hhea supports it
-        hhea.number_of_h_metrics = count if hhea.respond_to?(:number_of_h_metrics=)
+        hhea.number_of_h_metrics = count
       end
     end
   end

data/lib/fontisan/variation/validator.rb

@@ -103,11 +103,9 @@ module Fontisan
         # Check CFF2 if present
         if @font.has_table?("CFF2")
           cff2 = @font.table("CFF2")
-          if cff2.respond_to?(:num_axes)
-            cff2_axes = cff2.num_axes || 0
-            if cff2_axes != axis_count && cff2_axes.positive?
-              @errors << "CFF2 axis count (#{cff2_axes}) doesn't match fvar (#{axis_count})"
-            end
+          cff2_axes = cff2&.num_axes || 0
+          if cff2_axes != axis_count && cff2_axes.positive?
+            @errors << "CFF2 axis count (#{cff2_axes}) doesn't match fvar (#{axis_count})"
           end
         end
 
@@ -133,20 +131,17 @@ module Fontisan
         return unless @font.has_table?(table_tag)
 
         table = @font.table(table_tag)
-        return unless table.respond_to?(:item_variation_store)
-
-        store = table.item_variation_store
+        store = table&.item_variation_store
         return unless store
 
-        # Check region list axis count
-        if store.respond_to?(:region_list) && store.region_list
-          region_list = store.region_list
-          if region_list.respond_to?(:axis_count)
-            region_axes = region_list.axis_count
-            if region_axes != expected_axes
-              @errors << "#{table_tag} region axis count (#{region_axes}) doesn't match fvar (#{expected_axes})"
-            end
-          end
+        region_list = store.variation_region_list
+        return unless region_list
+
+        region_axes = region_list.axis_count
+        return unless region_axes
+
+        if region_axes != expected_axes
+          @errors << "#{table_tag} region axis count (#{region_axes}) doesn't match fvar (#{expected_axes})"
         end
       end
 
@@ -195,24 +190,15 @@ module Fontisan
         hvar = @font.table("HVAR")
         return unless hvar
 
-        # Check for item_variation_store
-        unless hvar.respond_to?(:item_variation_store)
-          @warnings << "HVAR table doesn't support item_variation_store"
-          return
-        end
-
         store = hvar.item_variation_store
         unless store
           @warnings << "HVAR has no item variation store"
           return
         end
 
-        # Check that variation data exists
-        if store.respond_to?(:item_variation_data)
-          data = store.item_variation_data
-          if data.nil? || data.empty?
-            @warnings << "HVAR has no variation data"
-          end
+        data = store.item_variation_data_entries
+        if data.nil? || data.empty?
+          @warnings << "HVAR has no variation data"
         end
       rescue StandardError => e
         @warnings << "Failed to check HVAR delta integrity: #{e.message}"
@@ -272,24 +258,26 @@ module Fontisan
       # @param axes [Array] Variation axes
       def check_metrics_region_coverage(table_tag, axes)
         table = @font.table(table_tag)
-        return unless table.respond_to?(:item_variation_store)
+        return unless table
 
         store = table.item_variation_store
-        return unless store.respond_to?(:region_list)
+        return unless store
 
-        region_list = store.region_list
-        return unless region_list.respond_to?(:regions)
+        region_list = store.variation_region_list
+        return unless region_list
 
-        # Check each region
         regions = region_list.regions
-        regions.each_with_index do |region, idx|
-          next unless region.respond_to?(:region_axes)
+        return unless regions
+
+        # Each region is an Array<RegionAxisCoordinates>; check coords
+        # are within the valid [-1, 1] normalized range.
+        regions.each_with_index do |region_axis_coords, idx|
+          next unless region_axis_coords.is_a?(Array)
 
-          region.region_axes.each_with_index do |reg_axis, axis_idx|
+          region_axis_coords.each_with_index do |reg_axis, axis_idx|
             next if axis_idx >= axes.length
             next unless reg_axis
 
-            # Check coordinates are in valid range [-1, 1]
             coords = {
               start_coord: reg_axis.start_coord,
               peak_coord: reg_axis.peak_coord,

data/lib/fontisan/variation/variable_svg_generator.rb

@@ -178,8 +178,6 @@ module Fontisan
       # @param tables [Hash<String, String>] Font tables
       # @return [Object] Font-like object
       def build_font_from_tables(tables)
-        # Create a simple font wrapper that implements the minimal
-        # interface needed by SvgGenerator
         InstanceFontWrapper.new(@font, tables)
       end
 
@@ -214,52 +212,6 @@ module Fontisan
         end
         coords
       end
-
-      # Wrapper class for instance font tables
-      #
-      # Provides minimal interface needed by SvgGenerator while using
-      # instance tables instead of original font tables.
-      class InstanceFontWrapper
-        # @return [Hash<String, String>] Font tables
-        attr_reader :table_data
-
-        # Initialize wrapper
-        #
-        # @param original_font [Object] Original variable font
-        # @param instance_tables [Hash<String, String>] Instance tables
-        def initialize(original_font, instance_tables)
-          @original_font = original_font
-          @table_data = instance_tables
-        end
-
-        # Get table by tag
-        #
-        # @param tag [String] Table tag
-        # @return [Object, nil] Table or nil
-        def table(tag)
-          # Use instance table if available, otherwise fall back to original
-          if @table_data.key?(tag)
-          end
-          @original_font.table(tag)
-        end
-
-        # Check if table exists
-        #
-        # @param tag [String] Table tag
-        # @return [Boolean] True if table exists
-        def has_table?(tag)
-          @table_data.key?(tag) || @original_font.has_table?(tag)
-        end
-
-        # Forward other methods to original font
-        def method_missing(method, ...)
-          @original_font.send(method, ...)
-        end
-
-        def respond_to_missing?(method, include_private = false)
-          @original_font.respond_to?(method, include_private) || super
-        end
-      end
     end
   end
 end

data/lib/fontisan/variation/variation_preserver.rb

@@ -148,10 +148,9 @@ module Fontisan
       def validate_source!
         raise ArgumentError, "Source font cannot be nil" if @source_font.nil?
 
-        unless @source_font.respond_to?(:has_table?) &&
-            @source_font.respond_to?(:table_data)
+        unless @source_font.is_a?(SfntSource)
           raise ArgumentError,
-                "Source font must respond to :has_table? and :table_data"
+                "Source font must be an SfntSource instance"
         end
 
         if @target_tables.nil?

data/lib/fontisan/variation.rb

@@ -13,6 +13,7 @@ module Fontisan
     autoload :DeltaParser, "fontisan/variation/delta_parser"
     autoload :Inspector, "fontisan/variation/inspector"
     autoload :InstanceGenerator, "fontisan/variation/instance_generator"
+    autoload :InstanceFontWrapper, "fontisan/variation/instance_font_wrapper"
     autoload :InstanceWriter, "fontisan/variation/instance_writer"
     autoload :Interpolator, "fontisan/variation/interpolator"
     autoload :MetricsAdjuster, "fontisan/variation/metrics_adjuster"

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/sfnt_checksum.rb

@@ -79,7 +79,7 @@ module Fontisan
         offsets = {}
         @tables.each do |t|
           offsets[t.tag] = cursor
-          cursor += Utilities::Padding.aligned_size(t.bytes)
+          cursor += Utilities::Padding.aligned_size(t.bytes.bytesize)
         end
 
         bytes = String.new(encoding: Encoding::BINARY)

data/lib/fontisan/woff2/table_transformer.rb

@@ -32,41 +32,34 @@ module Fontisan
       #
       # @param tag [String] Table tag
       # @return [String, nil] Transformed table data
+      # Per-tag transform method dispatch.
+      TRANSFORM_DISPATCH = {
+        "glyf" => :transform_glyf,
+        "loca" => :transform_loca,
+        "hmtx" => :transform_hmtx,
+      }.freeze
+
+      # Per-tag transform version constant.
+      TRANSFORM_VERSIONS = {
+        "glyf" => Directory::TRANSFORM_GLYF_LOCA,
+        "loca" => Directory::TRANSFORM_GLYF_LOCA,
+        "hmtx" => Directory::TRANSFORM_HMTX,
+      }.freeze
+
       def transform_table(tag)
-        case tag
-        when "glyf"
-          transform_glyf
-        when "loca"
-          transform_loca
-        when "hmtx"
-          transform_hmtx
-        else
-          # No transformation, return original data
-          get_table_data(tag)
-        end
+        transform_method = TRANSFORM_DISPATCH[tag]
+        return method(transform_method).call if transform_method
+
+        # No transformation, return original data
+        get_table_data(tag)
       end
 
-      # Check if a table can be transformed
-      #
-      # @param tag [String] Table tag
-      # @return [Boolean] True if table supports transformation
       def transformable?(tag)
-        %w[glyf loca hmtx].include?(tag)
+        TRANSFORM_DISPATCH.key?(tag)
       end
 
-      # Determine transformation version for a table
-      #
-      # @param tag [String] Table tag
-      # @return [Integer] Transformation version
       def transformation_version(tag)
-        case tag
-        when "glyf", "loca"
-          Directory::TRANSFORM_GLYF_LOCA
-        when "hmtx"
-          Directory::TRANSFORM_HMTX
-        else
-          Directory::TRANSFORM_NONE
-        end
+        TRANSFORM_VERSIONS.fetch(tag, Directory::TRANSFORM_NONE)
       end
 
       private
@@ -150,7 +143,7 @@ module Fontisan
       # @param tag [String] Table tag
       # @return [String, nil] Table data or nil if not found
       def get_table_data(tag)
-        return nil unless font.respond_to?(:table_data)
+        return nil unless font.is_a?(SfntSource)
 
         font.table_data[tag]
       end