fontisan 0.2.4 → 0.2.6

data/lib/fontisan/validation/variable_font_validator.rb

@@ -1,218 +0,0 @@
-# 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/validation/woff2_header_validator.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  module Validation
-    # Woff2HeaderValidator validates the WOFF2 header structure
-    #
-    # This validator checks the WOFF2 header for:
-    # - Valid signature (0x774F4632 'wOF2')
-    # - Valid flavor (TrueType or CFF)
-    # - Reserved field is zero
-    # - File length consistency
-    # - Valid table count
-    # - Valid compressed size
-    # - Metadata offset/length consistency
-    # - Private data offset/length consistency
-    #
-    # Single Responsibility: WOFF2 header validation
-    #
-    # @example Validating a WOFF2 header
-    #   validator = Woff2HeaderValidator.new(rules)
-    #   issues = validator.validate(woff2_font)
-    class Woff2HeaderValidator
-      # Valid WOFF2 flavors
-      VALID_FLAVORS = [
-        0x00010000, # TrueType
-        0x74727565, # 'true' (TrueType)
-        0x4F54544F, # 'OTTO' (CFF/OpenType)
-      ].freeze
-
-      # Initialize WOFF2 header validator
-      #
-      # @param rules [Hash] Validation rules configuration
-      def initialize(rules)
-        @rules = rules
-        @woff2_config = rules["woff2_validation"] || {}
-      end
-
-      # Validate WOFF2 header
-      #
-      # @param woff2_font [Woff2Font] The WOFF2 font to validate
-      # @return [Array<Hash>] Array of validation issues
-      def validate(woff2_font)
-        issues = []
-
-        header = woff2_font.header
-        return issues unless header
-
-        # Check signature
-        issues.concat(check_signature(header))
-
-        # Check flavor
-        issues.concat(check_flavor(header))
-
-        # Check reserved field
-        issues.concat(check_reserved_field(header))
-
-        # Check table count
-        issues.concat(check_table_count(header, woff2_font))
-
-        # Check compressed size
-        issues.concat(check_compressed_size(header))
-
-        # Check metadata consistency
-        issues.concat(check_metadata(header))
-
-        # Check private data consistency
-        issues.concat(check_private_data(header))
-
-        issues
-      end
-
-      private
-
-      # Check signature validity
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of signature issues
-      def check_signature(header)
-        issues = []
-
-        unless header.signature == Woff2::Woff2Header::SIGNATURE
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Invalid WOFF2 signature: expected 0x#{Woff2::Woff2Header::SIGNATURE.to_s(16)}, " \
-                     "got 0x#{header.signature.to_s(16)}",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-
-      # Check flavor validity
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of flavor issues
-      def check_flavor(header)
-        issues = []
-
-        unless VALID_FLAVORS.include?(header.flavor)
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Invalid WOFF2 flavor: 0x#{header.flavor.to_s(16)} " \
-                     "(expected TrueType 0x00010000 or CFF 0x4F54544F)",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-
-      # Check reserved field
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of reserved field issues
-      def check_reserved_field(header)
-        issues = []
-
-        if header.reserved != 0
-          issues << {
-            severity: "warning",
-            category: "woff2_header",
-            message: "Reserved field should be 0, got #{header.reserved}",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-
-      # Check table count validity
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @param woff2_font [Woff2Font] The WOFF2 font
-      # @return [Array<Hash>] Array of table count issues
-      def check_table_count(header, woff2_font)
-        issues = []
-
-        if header.num_tables.zero?
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Number of tables cannot be zero",
-            location: "header",
-          }
-        end
-
-        # Check consistency with actual table entries
-        actual_count = woff2_font.table_entries.length
-        if header.num_tables != actual_count
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Table count mismatch: header=#{header.num_tables}, actual=#{actual_count}",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-
-      # Check compressed size validity
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of compressed size issues
-      def check_compressed_size(header)
-        issues = []
-
-        if header.total_compressed_size.zero?
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Total compressed size cannot be zero",
-            location: "header",
-          }
-        end
-
-        # Check compression ratio
-        if header.total_sfnt_size.positive? && header.total_compressed_size.positive?
-          ratio = header.total_compressed_size.to_f / header.total_sfnt_size
-          min_ratio = @woff2_config["min_compression_ratio"] || 0.2
-          max_ratio = @woff2_config["max_compression_ratio"] || 0.95
-
-          if ratio < min_ratio
-            issues << {
-              severity: "warning",
-              category: "woff2_header",
-              message: "Compression ratio (#{(ratio * 100).round(2)}%) is unusually low",
-              location: "header",
-            }
-          elsif ratio > max_ratio
-            issues << {
-              severity: "warning",
-              category: "woff2_header",
-              message: "Compression ratio (#{(ratio * 100).round(2)}%) is unusually high",
-              location: "header",
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Check metadata consistency
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of metadata issues
-      def check_metadata(header)
-        issues = []
-
-        # If metadata offset is set, length must be positive
-        if header.meta_offset.positive? && header.meta_length.zero?
-          issues << {
-            severity: "warning",
-            category: "woff2_header",
-            message: "Metadata offset is set but length is zero",
-            location: "header",
-          }
-        end
-
-        # If metadata length is set, offset must be positive
-        if header.meta_length.positive? && header.meta_offset.zero?
-          issues << {
-            severity: "warning",
-            category: "woff2_header",
-            message: "Metadata length is set but offset is zero",
-            location: "header",
-          }
-        end
-
-        # Original length should be >= compressed length
-        if header.meta_orig_length.positive? && header.meta_length.positive? && (header.meta_orig_length < header.meta_length)
-          issues << {
-            severity: "error",
-            category: "woff2_header",
-            message: "Metadata original length (#{header.meta_orig_length}) " \
-                     "is less than compressed length (#{header.meta_length})",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-
-      # Check private data consistency
-      #
-      # @param header [Woff2::Woff2Header] The header
-      # @return [Array<Hash>] Array of private data issues
-      def check_private_data(header)
-        issues = []
-
-        # If private offset is set, length must be positive
-        if header.priv_offset.positive? && header.priv_length.zero?
-          issues << {
-            severity: "warning",
-            category: "woff2_header",
-            message: "Private data offset is set but length is zero",
-            location: "header",
-          }
-        end
-
-        # If private length is set, offset must be positive
-        if header.priv_length.positive? && header.priv_offset.zero?
-          issues << {
-            severity: "warning",
-            category: "woff2_header",
-            message: "Private data length is set but offset is zero",
-            location: "header",
-          }
-        end
-
-        issues
-      end
-    end
-  end
-end