fontisan 0.1.0 → 0.2.0

data/lib/fontisan/validation/table_validator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Fontisan
+  module Validation
+    # TableValidator validates the presence and correctness of font tables
+    #
+    # This validator checks that all required tables are present in the font
+    # based on the font type (TrueType, OpenType/CFF, Variable) and validates
+    # table-specific properties like versioning.
+    #
+    # Single Responsibility: Table presence and table-level validation
+    #
+    # @example Validating tables
+    #   validator = TableValidator.new(rules)
+    #   issues = validator.validate(font)
+    class TableValidator
+      # Initialize table validator
+      #
+      # @param rules [Hash] Validation rules configuration
+      def initialize(rules)
+        @rules = rules
+        @required_tables = rules["required_tables"]
+      end
+
+      # Validate font tables
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
+      # @return [Array<Hash>] Array of validation issues
+      def validate(font)
+        issues = []
+
+        # Determine font type
+        font_type = determine_font_type(font)
+
+        # Check required tables based on font type
+        issues.concat(check_required_tables(font, font_type))
+
+        # Check table-specific validations if tables exist
+        issues.concat(check_table_versions(font)) if @rules["check_table_versions"]
+
+        issues
+      end
+
+      private
+
+      # Determine the font type
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] The font
+      # @return [Symbol] :truetype, :opentype_cff, or :variable
+      def determine_font_type(font)
+        if font.has_table?(Constants::FVAR_TAG)
+          :variable
+        elsif font.has_table?(Constants::CFF_TAG) || font.has_table?("CFF2")
+          :opentype_cff
+        else
+          :truetype
+        end
+      end
+
+      # Check that required tables are present
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] The font
+      # @param font_type [Symbol] The font type
+      # @return [Array<Hash>] Array of missing table issues
+      def check_required_tables(font, font_type)
+        issues = []
+
+        # Get required tables for this font type
+        required = @required_tables["all"].dup
+
+        case font_type
+        when :truetype
+          required.concat(@required_tables["truetype"])
+        when :opentype_cff
+          required.concat(@required_tables["opentype_cff"])
+        when :variable
+          required.concat(@required_tables["variable"])
+        end
+
+        # Check each required table
+        required.each do |table_tag|
+          next if font.has_table?(table_tag)
+
+          # Special case: CFF or CFF2 are alternatives
+          if (table_tag == "CFF") && font.has_table?("CFF2")
+            next
+          end
+
+          issues << {
+            severity: "error",
+            category: "tables",
+            message: "Missing required table: #{table_tag}",
+            location: nil,
+          }
+        end
+
+        issues
+      end
+
+      # Check table version compatibility
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] The font
+      # @return [Array<Hash>] Array of version issues
+      def check_table_versions(font)
+        issues = []
+
+        # Check head table version
+        if font.has_table?(Constants::HEAD_TAG)
+          head = font.table(Constants::HEAD_TAG)
+          unless valid_head_version?(head)
+            issues << {
+              severity: "warning",
+              category: "tables",
+              message: "Unsupported head table version: #{head.major_version}.#{head.minor_version}",
+              location: Constants::HEAD_TAG,
+            }
+          end
+        end
+
+        # Check maxp table version
+        if font.has_table?(Constants::MAXP_TAG)
+          maxp = font.table(Constants::MAXP_TAG)
+          unless valid_maxp_version?(maxp)
+            issues << {
+              severity: "warning",
+              category: "tables",
+              message: "Unsupported maxp table version: #{maxp.version}",
+              location: Constants::MAXP_TAG,
+            }
+          end
+        end
+
+        issues
+      end
+
+      # Check if head table version is valid
+      #
+      # @param head [Tables::Head] The head table
+      # @return [Boolean] true if version is valid
+      def valid_head_version?(head)
+        # Head table version should be 1.0
+        head.major_version == 1 && head.minor_version.zero?
+      end
+
+      # Check if maxp table version is valid
+      #
+      # @param maxp [Tables::Maxp] The maxp table
+      # @return [Boolean] true if version is valid
+      def valid_maxp_version?(maxp)
+        # Version 0.5 for CFF fonts, 1.0 for TrueType fonts
+        version = maxp.version
+        [0x00005000, 0x00010000].include?(version)
+      end
+    end
+  end
+end

data/lib/fontisan/validation/validator.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../models/validation_report"
+require_relative "table_validator"
+require_relative "structure_validator"
+require_relative "consistency_validator"
+require_relative "checksum_validator"
+
+module Fontisan
+  module Validation
+    # Validator is the main orchestrator for font validation
+    #
+    # This class coordinates all validation checks (tables, structure,
+    # consistency, checksums) and produces a comprehensive ValidationReport.
+    #
+    # Single Responsibility: Orchestration of validation workflow
+    #
+    # @example Validating a font
+    #   validator = Validator.new(level: :standard)
+    #   report = validator.validate(font, font_path)
+    #   puts report.text_summary
+    class Validator
+      # Validation levels
+      LEVELS = %i[strict standard lenient].freeze
+
+      # Initialize validator
+      #
+      # @param level [Symbol] Validation level (:strict, :standard, :lenient)
+      # @param rules_path [String, nil] Path to custom rules file
+      def initialize(level: :standard, rules_path: nil)
+        @level = level
+        validate_level!
+
+        @rules = load_rules(rules_path)
+        @table_validator = TableValidator.new(@rules)
+        @structure_validator = StructureValidator.new(@rules)
+        @consistency_validator = ConsistencyValidator.new(@rules)
+        @checksum_validator = ChecksumValidator.new(@rules)
+      end
+
+      # Validate a font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
+      # @param font_path [String] Path to the font file
+      # @return [Models::ValidationReport] Validation report
+      def validate(font, font_path)
+        report = Models::ValidationReport.new(
+          font_path: font_path,
+          valid: true,
+        )
+
+        begin
+          # Run all validation checks
+          all_issues = []
+
+          # 1. Table validation
+          all_issues.concat(@table_validator.validate(font))
+
+          # 2. Structure validation
+          all_issues.concat(@structure_validator.validate(font))
+
+          # 3. Consistency validation
+          all_issues.concat(@consistency_validator.validate(font))
+
+          # 4. Checksum validation (requires file path)
+          all_issues.concat(@checksum_validator.validate(font, font_path))
+
+          # Add issues to report
+          all_issues.each do |issue|
+            case issue[:severity]
+            when "error"
+              report.add_error(issue[:category], issue[:message],
+                               issue[:location])
+            when "warning"
+              report.add_warning(issue[:category], issue[:message],
+                                 issue[:location])
+            when "info"
+              report.add_info(issue[:category], issue[:message],
+                              issue[:location])
+            end
+          end
+
+          # Determine overall validity based on level
+          report.valid = determine_validity(report)
+        rescue StandardError => e
+          report.add_error("validation", "Validation failed: #{e.message}", nil)
+          report.valid = false
+        end
+
+        report
+      end
+
+      # Get the current validation level
+      #
+      # @return [Symbol] The validation level
+      attr_reader :level
+
+      private
+
+      # Validate that the level is supported
+      #
+      # @raise [ArgumentError] if level is invalid
+      # @return [void]
+      def validate_level!
+        unless LEVELS.include?(@level)
+          raise ArgumentError,
+                "Invalid validation level: #{@level}. Must be one of: #{LEVELS.join(', ')}"
+        end
+      end
+
+      # Load validation rules
+      #
+      # @param rules_path [String, nil] Path to custom rules file
+      # @return [Hash] The rules configuration
+      def load_rules(rules_path)
+        path = rules_path || default_rules_path
+        YAML.load_file(path)
+      rescue Errno::ENOENT
+        raise "Validation rules file not found: #{path}"
+      rescue Psych::SyntaxError => e
+        raise "Invalid validation rules YAML: #{e.message}"
+      end
+
+      # Get the default rules path
+      #
+      # @return [String] Path to default rules file
+      def default_rules_path
+        File.join(__dir__, "..", "config", "validation_rules.yml")
+      end
+
+      # Determine if font is valid based on validation level
+      #
+      # @param report [Models::ValidationReport] The validation report
+      # @return [Boolean] true if font is valid for the given level
+      def determine_validity(report)
+        case @level
+        when :strict
+          # Strict: no errors, no warnings
+          !report.has_errors? && !report.has_warnings?
+        when :standard
+          # Standard: no errors (warnings allowed)
+          !report.has_errors?
+        when :lenient
+          # Lenient: no critical errors (some errors may be acceptable)
+          # For now, treat lenient same as standard
+          !report.has_errors?
+        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