fontisan 0.2.4 → 0.2.6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-03 00:00:00.000000000 Z
+date: 2026-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -127,6 +127,7 @@ files:
 - lib/fontisan/binary/structures.rb
 - lib/fontisan/cli.rb
 - lib/fontisan/collection/builder.rb
+- lib/fontisan/collection/dfont_builder.rb
 - lib/fontisan/collection/offset_calculator.rb
 - lib/fontisan/collection/table_analyzer.rb
 - lib/fontisan/collection/table_deduplicator.rb
@@ -156,10 +157,10 @@ 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
+- lib/fontisan/converters/collection_converter.rb
 - lib/fontisan/converters/conversion_strategy.rb
 - lib/fontisan/converters/format_converter.rb
 - lib/fontisan/converters/outline_converter.rb
@@ -167,6 +168,7 @@ files:
 - lib/fontisan/converters/table_copier.rb
 - lib/fontisan/converters/woff2_encoder.rb
 - lib/fontisan/converters/woff_writer.rb
+- lib/fontisan/dfont_collection.rb
 - lib/fontisan/error.rb
 - lib/fontisan/export/exporter.rb
 - lib/fontisan/export/table_serializer.rb
@@ -238,6 +240,7 @@ files:
 - lib/fontisan/optimizers/subroutine_generator.rb
 - lib/fontisan/optimizers/subroutine_optimizer.rb
 - lib/fontisan/outline_extractor.rb
+- lib/fontisan/parsers/dfont_parser.rb
 - lib/fontisan/parsers/tag.rb
 - lib/fontisan/pipeline/format_detector.rb
 - lib/fontisan/pipeline/output_writer.rb
@@ -322,15 +325,13 @@ 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/validation/collection_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

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