fontisan 0.4.42 → 0.4.44

data/lib/fontisan/ufo/bounds.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Immutable axis-aligned bounding box over outline points.
+    #
+    # Bounds is a value object: equality and hash are based on the four
+    # coordinates, not identity. Bounds composes via #union so callers
+    # can fold bounds across many contours or many glyphs without
+    # mutating either side.
+    class Bounds
+      include Comparable
+
+      attr_reader :min_x, :min_y, :max_x, :max_y
+
+      def initialize(min_x:, min_y:, max_x:, max_y:)
+        @min_x = min_x.to_f
+        @min_y = min_y.to_f
+        @max_x = max_x.to_f
+        @max_y = max_y.to_f
+      end
+
+      # @param contours [Array<Contour>, Enumerable<Contour>]
+      # @return [Bounds]
+      def self.measure(contours)
+        min_x = min_y = +Float::INFINITY
+        max_x = max_y = -Float::INFINITY
+        saw_point = false
+
+        contours.each do |contour|
+          contour.points.each do |pt|
+            saw_point = true
+            min_x = pt.x if pt.x < min_x
+            min_y = pt.y if pt.y < min_y
+            max_x = pt.x if pt.x > max_x
+            max_y = pt.y if pt.y > max_y
+          end
+        end
+
+        return empty unless saw_point
+
+        new(min_x: min_x, min_y: min_y, max_x: max_x, max_y: max_y)
+      end
+
+      # @return [Bounds] zero-extent bounds anchored at the origin
+      def self.empty
+        new(min_x: 0, min_y: 0, max_x: 0, max_y: 0)
+      end
+
+      def width
+        max_x - min_x
+      end
+
+      def height
+        max_y - min_y
+      end
+
+      # A bounds is empty when it has zero extent in both axes. Note that
+      # a contour containing a single point yields zero-extent bounds but
+      # is not "empty" in the geometric sense — callers that need to
+      # distinguish should test the contour directly.
+      def empty?
+        width.zero? && height.zero?
+      end
+
+      # Smallest bounds containing both self and other.
+      #
+      # @param other [Bounds]
+      # @return [Bounds]
+      def union(other)
+        self.class.new(
+          min_x: [@min_x, other.min_x].min,
+          min_y: [@min_y, other.min_y].min,
+          max_x: [@max_x, other.max_x].max,
+          max_y: [@max_y, other.max_y].max,
+        )
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(Bounds)
+
+        [@min_x, @min_y, @max_x, @max_y] <=>
+          [other.min_x, other.min_y, other.max_x, other.max_y]
+      end
+
+      def hash
+        [@min_x, @min_y, @max_x, @max_y].hash
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/fvar.rb

@@ -20,8 +20,8 @@ module Fontisan
         # @param instances [Array<Hash>] named instance definitions
         # @return [String, nil] fvar table bytes, or nil if no axes
         def self.build(font, axes: nil, instances: nil)
-          axes ||= font.info.respond_to?(:axes) ? font.info.axes : nil
-          instances ||= font.info.respond_to?(:named_instances) ? font.info.named_instances : nil
+          axes ||= font.info.axes
+          instances ||= font.info.named_instances
 
           axes ||= []
           return nil if axes.empty?

data/lib/fontisan/ufo/contour.rb

@@ -24,6 +24,11 @@ module Fontisan
       def point_count
         @points.size
       end
+
+      # @return [Bounds] extents of this contour's points
+      def bounds
+        Bounds.measure([self])
+      end
     end
   end
 end

data/lib/fontisan/ufo/convert/from_bin_data.rb

@@ -61,8 +61,7 @@ module Fontisan
           name_table = font.table("name")
           return unless name_table
 
-          records = name_table.respond_to?(:name_records) ? name_table.name_records : []
-          records.each do |record|
+          name_table.name_records.each do |record|
             next unless record.platform_id == 3 && record.encoding_id == 1 # Windows Unicode BMP
 
             value = decode_name_value(record, name_table)
@@ -79,9 +78,7 @@ module Fontisan
         end
 
         def self.decode_name_value(record, name_table)
-          raw = if name_table.respond_to?(:string_for_record)
-                  name_table.string_for_record(record)
-                end
+          raw = name_table.string_for_record(record)
 
           if raw && raw.encoding == Encoding::UTF_16BE
             raw.encode("UTF-8")
@@ -100,12 +97,7 @@ module Fontisan
           post = font.table("post")
           return unless post
 
-          if post.respond_to?(:italic_angle)
-            info.italic_angle = post.italic_angle
-          elsif post.respond_to?(:italic_angle_raw)
-            raw = post.italic_angle_raw
-            info.italic_angle = raw.to_i / 65536.0
-          end
+          info.italic_angle = post.italic_angle
         rescue NoMethodError
           # post table may not have italic_angle
         end
@@ -128,7 +120,7 @@ module Fontisan
           cmap_table = font.table("cmap")
           return {} unless cmap_table
 
-          mappings = cmap_table.respond_to?(:unicode_mappings) ? cmap_table.unicode_mappings : {}
+          mappings = cmap_table.unicode_mappings || {}
           # Invert: gid → [codepoints]
           inverted = Hash.new { |h, k| h[k] = [] }
           mappings.each { |cp, gid| inverted[gid] << cp }
@@ -146,13 +138,11 @@ module Fontisan
           num_glyphs = maxp&.num_glyphs || 0
 
           # Hmtx requires context-aware parsing before metric_for works.
-          if hmtx.respond_to?(:parse_with_context)
-            hmtx.parse_with_context(num_h_metrics, num_glyphs)
-          end
+          hmtx.parse_with_context(num_h_metrics, num_glyphs)
 
           widths = {}
           num_glyphs.times do |gid|
-            metric = hmtx.respond_to?(:metric_for) ? hmtx.metric_for(gid) : nil
+            metric = hmtx.metric_for(gid)
             widths[gid] = metric ? metric[:advance_width] : 0
           end
           widths
@@ -169,10 +159,8 @@ module Fontisan
           return unless glyf && loca && head
 
           # Tables need context-aware initialization before per-glyph access.
-          if loca.respond_to?(:parse_with_context)
-            loca.parse_with_context(head.index_to_loc_format,
-                                    num_glyphs)
-          end
+          loca.parse_with_context(head.index_to_loc_format,
+                                  num_glyphs)
 
           num_glyphs.times do |gid|
             glyph_name = glyph_name_for(font, gid) || "glyph#{gid}"
@@ -189,7 +177,7 @@ module Fontisan
 
             if simple.is_a?(Fontisan::Tables::SimpleGlyph)
               extract_simple_contours(simple, ufo_glyph)
-            elsif simple.respond_to?(:compound?) && simple.compound?
+            elsif simple.is_a?(Fontisan::Tables::CompoundGlyph) && simple.compound?
               extract_compound_contours(simple, ufo_glyph, glyf, loca, head)
             end
 
@@ -309,7 +297,7 @@ module Fontisan
           visited = visited.dup.add(compound.glyph_id)
 
           compound.components.each do |component|
-            next unless component.respond_to?(:args_are_xy?) ? component.args_are_xy? : true
+            next unless component.args_are_xy?
 
             raw = begin
               glyf.glyph_for(component.glyph_index, loca, head)
@@ -320,9 +308,9 @@ module Fontisan
 
             matrix = component.transformation_matrix
 
-            if raw.respond_to?(:simple?) && raw.simple?
+            if raw.is_a?(Fontisan::Tables::SimpleGlyph) && raw.simple?
               flatten_simple_component(raw, ufo_glyph, matrix)
-            elsif raw.respond_to?(:compound?) && raw.compound?
+            elsif raw.is_a?(Fontisan::Tables::CompoundGlyph) && raw.compound?
               flatten_compound(raw, ufo_glyph, glyf, loca, head, visited, depth + 1)
             end
           end
@@ -358,12 +346,10 @@ module Fontisan
           post = font.table("post")
           return nil unless post
 
-          if post.respond_to?(:glyph_name)
-            name = post.glyph_name(gid)
-            return name unless name.nil? || name.empty?
-          end
+          name = post.glyph_name(gid)
+          return nil if name.nil? || name.empty?
 
-          nil
+          name
         rescue NoMethodError
           nil
         end

data/lib/fontisan/ufo/info.rb

@@ -26,6 +26,10 @@ module Fontisan
 
       attr_accessor(*STANDARD_FIELDS)
 
+      # Variation font metadata. Populated by UFO 3 extensions or by
+      # explicit compiler configuration; nil when not set.
+      attr_accessor :axes, :named_instances
+
       # Catch-all for non-standard (vendor-specific) fields.
       attr_accessor :extras
 

data/lib/fontisan/ufo/point.rb

@@ -27,13 +27,6 @@ module Fontisan
       def off_curve?
         @type == "offcurve" || @type == "qcurve"
       end
-
-      # @return [Hash] suitable for `to_glif` output
-      def to_h
-        h = { x: @x, y: @y, type: @type }
-        h[:smooth] = true if @smooth
-        h
-      end
     end
   end
 end

data/lib/fontisan/ufo.rb

@@ -24,6 +24,7 @@ module Fontisan
     autoload :LayerSet,    "fontisan/ufo/layer_set"
     autoload :Glyph,       "fontisan/ufo/glyph"
     autoload :Contour,     "fontisan/ufo/contour"
+    autoload :Bounds,      "fontisan/ufo/bounds"
     autoload :Point,       "fontisan/ufo/point"
     autoload :Component,   "fontisan/ufo/component"
     autoload :Anchor,      "fontisan/ufo/anchor"

data/lib/fontisan/utilities/brotli_wrapper.rb

@@ -129,13 +129,11 @@ module Fontisan
         # @param data [String] Data to validate
         # @raise [ArgumentError] If data is invalid
         def validate_data!(data)
-          if data.nil?
-            raise ArgumentError, "Data cannot be nil"
-          end
+          raise ArgumentError, "Data cannot be nil" if data.nil?
 
-          unless data.respond_to?(:bytesize)
+          unless data.is_a?(String)
             raise ArgumentError,
-                  "Data must be a String-like object, got #{data.class}"
+                  "Data must be a String, got #{data.class}"
           end
         end
       end

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