fontisan 0.2.4 → 0.2.5

data/lib/fontisan/validators/web_font_validator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "basic_validator"
+
+module Fontisan
+  module Validators
+    # WebFontValidator provides web font optimization and embedding compatibility checks
+    #
+    # This validator extends BasicValidator with checks specific to web font use cases.
+    # Unlike FontBookValidator, it focuses on web embedding permissions, file size,
+    # and WOFF/WOFF2 conversion readiness rather than desktop installation.
+    #
+    # The validator inherits 8 checks from BasicValidator and adds 10 new checks:
+    # - Embedding permissions (OS/2 fsType)
+    # - File size and glyph complexity for web performance
+    # - Character coverage for web use
+    # - Glyph accessibility
+    # - WOFF/WOFF2 conversion readiness
+    #
+    # @example Using WebFontValidator
+    #   validator = WebFontValidator.new
+    #   report = validator.validate(font)
+    #   puts "Font is web-ready" if report.valid?
+    class WebFontValidator < BasicValidator
+      private
+
+      # Define web font validation checks
+      #
+      # Calls super to inherit BasicValidator's 8 checks, then adds 10 new checks.
+      # All checks use helpers from Week 1 table implementations.
+      def define_checks
+        # Inherit BasicValidator checks (8 checks)
+        super
+
+        # Check 9: OS/2 embedding permissions must allow web use
+        check_table :embedding_permissions, 'OS/2', severity: :error do |table|
+          table.has_embedding_permissions?
+        end
+
+        # Check 10: OS/2 version should be present
+        check_table :os2_version_web, 'OS/2', severity: :warning do |table|
+          table.valid_version?
+        end
+
+        # Check 11: Glyph complexity should be reasonable for web
+        check_glyphs :no_complex_glyphs, severity: :warning do |font|
+          maxp = font.table('maxp')
+          next true unless maxp.version_1_0?
+
+          # Check max points and contours are reasonable for web rendering
+          maxp.max_points && maxp.max_points < 3000 &&
+            maxp.max_contours && maxp.max_contours < 500
+        end
+
+        # Check 12: Cmap must have Unicode mapping for web
+        check_table :character_coverage, 'cmap', severity: :error do |table|
+          table.has_unicode_mapping?
+        end
+
+        # Check 13: Cmap should have BMP coverage
+        check_table :cmap_bmp_web, 'cmap', severity: :warning do |table|
+          table.has_bmp_coverage?
+        end
+
+        # Check 14: Glyf glyphs must be accessible (web browsers need this)
+        check_glyphs :glyph_accessible_web, severity: :error do |font|
+          glyf = font.table('glyf')
+          next true unless glyf
+
+          loca = font.table('loca')
+          head = font.table('head')
+          maxp = font.table('maxp')
+          glyf.all_glyphs_accessible?(loca, head, maxp.num_glyphs)
+        end
+
+        # Check 15: Head table must have valid bounding box
+        check_table :head_bbox_web, 'head', severity: :error do |table|
+          table.valid_bounding_box?
+        end
+
+        # Check 16: Hhea metrics must be valid for web rendering
+        check_table :hhea_metrics_web, 'hhea', severity: :error do |table|
+          table.valid_ascent_descent? && table.valid_number_of_h_metrics?
+        end
+
+        # Check 17: WOFF conversion readiness
+        check_structure :woff_conversion_ready, severity: :info do |font|
+          # Check font can be converted to WOFF
+          # All required tables present
+          %w[name head maxp hhea].all? { |tag| font.table(tag) }
+        end
+
+        # Check 18: WOFF2 conversion readiness
+        check_structure :woff2_conversion_ready, severity: :info do |font|
+          # Check font can be converted to WOFF2
+          # Same requirements as WOFF
+          %w[name head maxp hhea].all? { |tag| font.table(tag) }
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/fontisan.rb

@@ -124,18 +124,30 @@ require_relative "fontisan/models/color_layer"
 require_relative "fontisan/models/color_palette"
 require_relative "fontisan/models/svg_glyph"
 
+# Validators infrastructure (NEW - DSL-based framework from Week 2+)
+require_relative "fontisan/validators/validator"
+require_relative "fontisan/validators/basic_validator"
+require_relative "fontisan/validators/font_book_validator"
+require_relative "fontisan/validators/opentype_validator"
+require_relative "fontisan/validators/web_font_validator"
+require_relative "fontisan/validators/profile_loader"
+
 # Export infrastructure
 require_relative "fontisan/export/table_serializer"
 require_relative "fontisan/export/ttx_generator"
 require_relative "fontisan/export/ttx_parser"
 require_relative "fontisan/export/exporter"
 
-# Validation infrastructure
-require_relative "fontisan/validation/table_validator"
-require_relative "fontisan/validation/structure_validator"
-require_relative "fontisan/validation/consistency_validator"
-require_relative "fontisan/validation/checksum_validator"
-require_relative "fontisan/validation/validator"
+# Validation infrastructure (OLD - commented out for new DSL framework)
+# Week 1 deleted these, Week 2-5 building new DSL-based framework
+# require_relative "fontisan/validation/checks/base_check"
+# require_relative "fontisan/validation/check_registry"
+# require_relative "fontisan/validation/profile"
+# require_relative "fontisan/validation/table_validator"
+# require_relative "fontisan/validation/structure_validator"
+# require_relative "fontisan/validation/consistency_validator"
+# require_relative "fontisan/validation/checksum_validator"
+# require_relative "fontisan/validation/validator"
 
 # Subsetting infrastructure
 require_relative "fontisan/subset/options"
@@ -261,4 +273,64 @@ module Fontisan
   def self.info(path, brief: false, font_index: 0)
     Commands::InfoCommand.new(path, brief: brief, font_index: font_index).run
   end
+
+  # Validate a font file using specified profile
+  #
+  # Validates fonts against quality checks, structural integrity, and OpenType
+  # specification compliance using the new DSL-based validation framework.
+  #
+  # @param path [String] Path to font file
+  # @param profile [Symbol, String] Validation profile (default: :default)
+  #   Available profiles:
+  #   - :indexability - Fast validation for font discovery
+  #   - :usability - Basic usability for installation
+  #   - :production - Comprehensive quality checks (default)
+  #   - :web - Web embedding and optimization
+  #   - :spec_compliance - Full OpenType spec compliance
+  #   - :default - Alias for production profile
+  # @param options [Hash] Additional validation options
+  # @return [Models::ValidationReport] Validation report with issues and status
+  #
+  # @example Validate with default profile
+  #   report = Fontisan.validate("font.ttf")
+  #   puts "Valid: #{report.valid?}"
+  #
+  # @example Validate for web use
+  #   report = Fontisan.validate("font.ttf", profile: :web)
+  #   puts "Errors: #{report.summary.errors}"
+  #
+  # @example Validate and get detailed report
+  #   report = Fontisan.validate("font.ttf", profile: :production)
+  #   puts report.to_yaml
+  def self.validate(path, profile: :default, options: {})
+    # Get profile configuration
+    profile_config = Validators::ProfileLoader.profile_info(profile)
+    raise ArgumentError, "Unknown profile: #{profile}" unless profile_config
+
+    # Load font with appropriate mode
+    mode = profile_config[:loading_mode].to_sym
+    font = FontLoader.load(path, mode: mode)
+
+    # Load validator for profile
+    validator = Validators::ProfileLoader.load(profile)
+
+    # Run validation
+    validator.validate(font)
+  end
+
+  class << self
+    private
+
+    # Get loading mode for validation profile
+    #
+    # Temporarily disabled - will be reimplemented with new DSL framework
+    #
+    # @param profile [Symbol] Validation profile
+    # @return [Symbol] Loading mode (:metadata or :full)
+    # def profile_loading_mode(profile)
+    #   Validation::Profile.load(profile).loading_mode.to_sym
+    # rescue
+    #   :full
+    # end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Ribose Inc.
@@ -156,7 +156,6 @@ files:
 - lib/fontisan/config/scripts.yml
 - lib/fontisan/config/subset_profiles.yml
 - lib/fontisan/config/svg_settings.yml
-- lib/fontisan/config/validation_rules.yml
 - lib/fontisan/config/variable_settings.yml
 - lib/fontisan/config/woff2_settings.yml
 - lib/fontisan/constants.rb
@@ -322,15 +321,12 @@ files:
 - lib/fontisan/utilities/brotli_wrapper.rb
 - lib/fontisan/utilities/checksum_calculator.rb
 - lib/fontisan/utils/thread_pool.rb
-- lib/fontisan/validation/checksum_validator.rb
-- lib/fontisan/validation/consistency_validator.rb
-- lib/fontisan/validation/structure_validator.rb
-- lib/fontisan/validation/table_validator.rb
-- lib/fontisan/validation/validator.rb
-- lib/fontisan/validation/variable_font_validator.rb
-- lib/fontisan/validation/woff2_header_validator.rb
-- lib/fontisan/validation/woff2_table_validator.rb
-- lib/fontisan/validation/woff2_validator.rb
+- lib/fontisan/validators/basic_validator.rb
+- lib/fontisan/validators/font_book_validator.rb
+- lib/fontisan/validators/opentype_validator.rb
+- lib/fontisan/validators/profile_loader.rb
+- lib/fontisan/validators/validator.rb
+- lib/fontisan/validators/web_font_validator.rb
 - lib/fontisan/variable/axis_normalizer.rb
 - lib/fontisan/variable/delta_applicator.rb
 - lib/fontisan/variable/glyph_delta_processor.rb

data/lib/fontisan/config/validation_rules.yml

@@ -1,149 +0,0 @@
-# Font Validation Rules Configuration
-#
-# This file defines validation rules for different font types and validation levels.
-# The rules determine which checks are performed and their severity thresholds.
-
-# Required tables for different font types
-required_tables:
-  # Tables required for all fonts
-  all:
-    - head
-    - name
-    - cmap
-    - maxp
-    - hhea
-    - hmtx
-    - post
-    - OS/2
-
-  # Additional tables required for TrueType fonts (.ttf)
-  truetype:
-    - glyf
-    - loca
-
-  # Additional tables required for OpenType/CFF fonts (.otf)
-  opentype_cff:
-    - "CFF "  # or CFF2 for CFF2 format (note: CFF has trailing space per OpenType spec)
-
-  # Additional tables required for variable fonts
-  variable:
-    - fvar
-    - gvar  # For TrueType variable fonts
-    - HVAR  # Horizontal metrics variations (optional but recommended)
-    - MVAR  # Metrics variations (optional)
-
-# Validation levels define which checks to perform
-validation_levels:
-  # Strict: All checks must pass, no warnings allowed
-  strict:
-    check_required_tables: true
-    check_table_checksums: true
-    check_head_checksum_adjustment: true
-    check_glyph_consistency: true
-    check_cmap_references: true
-    check_hmtx_consistency: true
-    check_name_consistency: true
-    check_variable_consistency: true
-    check_table_offsets: true
-    check_table_ordering: false  # Not critical for correctness
-    allow_warnings: false
-    allow_info: true
-
-  # Standard: Most checks enabled, warnings allowed
-  standard:
-    check_required_tables: true
-    check_table_checksums: true
-    check_head_checksum_adjustment: true
-    check_glyph_consistency: true
-    check_cmap_references: true
-    check_hmtx_consistency: true
-    check_name_consistency: true
-    check_variable_consistency: true
-    check_table_offsets: true
-    check_table_ordering: false
-    allow_warnings: true
-    allow_info: true
-
-  # Lenient: Basic checks only, many warnings allowed
-  lenient:
-    check_required_tables: true
-    check_table_checksums: false  # Skip checksum validation
-    check_head_checksum_adjustment: false
-    check_glyph_consistency: true
-    check_cmap_references: false  # Skip cmap validation
-    check_hmtx_consistency: true
-    check_name_consistency: false
-    check_variable_consistency: false
-    check_table_offsets: true
-    check_table_ordering: false
-    allow_warnings: true
-    allow_info: true
-
-# Error messages templates
-error_messages:
-  missing_table: "Missing required table: %{table}"
-  invalid_table_checksum: "Table '%{table}' checksum mismatch (expected: %{expected}, got: %{actual})"
-  invalid_head_checksum: "Invalid head table checksum adjustment"
-  glyph_count_mismatch: "Glyph count mismatch: maxp=%{maxp}, actual=%{actual}"
-  invalid_cmap_reference: "cmap references non-existent glyph ID %{glyph_id}"
-  hmtx_count_mismatch: "hmtx entries (%{hmtx}) don't match glyph count (%{glyph_count})"
-  invalid_table_offset: "Table '%{table}' has invalid offset: %{offset}"
-  variable_table_missing: "Variable font missing required table: %{table}"
-  fvar_gvar_mismatch: "fvar axis count (%{fvar}) doesn't match gvar axis count (%{gvar})"
-
-# Warning messages templates
-warning_messages:
-  table_checksum_mismatch: "Table '%{table}' checksum mismatch"
-  suboptimal_table_order: "Tables not in optimal order for performance"
-  missing_optional_table: "Optional table '%{table}' not present (recommended for %{reason})"
-  name_inconsistency: "Name table inconsistency: %{issue}"
-  large_font_size: "Font file size (%{size} bytes) is unusually large"
-
-# Info messages templates
-info_messages:
-  optimization_opportunity: "Font could benefit from %{optimization}"
-  subsetting_recommended: "Font contains %{glyph_count} glyphs; subsetting may reduce size"
-  compression_recommended: "Font could benefit from WOFF2 compression"
-
-# Checksum validation settings
-checksum_validation:
-  # Magic number for checksum adjustment calculation
-  magic: 0xB1B0AFBA
-
-  # Tables exempt from checksum validation (some tables have dynamic content)
-  skip_tables:
-    - DSIG  # Digital signature table (changes with signing)
-
-# Consistency checks configuration
-consistency_checks:
-  # Maximum acceptable glyph ID for cmap validation
-  max_glyph_id_multiplier: 2.0  # Allow up to 2x maxp.numGlyphs for safety
-
-  # Minimum acceptable glyph count
-  min_glyph_count: 1
-
-  # Maximum acceptable glyph count (sanity check)
-  max_glyph_count: 65536
-
-# Structure validation settings
-structure_validation:
-  # Minimum valid offset (after header and directory)
-  min_table_offset: 12
-
-  # Table alignment requirement (4-byte alignment)
-  table_alignment: 4
-
-  # Maximum reasonable table size (100MB)
-  max_table_size: 104857600
-
-# Variable font specific validation
-variable_validation:
-  # Check that all required variation tables are consistent
-  check_axis_consistency: true
-
-  # Check that variation regions are valid
-  check_region_validity: true
-
-  # Check that deltas are within reasonable bounds
-  max_delta_value: 32767
-  min_delta_value: -32768

data/lib/fontisan/validation/checksum_validator.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../utilities/checksum_calculator"
-
-module Fontisan
-  module Validation
-    # ChecksumValidator validates font file and table checksums
-    #
-    # This validator checks that the head table checksum adjustment is correct
-    # and validates individual table checksums to ensure file integrity.
-    #
-    # Single Responsibility: Checksum validation and file integrity
-    #
-    # @example Validating checksums
-    #   validator = ChecksumValidator.new(rules)
-    #   issues = validator.validate(font, font_path)
-    class ChecksumValidator
-      # Initialize checksum validator
-      #
-      # @param rules [Hash] Validation rules configuration
-      def initialize(rules)
-        @rules = rules
-        @checksum_config = rules["checksum_validation"] || {}
-      end
-
-      # Validate font checksums
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
-      # @param font_path [String] Path to the font file
-      # @return [Array<Hash>] Array of validation issues
-      def validate(font, font_path)
-        issues = []
-
-        # Check head table checksum adjustment if enabled
-        if should_check?("check_head_checksum_adjustment")
-          issues.concat(check_head_checksum_adjustment(font, font_path))
-        end
-
-        # Check individual table checksums if enabled
-        if should_check?("check_table_checksums")
-          issues.concat(check_table_checksums(font))
-        end
-
-        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 head table checksum adjustment
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @param font_path [String] Path to the font file
-      # @return [Array<Hash>] Array of checksum issues
-      def check_head_checksum_adjustment(font, font_path)
-        issues = []
-
-        head_entry = font.head_table
-        return issues unless head_entry
-
-        # Calculate the checksum of the entire font file
-        begin
-          file_checksum = Utilities::ChecksumCalculator.calculate_file_checksum(font_path)
-          magic = @checksum_config["magic"] || Constants::CHECKSUM_ADJUSTMENT_MAGIC
-
-          # Read the actual checksum adjustment from head table
-          head_data = font.table_data[Constants::HEAD_TAG]
-          return issues unless head_data && head_data.bytesize >= 12
-
-          actual_adjustment = head_data.byteslice(8, 4).unpack1("N")
-
-          # The actual adjustment should be 0 when we calculate, since we zero it out
-          # So we need to check if the file checksum with zeroed adjustment equals magic
-          if file_checksum != magic
-            # Calculate what the adjustment should be
-            temp_checksum = (file_checksum - actual_adjustment) & 0xFFFFFFFF
-            correct_adjustment = (magic - temp_checksum) & 0xFFFFFFFF
-
-            if actual_adjustment != correct_adjustment
-              issues << {
-                severity: "error",
-                category: "checksum",
-                message: "Invalid head table checksum adjustment (expected: 0x#{correct_adjustment.to_s(16)}, got: 0x#{actual_adjustment.to_s(16)})",
-                location: "head table",
-              }
-            end
-          end
-        rescue StandardError => e
-          issues << {
-            severity: "error",
-            category: "checksum",
-            message: "Failed to validate head checksum adjustment: #{e.message}",
-            location: "head table",
-          }
-        end
-
-        issues
-      end
-
-      # Check individual table checksums
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font
-      # @return [Array<Hash>] Array of table checksum issues
-      def check_table_checksums(font)
-        issues = []
-
-        skip_tables = @checksum_config["skip_tables"] || []
-
-        font.tables.each do |table_entry|
-          tag = table_entry.tag.to_s # Convert BinData field to string
-
-          # Skip tables that are exempt from checksum validation
-          next if skip_tables.include?(tag)
-
-          # Get table data
-          table_data = font.table_data[tag]
-          next unless table_data
-
-          # Calculate checksum for the table
-          calculated_checksum = calculate_table_checksum(table_data)
-          declared_checksum = table_entry.checksum.to_i # Convert BinData field to integer
-
-          # Special handling for head table (checksum adjustment field should be 0)
-          if tag == Constants::HEAD_TAG
-            # Zero out checksum adjustment field for calculation
-            modified_data = table_data.dup
-            modified_data[8, 4] = "\x00\x00\x00\x00"
-            calculated_checksum = calculate_table_checksum(modified_data)
-          end
-
-          if calculated_checksum != declared_checksum
-            issues << {
-              severity: "warning",
-              category: "checksum",
-              message: "Table '#{tag}' checksum mismatch (expected: 0x#{declared_checksum.to_s(16)}, got: 0x#{calculated_checksum.to_s(16)})",
-              location: "#{tag} table",
-            }
-          end
-        end
-
-        issues
-      end
-
-      # Calculate checksum for table data
-      #
-      # @param data [String] The table data
-      # @return [Integer] The calculated checksum
-      def calculate_table_checksum(data)
-        sum = 0
-        # Pad to 4-byte boundary
-        padded_data = data + ("\x00" * ((4 - (data.bytesize % 4)) % 4))
-
-        # Sum all 32-bit values
-        (0...padded_data.bytesize).step(4) do |i|
-          value = padded_data.byteslice(i, 4).unpack1("N")
-          sum = (sum + value) & 0xFFFFFFFF
-        end
-
-        sum
-      end
-    end
-  end
-end