fontisan 0.1.0 → 0.2.1

data/lib/fontisan/validation/structure_validator.rb

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

@@ -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 == 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

@@ -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