fontisan 0.1.0 → 0.2.0

data/lib/fontisan/utils/thread_pool.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Utils
+    # Simple thread pool implementation
+    #
+    # Manages a fixed number of worker threads for parallel job execution.
+    # Jobs are queued and processed by available workers.
+    #
+    # @example Basic usage
+    #   pool = ThreadPool.new(4)
+    #   future = pool.schedule { expensive_computation }
+    #   result = future.value
+    #   pool.shutdown
+    class ThreadPool
+      # Initialize thread pool
+      #
+      # @param size [Integer] Number of worker threads
+      def initialize(size)
+        @size = size
+        @queue = Queue.new
+        @threads = []
+        @shutdown = false
+
+        # Start worker threads
+        @size.times do
+          @threads << Thread.new { worker_loop }
+        end
+      end
+
+      # Schedule a job for execution
+      #
+      # @yield Job to execute
+      # @return [Future] Future object to retrieve result
+      def schedule(&block)
+        future = Future.new
+        @queue << { block: block, future: future }
+        future
+      end
+
+      # Shutdown thread pool
+      #
+      # Waits for all queued jobs to complete and stops workers.
+      def shutdown
+        @shutdown = true
+
+        # Signal all threads to stop
+        @size.times { @queue << :stop }
+
+        # Wait for all threads to finish
+        @threads.each(&:join)
+      end
+
+      private
+
+      # Worker thread main loop
+      def worker_loop
+        loop do
+          job = @queue.pop
+          break if job == :stop
+
+          begin
+            result = job[:block].call
+            job[:future].set_value(result)
+          rescue StandardError => e
+            job[:future].set_error(e)
+          end
+        end
+      end
+    end
+
+    # Future object for async result retrieval
+    #
+    # Represents a computation that will complete in the future.
+    # Provides blocking access to the eventual result or error.
+    #
+    # @example Basic usage
+    #   future = Future.new
+    #   Thread.new { future.set_value(42) }
+    #   result = future.value  # Blocks until value is set
+    class Future
+      def initialize
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @completed = false
+        @value = nil
+        @error = nil
+      end
+
+      # Set the computed value
+      #
+      # @param value [Object] Result value
+      def set_value(value)
+        @mutex.synchronize do
+          @value = value
+          @completed = true
+          @condition.signal
+        end
+      end
+
+      # Set an error
+      #
+      # @param error [Exception] Error that occurred
+      def set_error(error)
+        @mutex.synchronize do
+          @error = error
+          @completed = true
+          @condition.signal
+        end
+      end
+
+      # Get the value, blocking until available
+      #
+      # @return [Object] Computed value
+      # @raise [Exception] If computation failed
+      def value
+        @mutex.synchronize do
+          @condition.wait(@mutex) until @completed
+
+          raise @error if @error
+
+          @value
+        end
+      end
+
+      # Check if computation is complete
+      #
+      # @return [Boolean] True if complete
+      def completed?
+        @mutex.synchronize { @completed }
+      end
+    end
+  end
+end

data/lib/fontisan/validation/checksum_validator.rb

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

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

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