fontisan 0.2.3 → 0.2.5

data/lib/fontisan/validation/consistency_validator.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Validation
-    # ConsistencyValidator validates cross-table consistency
-    #
-    # This validator ensures that references between tables are valid,
-    # such as cmap glyph references, hmtx entry counts, and variable
-    # font table consistency.
-    #
-    # Single Responsibility: Cross-table data consistency validation
-    #
-    # @example Validating consistency
-    #   validator = ConsistencyValidator.new(rules)
-    #   issues = validator.validate(font)
-    class ConsistencyValidator
-      # Initialize consistency validator
-      #
-      # @param rules [Hash] Validation rules configuration
-      def initialize(rules)
-        @rules = rules
-        @consistency_config = rules["consistency_checks"] || {}
-      end
-
-      # Validate font consistency
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
-      # @return [Array<Hash>] Array of validation issues
-      def validate(font)
-        issues = []
-
-        # Check hmtx consistency if enabled
-        issues.concat(check_hmtx_consistency(font)) if should_check?("check_hmtx_consistency")
-
-        # Check name table consistency if enabled
-        issues.concat(check_name_consistency(font)) if should_check?("check_name_consistency")
-
-        # Check variable font consistency if enabled
-        issues.concat(check_variable_consistency(font)) if should_check?("check_variable_consistency")
-
-        issues
-      end
-
-      private
-
-      # Check if a validation should be performed
-      #
-      # @param check_name [String] The check name
-      # @return [Boolean] true if check should be performed
-      def should_check?(check_name)
-        @rules.dig("validation_levels", "standard", check_name)
-      end
-
-      # Check hmtx entry count matches glyph count
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of hmtx consistency issues
-      def check_hmtx_consistency(font)
-        issues = []
-
-        hmtx = font.table(Constants::HMTX_TAG)
-        maxp = font.table(Constants::MAXP_TAG)
-        hhea = font.table(Constants::HHEA_TAG)
-
-        return issues unless hmtx && maxp && hhea
-
-        glyph_count = maxp.num_glyphs
-        num_of_long_hor_metrics = hhea.number_of_h_metrics
-
-        # Verify the structure makes sense
-        if num_of_long_hor_metrics > glyph_count
-          issues << {
-            severity: "error",
-            category: "consistency",
-            message: "hhea number_of_h_metrics (#{num_of_long_hor_metrics}) exceeds glyph count (#{glyph_count})",
-            location: "hhea/hmtx tables",
-          }
-        end
-
-        if num_of_long_hor_metrics < 1
-          issues << {
-            severity: "error",
-            category: "consistency",
-            message: "hhea number_of_h_metrics is #{num_of_long_hor_metrics}, must be at least 1",
-            location: "hhea table",
-          }
-        end
-
-        issues
-      end
-
-      # Check name table for consistency issues
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of name table issues
-      def check_name_consistency(font)
-        issues = []
-
-        name = font.table(Constants::NAME_TAG)
-        return issues unless name
-
-        # Check that required name IDs are present
-        required_name_ids = [
-          Tables::Name::FAMILY,           # 1
-          Tables::Name::SUBFAMILY,        # 2
-          Tables::Name::FULL_NAME,        # 4
-          Tables::Name::VERSION,          # 5
-          Tables::Name::POSTSCRIPT_NAME,  # 6
-        ]
-
-        required_name_ids.each do |name_id|
-          has_entry = name.name_records.any? do |record|
-            record.name_id == name_id
-          end
-          unless has_entry
-            issues << {
-              severity: "warning",
-              category: "consistency",
-              message: "Missing recommended name ID #{name_id}",
-              location: "name table",
-            }
-          end
-        end
-
-        # Check for duplicate entries (same platform/encoding/language/nameID)
-        seen = {}
-        name.name_records.each do |record|
-          key = [record.platform_id, record.encoding_id, record.language_id,
-                 record.name_id]
-          if seen[key]
-            issues << {
-              severity: "warning",
-              category: "consistency",
-              message: "Duplicate name record: platform=#{record.platform_id}, encoding=#{record.encoding_id}, language=#{record.language_id}, nameID=#{record.name_id}",
-              location: "name table",
-            }
-          end
-          seen[key] = true
-        end
-
-        issues
-      end
-
-      # Check variable font table consistency
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of variable font issues
-      def check_variable_consistency(font)
-        issues = []
-
-        # Only check if this is a variable font
-        return issues unless font.has_table?(Constants::FVAR_TAG)
-
-        fvar = font.table(Constants::FVAR_TAG)
-        return issues unless fvar
-
-        axis_count = fvar.axes.length
-
-        # For TrueType variable fonts, check gvar consistency
-        if font.has_table?(Constants::GVAR_TAG)
-          gvar = font.table(Constants::GVAR_TAG)
-          gvar_axis_count = gvar.axis_count
-          if gvar_axis_count != axis_count
-            issues << {
-              severity: "error",
-              category: "consistency",
-              message: "fvar axis count (#{axis_count}) doesn't match gvar axis count (#{gvar_axis_count})",
-              location: "fvar/gvar tables",
-            }
-          end
-        end
-
-        # Check that recommended variation tables are present
-        unless font.has_table?(Constants::GVAR_TAG) || font.has_table?(Constants::CFF2_TAG)
-          issues << {
-            severity: "error",
-            category: "consistency",
-            message: "Variable font missing gvar (TrueType) or CFF2 (CFF) table",
-            location: "variable font",
-          }
-        end
-
-        # Check for recommended metrics variation tables
-        unless font.has_table?(Constants::HVAR_TAG)
-          issues << {
-            severity: "info",
-            category: "consistency",
-            message: "Variable font missing HVAR table (recommended for better rendering)",
-            location: nil,
-          }
-        end
-
-        issues
-      end
-    end
-  end
-end

data/lib/fontisan/validation/structure_validator.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Validation
-    # StructureValidator validates the structural integrity of fonts
-    #
-    # This validator checks the SFNT structure, table offsets, table ordering,
-    # and other structural properties that ensure the font file is well-formed.
-    #
-    # Single Responsibility: Font structure and SFNT format validation
-    #
-    # @example Validating structure
-    #   validator = StructureValidator.new(rules)
-    #   issues = validator.validate(font)
-    class StructureValidator
-      # Initialize structure validator
-      #
-      # @param rules [Hash] Validation rules configuration
-      def initialize(rules)
-        @rules = rules
-        @structure_config = rules["structure_validation"] || {}
-      end
-
-      # Validate font structure
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
-      # @return [Array<Hash>] Array of validation issues
-      def validate(font)
-        issues = []
-
-        # Check glyph count consistency
-        issues.concat(check_glyph_consistency(font))
-
-        # Check table offsets
-        issues.concat(check_table_offsets(font)) if @rules.dig(
-          "validation_levels", "standard", "check_table_offsets"
-        )
-
-        # Check table ordering (optional optimization check)
-        issues.concat(check_table_ordering(font)) if @rules.dig(
-          "validation_levels", "standard", "check_table_ordering"
-        )
-
-        issues
-      end
-
-      private
-
-      # Check glyph count consistency across tables
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of consistency issues
-      def check_glyph_consistency(font)
-        issues = []
-
-        # Get glyph count from maxp table
-        maxp = font.table(Constants::MAXP_TAG)
-        return issues unless maxp
-
-        expected_count = maxp.num_glyphs
-
-        # For TrueType fonts, check glyf table glyph count
-        if font.has_table?(Constants::GLYF_TAG)
-          glyf = font.table(Constants::GLYF_TAG)
-          actual_count = glyf.glyphs.length if glyf.respond_to?(:glyphs)
-
-          if actual_count && actual_count != expected_count
-            issues << {
-              severity: "error",
-              category: "structure",
-              message: "Glyph count mismatch: maxp=#{expected_count}, glyf=#{actual_count}",
-              location: "glyf table",
-            }
-          end
-        end
-
-        # Check glyph count bounds with safe defaults
-        min_glyph_count = @structure_config["min_glyph_count"] || 1
-        max_glyph_count = @structure_config["max_glyph_count"] || 65536
-
-        if expected_count < min_glyph_count
-          issues << {
-            severity: "error",
-            category: "structure",
-            message: "Glyph count (#{expected_count}) below minimum (#{min_glyph_count})",
-            location: "maxp table",
-          }
-        end
-
-        if expected_count > max_glyph_count
-          issues << {
-            severity: "error",
-            category: "structure",
-            message: "Glyph count (#{expected_count}) exceeds maximum (#{max_glyph_count})",
-            location: "maxp table",
-          }
-        end
-
-        issues
-      end
-
-      # Check that table offsets are valid
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of offset issues
-      def check_table_offsets(font)
-        issues = []
-
-        min_offset = @structure_config["min_table_offset"] || 12
-        max_size = @structure_config["max_table_size"] || 104857600
-
-        font.tables.each do |table_entry|
-          tag = table_entry.tag
-          offset = table_entry.offset
-          length = table_entry.table_length
-
-          # Check minimum offset
-          if offset < min_offset
-            issues << {
-              severity: "error",
-              category: "structure",
-              message: "Table '#{tag}' has invalid offset: #{offset} (minimum: #{min_offset})",
-              location: "#{tag} table directory",
-            }
-          end
-
-          # Check for reasonable table size
-          if length > max_size
-            issues << {
-              severity: "warning",
-              category: "structure",
-              message: "Table '#{tag}' has unusually large size: #{length} bytes",
-              location: "#{tag} table",
-            }
-          end
-
-          # Check alignment (tables should be 4-byte aligned)
-          alignment = @structure_config["table_alignment"] || 4
-          if offset % alignment != 0
-            issues << {
-              severity: "warning",
-              category: "structure",
-              message: "Table '#{tag}' is not #{alignment}-byte aligned (offset: #{offset})",
-              location: "#{tag} table directory",
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Check table ordering (optimization check, not critical)
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of ordering issues
-      def check_table_ordering(font)
-        issues = []
-
-        # Recommended table order for optimal loading
-        recommended_order = [
-          Constants::HEAD_TAG,
-          Constants::HHEA_TAG,
-          Constants::MAXP_TAG,
-          Constants::OS2_TAG,
-          Constants::NAME_TAG,
-          Constants::CMAP_TAG,
-          Constants::POST_TAG,
-          Constants::GLYF_TAG,
-          Constants::LOCA_TAG,
-          Constants::HMTX_TAG,
-        ]
-
-        # Get actual table order
-        actual_order = font.table_names
-
-        # Check if critical tables are in recommended order
-        critical_tables = recommended_order.take(7) # head through post
-        actual_critical = actual_order.select do |tag|
-          critical_tables.include?(tag)
-        end
-        expected_critical = critical_tables.select do |tag|
-          actual_order.include?(tag)
-        end
-
-        if actual_critical != expected_critical
-          issues << {
-            severity: "info",
-            category: "structure",
-            message: "Tables not in optimal order for performance",
-            location: nil,
-          }
-        end
-
-        issues
-      end
-    end
-  end
-end

data/lib/fontisan/validation/table_validator.rb

@@ -1,158 +0,0 @@
-# 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 == Constants::CFF_TAG) && 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

@@ -1,152 +0,0 @@
-# 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