fontisan 0.1.0 → 0.2.1

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/variable/axis_normalizer.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Fontisan
+  module Variable
+    # Normalizes user coordinates to design space
+    #
+    # Converts user-provided axis coordinates (e.g., wght=700) to normalized
+    # values in the range -1.0 to 1.0 based on axis definitions from the fvar table.
+    #
+    # The normalization algorithm follows the OpenType specification:
+    # - For values below default: normalized = (value - default) / (default - min)
+    # - For values above default: normalized = (value - default) / (max - default)
+    # - Values are clamped to the -1.0 to 1.0 range
+    #
+    # @example Normalize coordinates
+    #   normalizer = AxisNormalizer.new(fvar_table)
+    #   normalized = normalizer.normalize({ "wght" => 700, "wdth" => 100 })
+    #   # => { "wght" => 0.5, "wdth" => 0.0 }
+    class AxisNormalizer
+      # @return [Hash] Configuration settings
+      attr_reader :config
+
+      # @return [Hash] Axis definitions from fvar table
+      attr_reader :axes
+
+      # Initialize the normalizer
+      #
+      # @param fvar [Fontisan::Tables::Fvar] Font variations table
+      # @param config [Hash] Optional configuration overrides
+      def initialize(fvar, config = {})
+        @fvar = fvar
+        @config = load_config.merge(config)
+        @axes = build_axis_map
+      end
+
+      # Normalize user coordinates to design space
+      #
+      # @param user_coords [Hash<String, Numeric>] User coordinates by axis tag
+      # @return [Hash<String, Float>] Normalized coordinates (-1.0 to 1.0)
+      def normalize(user_coords)
+        result = {}
+
+        @axes.each do |tag, axis_info|
+          user_value = user_coords[tag] || user_coords[tag.to_sym]
+
+          # Use default if not provided and config allows
+          if user_value.nil?
+            user_value = if @config.dig(:coordinate_normalization,
+                                        :use_axis_defaults)
+                           axis_info[:default]
+                         else
+                           next
+                         end
+          end
+
+          # Validate and clamp if configured
+          validated_value = validate_coordinate(user_value, axis_info)
+
+          # Normalize the value
+          normalized = normalize_value(validated_value, axis_info)
+
+          result[tag] = normalized
+        end
+
+        result
+      end
+
+      # Normalize a single axis value
+      #
+      # @param value [Numeric] User coordinate value
+      # @param axis_tag [String] Axis tag
+      # @return [Float] Normalized value (-1.0 to 1.0)
+      def normalize_axis(value, axis_tag)
+        axis_info = @axes[axis_tag]
+        raise ArgumentError, "Unknown axis: #{axis_tag}" unless axis_info
+
+        validated_value = validate_coordinate(value, axis_info)
+        normalize_value(validated_value, axis_info)
+      end
+
+      # Get axis information
+      #
+      # @param axis_tag [String] Axis tag
+      # @return [Hash, nil] Axis information or nil
+      def axis_info(axis_tag)
+        @axes[axis_tag]
+      end
+
+      # Get all axis tags
+      #
+      # @return [Array<String>] Array of axis tags
+      def axis_tags
+        @axes.keys
+      end
+
+      private
+
+      # Load configuration from YAML file
+      #
+      # @return [Hash] Configuration hash
+      def load_config
+        config_path = File.join(__dir__, "..", "config",
+                                "variable_settings.yml")
+        loaded = YAML.load_file(config_path)
+        # Convert string keys to symbol keys for consistency
+        deep_symbolize_keys(loaded)
+      rescue StandardError
+        # Return default config if file doesn't exist
+        {
+          coordinate_normalization: {
+            normalize: true,
+            use_axis_defaults: true,
+            normalized_precision: 6,
+          },
+          delta_application: {
+            validate_coordinates: true,
+            clamp_coordinates: true,
+          },
+        }
+      end
+
+      # Recursively convert hash keys to symbols
+      #
+      # @param hash [Hash] Hash with string keys
+      # @return [Hash] Hash with symbol keys
+      def deep_symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.to_sym
+          new_value = value.is_a?(Hash) ? deep_symbolize_keys(value) : value
+          result[new_key] = new_value
+        end
+      end
+
+      # Build axis information map from fvar table
+      #
+      # @return [Hash<String, Hash>] Map of axis tag to axis info
+      def build_axis_map
+        return {} unless @fvar
+
+        @fvar.axes.each_with_object({}) do |axis, hash|
+          # Convert BinData::String to regular Ruby String for proper Hash key behavior
+          tag = axis.axis_tag.to_s
+          hash[tag] = {
+            min: axis.min_value,
+            default: axis.default_value,
+            max: axis.max_value,
+            name_id: axis.axis_name_id,
+          }
+        end
+      end
+
+      # Validate and optionally clamp coordinate value
+      #
+      # @param value [Numeric] User coordinate value
+      # @param axis_info [Hash] Axis information
+      # @return [Float] Validated value
+      def validate_coordinate(value, axis_info)
+        value = value.to_f
+
+        # Check if validation is enabled
+        if @config.dig(:delta_application, :validate_coordinates)
+          min = axis_info[:min]
+          max = axis_info[:max]
+
+          # Clamp if configured
+          if @config.dig(:delta_application, :clamp_coordinates)
+            value = [[value, min].max, max].min
+          elsif value < min || value > max
+            raise ArgumentError,
+                  "Coordinate #{value} out of range [#{min}, #{max}]"
+          end
+        end
+
+        value
+      end
+
+      # Normalize a value to -1.0 to 1.0 range
+      #
+      # @param value [Float] User coordinate value
+      # @param axis_info [Hash] Axis information
+      # @return [Float] Normalized value
+      def normalize_value(value, axis_info)
+        default = axis_info[:default]
+
+        # Value at default is always 0.0
+        return 0.0 if (value - default).abs < Float::EPSILON
+
+        if value < default
+          # Below default: negative range
+          min = axis_info[:min]
+          range = default - min
+
+        else
+          # Above default: positive range
+          max = axis_info[:max]
+          range = max - default
+
+        end
+        return 0.0 if range.abs < Float::EPSILON
+
+        normalized = (value - default) / range
+
+        # Clamp to -1.0 to 1.0
+        normalized = [[-1.0, normalized].max, 1.0].min
+
+        # Apply precision
+        precision = @config.dig(:coordinate_normalization,
+                                :normalized_precision) || 6
+        normalized.round(precision)
+      end
+    end
+  end
+end