fontisan 0.2.4 → 0.2.6

data/lib/fontisan/validation/woff2_table_validator.rb

@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../woff2/directory"
-
-module Fontisan
-  module Validation
-    # Woff2TableValidator validates WOFF2 table directory entries
-    #
-    # This validator checks each table entry for:
-    # - Valid tag (known or custom)
-    # - Valid transformation version
-    # - Transform length consistency
-    # - Table size validity
-    # - Flags byte correctness
-    #
-    # Single Responsibility: WOFF2 table directory validation
-    #
-    # @example Validating WOFF2 tables
-    #   validator = Woff2TableValidator.new(rules)
-    #   issues = validator.validate(woff2_font)
-    class Woff2TableValidator
-      # Initialize WOFF2 table validator
-      #
-      # @param rules [Hash] Validation rules configuration
-      def initialize(rules)
-        @rules = rules
-        @woff2_config = rules["woff2_validation"] || {}
-      end
-
-      # Validate WOFF2 table directory
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font to validate
-      # @return [Array<Hash>] Array of validation issues
-      def validate(woff2_font)
-        issues = []
-
-        woff2_font.table_entries.each do |entry|
-          # Check tag validity
-          issues.concat(check_tag(entry))
-
-          # Check flags byte
-          issues.concat(check_flags(entry))
-
-          # Check transformation version
-          issues.concat(check_transformation(entry))
-
-          # Check table sizes
-          issues.concat(check_sizes(entry))
-        end
-
-        # Check for duplicate tables
-        issues.concat(check_duplicates(woff2_font.table_entries))
-
-        issues
-      end
-
-      private
-
-      # Check tag validity
-      #
-      # @param entry [Woff2TableDirectoryEntry] The table entry
-      # @return [Array<Hash>] Array of tag issues
-      def check_tag(entry)
-        issues = []
-
-        if entry.tag.nil? || entry.tag.empty?
-          issues << {
-            severity: "error",
-            category: "woff2_tables",
-            message: "Table entry has nil or empty tag",
-            location: "table directory",
-          }
-        elsif entry.tag.bytesize != 4
-          issues << {
-            severity: "error",
-            category: "woff2_tables",
-            message: "Table tag '#{entry.tag}' must be exactly 4 bytes, got #{entry.tag.bytesize}",
-            location: entry.tag,
-          }
-        end
-
-        issues
-      end
-
-      # Check flags byte validity
-      #
-      # @param entry [Woff2TableDirectoryEntry] The table entry
-      # @return [Array<Hash>] Array of flags issues
-      def check_flags(entry)
-        issues = []
-
-        tag_index = entry.flags & 0x3F
-        (entry.flags >> 6) & 0x03
-
-        # Check tag index consistency
-        if tag_index == Woff2::Directory::CUSTOM_TAG_INDEX
-          # Custom tag - should not be in known tags
-          if Woff2::Directory::KNOWN_TAGS.include?(entry.tag)
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' uses custom tag index but is a known tag",
-              location: entry.tag,
-            }
-          end
-        else
-          # Known tag - should match index
-          expected_tag = Woff2::Directory::KNOWN_TAGS[tag_index]
-          if expected_tag && expected_tag != entry.tag
-            issues << {
-              severity: "error",
-              category: "woff2_tables",
-              message: "Table tag mismatch: index #{tag_index} should be '#{expected_tag}', got '#{entry.tag}'",
-              location: entry.tag,
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Check transformation version
-      #
-      # @param entry [Woff2TableDirectoryEntry] The table entry
-      # @return [Array<Hash>] Array of transformation issues
-      def check_transformation(entry)
-        issues = []
-
-        transform_version = (entry.flags >> 6) & 0x03
-
-        # Check transformation consistency for transformable tables
-        case entry.tag
-        when "glyf", "loca"
-          # glyf/loca: version 0 = transformed (needs transform_length)
-          #            version 1-3 = not transformed (no transform_length)
-          if transform_version.zero?
-            # Should be transformed
-            unless entry.transform_length&.positive?
-              issues << {
-                severity: "error",
-                category: "woff2_tables",
-                message: "Table '#{entry.tag}' has transform version 0 but no transform_length",
-                location: entry.tag,
-              }
-            end
-          elsif entry.transform_length&.positive?
-            # Should not be transformed
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' has transform version #{transform_version} but has transform_length",
-              location: entry.tag,
-            }
-          end
-
-        when "hmtx"
-          # hmtx: version 1 = transformed (needs transform_length)
-          #       version 0, 2, 3 = not transformed (no transform_length)
-          if transform_version == 1
-            # Should be transformed
-            unless entry.transform_length&.positive?
-              issues << {
-                severity: "error",
-                category: "woff2_tables",
-                message: "Table '#{entry.tag}' has transform version 1 but no transform_length",
-                location: entry.tag,
-              }
-            end
-          elsif entry.transform_length&.positive?
-            # Should not be transformed
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' has transform version #{transform_version} but has transform_length",
-              location: entry.tag,
-            }
-          end
-
-        else
-          # Other tables should not be transformed
-          if entry.transform_length&.positive?
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' is not transformable but has transform_length",
-              location: entry.tag,
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Check table sizes
-      #
-      # @param entry [Woff2TableDirectoryEntry] The table entry
-      # @return [Array<Hash>] Array of size issues
-      def check_sizes(entry)
-        issues = []
-
-        # Check orig_length
-        if entry.orig_length.nil? || entry.orig_length.zero?
-          issues << {
-            severity: "error",
-            category: "woff2_tables",
-            message: "Table '#{entry.tag}' has invalid orig_length: #{entry.orig_length}",
-            location: entry.tag,
-          }
-        end
-
-        # Check transform_length if present
-        if entry.transform_length
-          if entry.transform_length.zero?
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' has transform_length of zero",
-              location: entry.tag,
-            }
-          elsif entry.transform_length > entry.orig_length
-            issues << {
-              severity: "warning",
-              category: "woff2_tables",
-              message: "Table '#{entry.tag}' has transform_length (#{entry.transform_length}) " \
-                       "greater than orig_length (#{entry.orig_length})",
-              location: entry.tag,
-            }
-          end
-        end
-
-        # Check for extremely large tables
-        max_table_size = @woff2_config["max_table_size"] || 104_857_600 # 100MB
-        if entry.orig_length > max_table_size
-          issues << {
-            severity: "warning",
-            category: "woff2_tables",
-            message: "Table '#{entry.tag}' has unusually large size: #{entry.orig_length} bytes",
-            location: entry.tag,
-          }
-        end
-
-        issues
-      end
-
-      # Check for duplicate table tags
-      #
-      # @param entries [Array<Woff2TableDirectoryEntry>] All table entries
-      # @return [Array<Hash>] Array of duplicate issues
-      def check_duplicates(entries)
-        issues = []
-
-        tag_counts = Hash.new(0)
-        entries.each { |entry| tag_counts[entry.tag] += 1 }
-
-        tag_counts.each do |tag, count|
-          if count > 1
-            issues << {
-              severity: "error",
-              category: "woff2_tables",
-              message: "Duplicate table tag '#{tag}' appears #{count} times",
-              location: tag,
-            }
-          end
-        end
-
-        issues
-      end
-    end
-  end
-end

data/lib/fontisan/validation/woff2_validator.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require_relative "../models/validation_report"
-require_relative "woff2_header_validator"
-require_relative "woff2_table_validator"
-
-module Fontisan
-  module Validation
-    # Woff2Validator is the main orchestrator for WOFF2 font validation
-    #
-    # This class coordinates WOFF2-specific validation checks (header, tables)
-    # and produces a comprehensive ValidationReport. It is designed to validate
-    # WOFF2 encoding quality and spec compliance.
-    #
-    # Single Responsibility: Orchestration of WOFF2 validation workflow
-    #
-    # @example Validating a WOFF2 font
-    #   validator = Woff2Validator.new(level: :standard)
-    #   report = validator.validate(woff2_font, font_path)
-    #   puts report.text_summary
-    #
-    # @example Validating WOFF2 encoding result
-    #   woff2_font = Woff2Font.from_file("output.woff2")
-    #   validator = Woff2Validator.new
-    #   report = validator.validate(woff2_font, "output.woff2")
-    #   puts "Valid: #{report.valid}"
-    class Woff2Validator
-      # Validation levels
-      LEVELS = %i[strict standard lenient].freeze
-
-      # Initialize WOFF2 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)
-        @header_validator = Woff2HeaderValidator.new(@rules)
-        @table_validator = Woff2TableValidator.new(@rules)
-      end
-
-      # Validate a WOFF2 font
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font to validate
-      # @param font_path [String] Path to the font file
-      # @return [Models::ValidationReport] Validation report
-      def validate(woff2_font, font_path)
-        report = Models::ValidationReport.new(
-          font_path: font_path,
-          valid: true,
-        )
-
-        begin
-          # Run all validation checks
-          all_issues = []
-
-          # 1. Header validation
-          all_issues.concat(@header_validator.validate(woff2_font))
-
-          # 2. Table validation
-          all_issues.concat(@table_validator.validate(woff2_font))
-
-          # 3. WOFF2-specific checks
-          all_issues.concat(check_woff2_specific(woff2_font))
-
-          # 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("woff2_validation", "WOFF2 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
-        # If rules file doesn't exist, use minimal defaults
-        {
-          "woff2_validation" => {
-            "min_compression_ratio" => 0.2,
-            "max_compression_ratio" => 0.95,
-            "max_table_size" => 104_857_600,
-          },
-        }
-      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
-
-      # WOFF2-specific validation checks
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font
-      # @return [Array<Hash>] Array of WOFF2-specific issues
-      def check_woff2_specific(woff2_font)
-        issues = []
-
-        # Check required tables for font type
-        issues.concat(check_required_woff2_tables(woff2_font))
-
-        # Check compression quality
-        issues.concat(check_compression_quality(woff2_font))
-
-        issues
-      end
-
-      # Check required tables based on font flavor
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font
-      # @return [Array<Hash>] Array of required table issues
-      def check_required_woff2_tables(woff2_font)
-        issues = []
-
-        # Basic required tables for all fonts
-        required_tables = %w[head hhea maxp name cmap post]
-
-        # Add flavor-specific tables
-        if woff2_font.truetype?
-          # For TrueType, we need glyf and hmtx
-          # Note: loca is NOT required in WOFF2 table directory because it can be
-          # reconstructed from transformed glyf. This is standard WOFF2 behavior.
-          required_tables << "glyf"
-          required_tables << "hmtx"
-        elsif woff2_font.cff?
-          required_tables << "CFF "
-        end
-
-        # Check each required table
-        required_tables.each do |table_tag|
-          unless woff2_font.has_table?(table_tag)
-            issues << {
-              severity: "error",
-              category: "woff2_structure",
-              message: "Missing required table: #{table_tag}",
-              location: nil,
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Check compression quality
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font
-      # @return [Array<Hash>] Array of compression quality issues
-      def check_compression_quality(woff2_font)
-        issues = []
-
-        header = woff2_font.header
-        return issues unless header
-
-        # Calculate actual compression ratio
-        if header.total_sfnt_size.positive? && header.total_compressed_size.positive?
-          ratio = header.total_compressed_size.to_f / header.total_sfnt_size
-          percentage = (ratio * 100).round(2)
-
-          # Info about compression achieved
-          issues << {
-            severity: "info",
-            category: "woff2_compression",
-            message: "Compression ratio: #{percentage}% (#{header.total_compressed_size} / #{header.total_sfnt_size} bytes)",
-            location: nil,
-          }
-
-          # Warn if compression is poor (> 80%)
-          if ratio > 0.80
-            issues << {
-              severity: "warning",
-              category: "woff2_compression",
-              message: "Poor compression ratio: #{percentage}% (expected < 80%)",
-              location: nil,
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Determine if WOFF2 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 WOFF2, treat lenient same as standard
-          !report.has_errors?
-        end
-      end
-    end
-  end
-end