fontisan 0.2.0 → 0.2.2

data/lib/fontisan/validation/variable_font_validator.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Validation
+    # VariableFontValidator validates variable font structure
+    #
+    # Validates:
+    # - fvar table structure
+    # - Axis definitions and ranges
+    # - Instance definitions
+    # - Variation table consistency
+    # - Metrics variation tables
+    #
+    # @example Validate a variable font
+    #   validator = VariableFontValidator.new(font)
+    #   errors = validator.validate
+    #   puts "Found #{errors.length} errors" if errors.any?
+    class VariableFontValidator
+      # Initialize validator with font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to validate
+      def initialize(font)
+        @font = font
+        @errors = []
+      end
+
+      # Validate variable font
+      #
+      # @return [Array<String>] Array of error messages
+      def validate
+        return [] unless @font.has_table?("fvar")
+
+        validate_fvar_structure
+        validate_axes
+        validate_instances
+        validate_variation_tables
+        validate_metrics_variation
+
+        @errors
+      end
+
+      private
+
+      # Validate fvar table structure
+      #
+      # @return [void]
+      def validate_fvar_structure
+        fvar = @font.table("fvar")
+        return unless fvar
+
+        if !fvar.respond_to?(:axes) || fvar.axes.nil? || fvar.axes.empty?
+          @errors << "fvar: No axes defined"
+          return
+        end
+
+        if fvar.respond_to?(:axis_count) && fvar.axis_count != fvar.axes.length
+          @errors << "fvar: Axis count mismatch (expected #{fvar.axis_count}, got #{fvar.axes.length})"
+        end
+      end
+
+      # Validate all axes
+      #
+      # @return [void]
+      def validate_axes
+        fvar = @font.table("fvar")
+        return unless fvar.respond_to?(:axes)
+
+        fvar.axes.each_with_index do |axis, index|
+          validate_axis_range(axis, index)
+          validate_axis_tag(axis, index)
+        end
+      end
+
+      # Validate axis range values
+      #
+      # @param axis [Object] Axis object
+      # @param index [Integer] Axis index
+      # @return [void]
+      def validate_axis_range(axis, index)
+        return unless axis.respond_to?(:min_value) && axis.respond_to?(:max_value)
+
+        if axis.min_value > axis.max_value
+          tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{index}"
+          @errors << "Axis #{tag}: min_value (#{axis.min_value}) > max_value (#{axis.max_value})"
+        end
+
+        if axis.respond_to?(:default_value) && (axis.default_value < axis.min_value || axis.default_value > axis.max_value)
+          tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{index}"
+          @errors << "Axis #{tag}: default_value (#{axis.default_value}) out of range [#{axis.min_value}, #{axis.max_value}]"
+        end
+      end
+
+      # Validate axis tag format
+      #
+      # @param axis [Object] Axis object
+      # @param index [Integer] Axis index
+      # @return [void]
+      def validate_axis_tag(axis, index)
+        return unless axis.respond_to?(:axis_tag)
+
+        tag = axis.axis_tag
+        unless tag.is_a?(String) && tag.length == 4 && tag =~ /^[a-zA-Z]{4}$/
+          @errors << "Axis #{index}: invalid tag '#{tag}' (must be 4 ASCII letters)"
+        end
+      end
+
+      # Validate named instances
+      #
+      # @return [void]
+      def validate_instances
+        fvar = @font.table("fvar")
+        return unless fvar.respond_to?(:instances)
+        return unless fvar.instances
+
+        fvar.instances.each_with_index do |instance, idx|
+          validate_instance_coordinates(instance, idx, fvar)
+        end
+      end
+
+      # Validate instance coordinates
+      #
+      # @param instance [Object] Instance object
+      # @param idx [Integer] Instance index
+      # @param fvar [Object] fvar table
+      # @return [void]
+      def validate_instance_coordinates(instance, idx, fvar)
+        return unless instance.is_a?(Hash) && instance[:coordinates]
+
+        coords = instance[:coordinates]
+        axis_count = fvar.respond_to?(:axis_count) ? fvar.axis_count : fvar.axes.length
+
+        if coords.length != axis_count
+          @errors << "Instance #{idx}: coordinate count mismatch (expected #{axis_count}, got #{coords.length})"
+        end
+
+        coords.each_with_index do |value, axis_idx|
+          next if axis_idx >= fvar.axes.length
+
+          axis = fvar.axes[axis_idx]
+          next unless axis.respond_to?(:min_value) && axis.respond_to?(:max_value)
+
+          if value < axis.min_value || value > axis.max_value
+            tag = axis.respond_to?(:axis_tag) ? axis.axis_tag : "axis #{axis_idx}"
+            @errors << "Instance #{idx}: coordinate for #{tag} (#{value}) out of range [#{axis.min_value}, #{axis.max_value}]"
+          end
+        end
+      end
+
+      # Validate variation tables
+      #
+      # @return [void]
+      def validate_variation_tables
+        has_gvar = @font.has_table?("gvar")
+        has_cff2 = @font.has_table?("CFF2")
+        has_glyf = @font.has_table?("glyf")
+        has_cff = @font.has_table?("CFF ")
+
+        # TrueType variable fonts should have gvar
+        if has_glyf && !has_gvar
+          @errors << "TrueType variable font missing gvar table"
+        end
+
+        # CFF variable fonts should have CFF2
+        if has_cff && !has_cff2
+          @errors << "CFF variable font missing CFF2 table"
+        end
+
+        # Can't have both gvar and CFF2
+        if has_gvar && has_cff2
+          @errors << "Font has both gvar and CFF2 tables (incompatible)"
+        end
+      end
+
+      # Validate metrics variation tables
+      #
+      # @return [void]
+      def validate_metrics_variation
+        validate_hvar if @font.has_table?("HVAR")
+        validate_vvar if @font.has_table?("VVAR")
+        validate_mvar if @font.has_table?("MVAR")
+      end
+
+      # Validate HVAR table
+      #
+      # @return [void]
+      def validate_hvar
+        # HVAR validation would go here
+        # For now, just check it exists
+        hvar = @font.table_data["HVAR"]
+        if hvar.nil? || hvar.empty?
+          @errors << "HVAR table is empty"
+        end
+      end
+
+      # Validate VVAR table
+      #
+      # @return [void]
+      def validate_vvar
+        # VVAR validation would go here
+        vvar = @font.table_data["VVAR"]
+        if vvar.nil? || vvar.empty?
+          @errors << "VVAR table is empty"
+        end
+      end
+
+      # Validate MVAR table
+      #
+      # @return [void]
+      def validate_mvar
+        # MVAR validation would go here
+        mvar = @font.table_data["MVAR"]
+        if mvar.nil? || mvar.empty?
+          @errors << "MVAR table is empty"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/cache.rb

@@ -44,6 +44,7 @@ module Fontisan
         @ttl = ttl
         @cache = {}
         @access_times = {}
+        @access_counter = 0
         @stats = {
           hits: 0,
           misses: 0,
@@ -219,7 +220,8 @@ module Fontisan
       #
       # @param key [String] Cache key
       def touch(key)
-        @access_times[key] = Time.now
+        @access_counter += 1
+        @access_times[key] = @access_counter
       end
 
       # Evict entries if cache is full

data/lib/fontisan/variation/converter.rb

@@ -24,13 +24,13 @@ module Fontisan
     # 4. Build gvar table structure
     #
     # @example Converting gvar to CFF2 blend
-    #   converter = VariationConverter.new(font, axes)
+    #   converter = Converter.new(font, axes)
     #   blend_data = converter.gvar_to_blend(glyph_id)
     #
     # @example Converting CFF2 blend to gvar
-    #   converter = VariationConverter.new(font, axes)
+    #   converter = Converter.new(font, axes)
     #   tuple_data = converter.blend_to_gvar(glyph_id)
-    class VariationConverter
+    class Converter
       include TableAccessor
 
       # @return [TrueTypeFont, OpenTypeFont] Font instance
@@ -72,19 +72,49 @@ module Fontisan
       #
       # @param glyph_id [Integer] Glyph ID
       # @return [Hash, nil] Tuple data or nil
-      def blend_to_gvar(_glyph_id)
+      def blend_to_gvar(glyph_id)
         return nil unless has_variation_table?("CFF2")
 
         cff2 = variation_table("CFF2")
         return nil unless cff2
 
         # Get CharString with blend operators
-        # This is a placeholder - full implementation would parse CharString
-        # and extract blend operator data
+        charstring = cff2.charstring_for_glyph(glyph_id)
+        return nil unless charstring
 
-        # Convert blend data to tuples
-        # Placeholder for full implementation
-        nil
+        # Parse CharString to extract blend data
+        charstring.parse unless charstring.instance_variable_get(:@parsed)
+        blend_data = charstring.blend_data
+        return nil if blend_data.nil? || blend_data.empty?
+
+        # Convert blend data to tuple format
+        convert_blend_to_tuples_for_glyph(blend_data)
+      end
+
+      # Convert all glyphs from gvar to blend format
+      #
+      # @param glyph_count [Integer] Number of glyphs
+      # @return [Hash<Integer, Hash>] Map of glyph_id to blend data
+      def convert_all_gvar_to_blend(glyph_count)
+        return {} unless can_convert?
+
+        (0...glyph_count).each_with_object({}) do |glyph_id, result|
+          blend_data = gvar_to_blend(glyph_id)
+          result[glyph_id] = blend_data if blend_data
+        end
+      end
+
+      # Convert all glyphs from blend to gvar format
+      #
+      # @param glyph_count [Integer] Number of glyphs
+      # @return [Hash<Integer, Hash>] Map of glyph_id to tuple data
+      def convert_all_blend_to_gvar(glyph_count)
+        return {} unless can_convert?
+
+        (0...glyph_count).each_with_object({}) do |glyph_id, result|
+          tuple_data = blend_to_gvar(glyph_id)
+          result[glyph_id] = tuple_data if tuple_data
+        end
       end
 
       # Check if variation data can be converted
@@ -99,6 +129,77 @@ module Fontisan
 
       private
 
+      # Convert blend data from a glyph to tuple format
+      #
+      # @param blend_data [Array<Hash>] Array of blend operations
+      # @return [Hash] Tuple variation data
+      def convert_blend_to_tuples_for_glyph(blend_data)
+        # Each blend operation represents variation at different points
+        # We need to aggregate these into region-based tuples
+
+        # Extract all regions from blend operations
+        regions_map = {}
+        point_count = 0
+
+        blend_data.each_with_index do |blend_op, idx|
+          blend_op[:blends].each do |blend|
+            # Track the maximum point index we've seen
+            point_count = [point_count, idx + 1].max
+
+            # For each delta axis, we need to create or update a region
+            blend[:deltas].each_with_index do |delta, axis_index|
+              next if delta.zero? # Skip zero deltas
+
+              # Create region key based on unique delta pattern
+              region_key = "region_#{axis_index}"
+
+              regions_map[region_key] ||= {
+                axis_index: axis_index,
+                deltas_per_point: Array.new(point_count) { { x: 0, y: 0 } },
+              }
+
+              # Store this delta for this point
+              # Note: CFF2 blend deltas are per-coordinate, we need to map to x/y
+              # This is a simplified mapping - full implementation would track
+              # which coordinates are being varied
+              regions_map[region_key][:deltas_per_point][idx / 2] ||= { x: 0,
+                                                                        y: 0 }
+              if idx.even?
+                regions_map[region_key][:deltas_per_point][idx / 2][:x] = delta
+              else
+                regions_map[region_key][:deltas_per_point][idx / 2][:y] = delta
+              end
+            end
+          end
+        end
+
+        # Convert regions to tuples
+        tuples = []
+        regions_map.each_value do |region_data|
+          axis_index = region_data[:axis_index]
+
+          # Build peak coordinates (one per axis)
+          peak = Array.new(@axes.length, 0.0)
+          peak[axis_index] = 1.0 if axis_index < @axes.length
+
+          # Build start/end (default full range)
+          start_vals = Array.new(@axes.length, -1.0)
+          end_vals = Array.new(@axes.length, 1.0)
+
+          tuples << {
+            peak: peak,
+            start: start_vals,
+            end: end_vals,
+            deltas: region_data[:deltas_per_point],
+          }
+        end
+
+        {
+          tuples: tuples,
+          point_count: point_count,
+        }
+      end
+
       # Convert tuple variations to blend format
       #
       # @param tuple_data [Hash] Tuple variation data from gvar
@@ -172,12 +273,19 @@ module Fontisan
       # @param tuple [Hash] Tuple data
       # @param point_count [Integer] Number of points
       # @return [Array<Hash>] Deltas with :x and :y
-      def parse_tuple_deltas(_tuple, point_count)
-        # This is a placeholder - full implementation would:
-        # 1. Parse delta data from tuple
+      def parse_tuple_deltas(tuple, point_count)
+        # If tuple has deltas array, use it
+        if tuple[:deltas].is_a?(Array)
+          return tuple[:deltas].map do |delta|
+            { x: delta[:x] || 0, y: delta[:y] || 0 }
+          end
+        end
+
+        # Otherwise return zeros (placeholder for parsing raw delta data)
+        # Full implementation would:
+        # 1. Parse delta data from tuple[:data]
         # 2. Decompress if needed
         # 3. Return array of { x: dx, y: dy } for each point
-
         Array.new(point_count) { { x: 0, y: 0 } }
       end
 

data/lib/fontisan/variation/delta_applier.rb

@@ -79,7 +79,8 @@ module Fontisan
         # Apply each active tuple's deltas
         adjusted_points = base_points.dup
         matches.each do |match|
-          apply_tuple_deltas(adjusted_points, match, tuple_data, base_points.length)
+          apply_tuple_deltas(adjusted_points, match, tuple_data,
+                             base_points.length)
         end
 
         adjusted_points

data/lib/fontisan/variation/inspector.rb

@@ -107,7 +107,8 @@ module Fontisan
             index: index,
             name: instance_name(instance[:subfamily_name_id]),
             postscript_name: instance_name(instance[:postscript_name_id]),
-            coordinates: instance_coordinates(instance[:coordinates], @context.axes),
+            coordinates: instance_coordinates(instance[:coordinates],
+                                              @context.axes),
           }
         end
       end

data/lib/fontisan/variation/instance_generator.rb

@@ -248,7 +248,8 @@ module Fontisan
       # @param scalars [Array<Float>] Region scalars
       # @return [Hash] Interpolated point
       def interpolate_point(base_point, delta_points, scalars)
-        @context.interpolator.interpolate_point(base_point, delta_points, scalars)
+        @context.interpolator.interpolate_point(base_point, delta_points,
+                                                scalars)
       end
 
       private