fontisan 0.2.4 → 0.2.6

data/lib/fontisan/parsers/dfont_parser.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "bindata"
+require_relative "../error"
+
+module Fontisan
+  module Parsers
+    # Parser for Apple dfont (Data Fork Font) resource fork format.
+    #
+    # dfont files store resource fork data in the data fork, containing
+    # TrueType or OpenType SFNT data embedded in a resource fork structure.
+    #
+    # @example Extract SFNT from dfont
+    #   File.open("font.dfont", "rb") do |io|
+    #     sfnt_data = DfontParser.extract_sfnt(io)
+    #     # sfnt_data is raw SFNT binary
+    #   end
+    class DfontParser
+      # Resource fork header structure (16 bytes)
+      class ResourceHeader < BinData::Record
+        endian :big
+        uint32 :resource_data_offset    # Offset to resource data section
+        uint32 :resource_map_offset     # Offset to resource map
+        uint32 :resource_data_length    # Length of resource data
+        uint32 :resource_map_length     # Length of resource map
+      end
+
+      # Resource type entry in type list
+      class ResourceType < BinData::Record
+        endian :big
+        string :type_code, length: 4        # Resource type (e.g., 'sfnt')
+        uint16 :resource_count_minus_1      # Number of resources - 1
+        uint16 :reference_list_offset       # Offset to reference list
+      end
+
+      # Resource reference in reference list
+      class ResourceReference < BinData::Record
+        endian :big
+        uint16 :resource_id           # Resource ID
+        int16 :name_offset            # Offset to name in name list (-1 if none)
+        uint8 :attributes             # Resource attributes
+        bit24 :data_offset            # Offset to data (relative to resource data section)
+        uint32 :reserved              # Reserved (handle to resource in memory)
+      end
+
+      # Extract SFNT data from dfont file
+      #
+      # @param io [IO] Open file handle
+      # @param index [Integer] Font index for multi-font suitcases (default: 0)
+      # @return [String] Raw SFNT binary data
+      # @raise [InvalidFontError] if not valid dfont or index out of range
+      def self.extract_sfnt(io, index: 0)
+        header = parse_header(io)
+        sfnt_resources = find_sfnt_resources(io, header)
+
+        if sfnt_resources.empty?
+          raise InvalidFontError, "No sfnt resources found in dfont file"
+        end
+
+        if index >= sfnt_resources.length
+          raise InvalidFontError,
+                "Font index #{index} out of range (dfont has #{sfnt_resources.length} fonts)"
+        end
+
+        extract_resource_data(io, header, sfnt_resources[index])
+      end
+
+      # Count number of sfnt resources (fonts) in dfont
+      #
+      # @param io [IO] Open file handle
+      # @return [Integer] Number of fonts
+      def self.sfnt_count(io)
+        header = parse_header(io)
+        sfnt_resources = find_sfnt_resources(io, header)
+        sfnt_resources.length
+      end
+
+      # Check if file is valid dfont resource fork
+      #
+      # @param io [IO] Open file handle
+      # @return [Boolean]
+      def self.dfont?(io)
+        io.rewind
+        header_bytes = io.read(16)
+        io.rewind
+
+        return false if header_bytes.nil? || header_bytes.length < 16
+
+        # Basic sanity check on resource fork structure
+        data_offset = header_bytes[0..3].unpack1("N")
+        map_offset = header_bytes[4..7].unpack1("N")
+
+        data_offset.positive? && map_offset > data_offset
+      end
+
+      # Parse resource fork header
+      #
+      # @param io [IO] Open file handle
+      # @return [ResourceHeader] Parsed header
+      # @raise [InvalidFontError] if header invalid
+      # @api private
+      def self.parse_header(io)
+        io.rewind
+        ResourceHeader.read(io)
+      rescue BinData::ValidityError => e
+        raise InvalidFontError, "Invalid dfont resource header: #{e.message}"
+      end
+
+      # Find all sfnt resources in resource map
+      #
+      # @param io [IO] Open file handle
+      # @param header [ResourceHeader] Parsed header
+      # @return [Array<Hash>] Array of resource info hashes with :id and :offset
+      # @api private
+      def self.find_sfnt_resources(io, header)
+        # Seek to resource map
+        io.seek(header.resource_map_offset)
+
+        # Skip resource map header (22 bytes reserved + 4 bytes attributes + 2 bytes type list offset + 2 bytes name list offset)
+        # The actual layout is:
+        # - Bytes 0-15: Copy of resource header (16 bytes)
+        # - Bytes 16-19: Reserved for handle to next resource map (4 bytes)
+        # - Bytes 20-21: Reserved for file reference number (2 bytes)
+        # - Bytes 22-23: Resource file attributes (2 bytes)
+        # - Bytes 24-25: Offset to type list (2 bytes)
+        # - Bytes 26-27: Offset to name list (2 bytes)
+        io.seek(header.resource_map_offset + 24)
+
+        # Read type list offset (relative to start of resource map)
+        type_list_offset = io.read(2).unpack1("n")
+
+        # Seek to type list
+        io.seek(header.resource_map_offset + type_list_offset)
+
+        # Read number of types minus 1
+        type_count_minus_1 = io.read(2).unpack1("n")
+        type_count = type_count_minus_1 + 1
+
+        # Find 'sfnt' type in type list
+        sfnt_type = nil
+        type_count.times do
+          type_entry = ResourceType.read(io)
+
+          if type_entry.type_code == "sfnt"
+            sfnt_type = type_entry
+            break
+          end
+        end
+
+        return [] unless sfnt_type
+
+        # Read reference list for sfnt resources
+        reference_list_offset = header.resource_map_offset + type_list_offset + sfnt_type.reference_list_offset
+        io.seek(reference_list_offset)
+
+        resource_count = sfnt_type.resource_count_minus_1 + 1
+        resources = []
+
+        resource_count.times do
+          ref = ResourceReference.read(io)
+          resources << { id: ref.resource_id, offset: ref.data_offset }
+        end
+
+        resources
+      end
+
+      # Extract resource data at specific offset
+      #
+      # @param io [IO] Open file handle
+      # @param header [ResourceHeader] Parsed header
+      # @param resource_info [Hash] Resource info with :offset
+      # @return [String] Raw SFNT binary data
+      # @api private
+      def self.extract_resource_data(io, header, resource_info)
+        # Calculate absolute offset to resource data
+        # The offset in the reference is relative to the start of the resource data section
+        data_offset = header.resource_data_offset + resource_info[:offset]
+
+        io.seek(data_offset)
+
+        # Read data length (first 4 bytes of resource data)
+        data_length = io.read(4).unpack1("N")
+
+        # Read the actual data
+        io.read(data_length)
+      end
+
+      private_class_method :parse_header, :find_sfnt_resources,
+                           :extract_resource_data
+    end
+  end
+end

data/lib/fontisan/pipeline/transformation_pipeline.rb

@@ -263,16 +263,12 @@ module Fontisan
       def validate_output
         return unless File.exist?(@output_path)
 
-        require_relative "../validation/validator"
+        # Use new validation framework with production profile
+        report = Fontisan.validate(@output_path, profile: :production)
 
-        # Load font for validation
-        font = FontLoader.load(@output_path, mode: :full)
-        validator = Validation::Validator.new
-        result = validator.validate(font, @output_path)
+        return if report.valid?
 
-        return if result.valid
-
-        error_messages = result.errors.map(&:message).join(", ")
+        error_messages = report.errors.map(&:message).join(", ")
         raise Error, "Output validation failed: #{error_messages}"
       end
 

data/lib/fontisan/tables/cmap.rb

@@ -36,8 +36,6 @@ module Fontisan
         @unicode_mappings ||= parse_mappings
       end
 
-      private
-
       # Parse all encoding records and extract Unicode mappings
       def parse_mappings
         mappings = {}
@@ -279,6 +277,88 @@ module Fontisan
           mappings[code] = glyph_index if glyph_index != 0
         end
       end
+
+      public
+
+      # Validation helper: Check if version is valid
+      #
+      # cmap version should be 0
+      #
+      # @return [Boolean] True if version is 0
+      def valid_version?
+        version == 0
+      end
+
+      # Validation helper: Check if at least one subtable exists
+      #
+      # @return [Boolean] True if num_tables > 0
+      def has_subtables?
+        num_tables && num_tables > 0
+      end
+
+      # Validation helper: Check if Unicode mapping exists
+      #
+      # @return [Boolean] True if Unicode mappings are present
+      def has_unicode_mapping?
+        !unicode_mappings.nil? && !unicode_mappings.empty?
+      end
+
+      # Validation helper: Check if BMP coverage exists
+      #
+      # Checks if the Basic Multilingual Plane (U+0000-U+FFFF) has mappings
+      #
+      # @return [Boolean] True if BMP characters are mapped
+      def has_bmp_coverage?
+        mappings = unicode_mappings
+        return false if mappings.nil? || mappings.empty?
+
+        # Check if any BMP characters (0x0000-0xFFFF) are mapped
+        mappings.keys.any? { |code| code.between?(0x0000, 0xFFFF) }
+      end
+
+      # Validation helper: Check if required characters are mapped
+      #
+      # Checks for essential characters like space (U+0020)
+      #
+      # @param required_chars [Array<Integer>] Character codes that must be present
+      # @return [Boolean] True if all required characters are mapped
+      def has_required_characters?(*required_chars)
+        mappings = unicode_mappings
+        return false if mappings.nil?
+
+        required_chars.all? { |code| mappings.key?(code) }
+      end
+
+      # Validation helper: Check if format 4 subtable exists
+      #
+      # Format 4 is the minimum requirement for Unicode BMP support
+      #
+      # @return [Boolean] True if format 4 subtable is found
+      def has_format_4_subtable?
+        data = to_binary_s
+        records = read_encoding_records(data)
+
+        records.any? do |record|
+          subtable_data = extract_subtable_data(record, data)
+          next false unless subtable_data && subtable_data.length >= 2
+
+          format = subtable_data[0, 2].unpack1("n")
+          format == 4
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if glyph indices are within bounds
+      #
+      # @param max_glyph_id [Integer] Maximum valid glyph ID from maxp table
+      # @return [Boolean] True if all mapped glyph IDs are valid
+      def valid_glyph_indices?(max_glyph_id)
+        mappings = unicode_mappings
+        return true if mappings.nil? || mappings.empty?
+
+        mappings.values.all? { |glyph_id| glyph_id >= 0 && glyph_id < max_glyph_id }
+      end
     end
   end
 end

data/lib/fontisan/tables/glyf.rb

@@ -158,6 +158,124 @@ module Fontisan
         @glyphs_cache ||= {}
       end
 
+      # Validation helper: Check if all non-special glyphs have contours
+      #
+      # The .notdef glyph (ID 0) can be empty, but other glyphs should have geometry
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if all non-special glyphs have contours
+      def no_empty_glyphs_except_special?(loca, head, num_glyphs)
+        # Check glyphs 1 through num_glyphs-1 (.notdef at 0 can be empty)
+        (1...num_glyphs).all? do |glyph_id|
+          size = loca.size_of(glyph_id)
+          # Empty glyphs (like space) are allowed, but check if they should be empty
+          # This is a basic check - we just ensure non-control glyphs have data
+          size.nil? || size.positive?
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if any glyphs are clipped (exceed bounds)
+      #
+      # Validates that glyph coordinates don't exceed head table's bounding box
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for bounds reference
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if no glyphs exceed the font's bounding box
+      def no_clipped_glyphs?(loca, head, num_glyphs)
+        font_x_min = head.x_min
+        font_y_min = head.y_min
+        font_x_max = head.x_max
+        font_y_max = head.y_max
+
+        (0...num_glyphs).all? do |glyph_id|
+          glyph = glyph_for(glyph_id, loca, head)
+          next true if glyph.nil?  # Empty glyphs are OK
+
+          # Check if glyph bounds are within font bounds
+          glyph.x_min >= font_x_min &&
+            glyph.y_min >= font_y_min &&
+            glyph.x_max <= font_x_max &&
+            glyph.y_max <= font_y_max
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if TrueType instructions are sound
+      #
+      # Validates that glyph instructions (if present) are parseable
+      # This is a basic check that ensures instructions exist and have valid length
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs to check
+      # @return [Boolean] True if all instructions are valid or absent
+      def instructions_sound?(loca, head, num_glyphs)
+        (0...num_glyphs).all? do |glyph_id|
+          glyph = glyph_for(glyph_id, loca, head)
+          next true if glyph.nil?  # Empty glyphs are OK
+
+          # Simple glyphs have instructions
+          if glyph.respond_to?(:instruction_length)
+            inst_len = glyph.instruction_length
+            # If instructions present, length should be reasonable
+            inst_len.nil? || inst_len >= 0
+          else
+            # Compound glyphs may have instructions too
+            true
+          end
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if glyph has valid number of contours
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @return [Boolean] True if contour count is valid
+      def valid_contour_count?(glyph_id, loca, head)
+        glyph = glyph_for(glyph_id, loca, head)
+        return true if glyph.nil?  # Empty glyphs are OK
+
+        # Simple glyphs: contours should be >= 0
+        # Compound glyphs: numberOfContours = -1
+        if glyph.respond_to?(:num_contours)
+          glyph.num_contours >= -1
+        else
+          true
+        end
+      rescue StandardError
+        false
+      end
+
+      # Validation helper: Check if all glyphs are accessible
+      #
+      # Attempts to access each glyph to ensure no corruption
+      #
+      # @param loca [Loca] Loca table for glyph access
+      # @param head [Head] Head table for context
+      # @param num_glyphs [Integer] Total number of glyphs
+      # @return [Boolean] True if all glyphs can be accessed
+      def all_glyphs_accessible?(loca, head, num_glyphs)
+        (0...num_glyphs).all? do |glyph_id|
+          begin
+            glyph_for(glyph_id, loca, head)
+            true
+          rescue Fontisan::CorruptedTableError
+            false
+          end
+        end
+      rescue StandardError
+        false
+      end
+
       private
 
       # Validate context and glyph ID

data/lib/fontisan/tables/head.rb

@@ -82,6 +82,66 @@ module Fontisan
         magic_number == MAGIC_NUMBER
       end
 
+      # Validation helper: Check if magic number is valid
+      #
+      # @return [Boolean] True if magic number equals 0x5F0F3CF5
+      def valid_magic?
+        magic_number == MAGIC_NUMBER
+      end
+
+      # Validation helper: Check if version is valid
+      #
+      # OpenType spec requires version to be 1.0
+      #
+      # @return [Boolean] True if version is 1.0
+      def valid_version?
+        version_raw == 0x00010000  # Version 1.0
+      end
+
+      # Validation helper: Check if units per em is valid
+      #
+      # Units per em should be a power of 2 between 16 and 16384
+      #
+      # @return [Boolean] True if units_per_em is valid
+      def valid_units_per_em?
+        return false if units_per_em.nil? || units_per_em.zero?
+
+        # Must be between 16 and 16384
+        return false unless units_per_em.between?(16, 16384)
+
+        # Should be a power of 2 (recommended but not required)
+        # Common values: 1000, 1024, 2048
+        # We'll allow any value in range for flexibility
+        true
+      end
+
+      # Validation helper: Check if bounding box is valid
+      #
+      # The bounding box should have xMin < xMax and yMin < yMax
+      #
+      # @return [Boolean] True if bounding box coordinates are valid
+      def valid_bounding_box?
+        x_min < x_max && y_min < y_max
+      end
+
+      # Validation helper: Check if index_to_loc_format is valid
+      #
+      # Must be 0 (short) or 1 (long)
+      #
+      # @return [Boolean] True if format is 0 or 1
+      def valid_index_to_loc_format?
+        index_to_loc_format == 0 || index_to_loc_format == 1
+      end
+
+      # Validation helper: Check if glyph_data_format is valid
+      #
+      # Must be 0 for current format
+      #
+      # @return [Boolean] True if format is 0
+      def valid_glyph_data_format?
+        glyph_data_format == 0
+      end
+
       # Validate magic number and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If magic number is invalid

data/lib/fontisan/tables/hhea.rb

@@ -97,6 +97,80 @@ module Fontisan
         true
       end
 
+      # Validation helper: Check if version is valid
+      #
+      # OpenType spec requires version to be 1.0
+      #
+      # @return [Boolean] True if version is 1.0
+      def valid_version?
+        version_raw == 0x00010000
+      end
+
+      # Validation helper: Check if metric data format is valid
+      #
+      # Must be 0 for current format
+      #
+      # @return [Boolean] True if format is 0
+      def valid_metric_data_format?
+        metric_data_format == 0
+      end
+
+      # Validation helper: Check if number of h metrics is valid
+      #
+      # Must be at least 1
+      #
+      # @return [Boolean] True if number_of_h_metrics >= 1
+      def valid_number_of_h_metrics?
+        number_of_h_metrics && number_of_h_metrics >= 1
+      end
+
+      # Validation helper: Check if ascent/descent values are reasonable
+      #
+      # Ascent should be positive, descent should be negative
+      #
+      # @return [Boolean] True if ascent/descent have correct signs
+      def valid_ascent_descent?
+        ascent > 0 && descent < 0
+      end
+
+      # Validation helper: Check if line gap is non-negative
+      #
+      # Line gap should be >= 0
+      #
+      # @return [Boolean] True if line_gap >= 0
+      def valid_line_gap?
+        line_gap >= 0
+      end
+
+      # Validation helper: Check if advance width max is positive
+      #
+      # Maximum advance width should be > 0
+      #
+      # @return [Boolean] True if advance_width_max > 0
+      def valid_advance_width_max?
+        advance_width_max && advance_width_max > 0
+      end
+
+      # Validation helper: Check if caret slope is valid
+      #
+      # For vertical text: rise=1, run=0
+      # For horizontal italic: both should be non-zero
+      #
+      # @return [Boolean] True if caret slope values are sensible
+      def valid_caret_slope?
+        # At least one should be non-zero
+        caret_slope_rise != 0 || caret_slope_run != 0
+      end
+
+      # Validation helper: Check if extent is reasonable
+      #
+      # x_max_extent should be positive
+      #
+      # @return [Boolean] True if x_max_extent > 0
+      def valid_x_max_extent?
+        x_max_extent > 0
+      end
+
       # Validate the table and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If table is invalid

data/lib/fontisan/tables/maxp.rb

@@ -157,6 +157,66 @@ module Fontisan
         true
       end
 
+      # Validation helper: Check if version is valid (0.5 or 1.0)
+      #
+      # @return [Boolean] True if version is 0.5 or 1.0
+      def valid_version?
+        version_0_5? || version_1_0?
+      end
+
+      # Validation helper: Check if number of glyphs is valid
+      #
+      # Must be at least 1 (.notdef glyph must exist)
+      #
+      # @return [Boolean] True if num_glyphs >= 1
+      def valid_num_glyphs?
+        num_glyphs && num_glyphs >= 1
+      end
+
+      # Validation helper: Check if maxZones is valid (version 1.0 only)
+      #
+      # For TrueType fonts, maxZones must be 1 or 2
+      #
+      # @return [Boolean] True if maxZones is valid or not applicable
+      def valid_max_zones?
+        return true if version_0_5?  # Not applicable for CFF
+
+        max_zones && max_zones.between?(1, 2)
+      end
+
+      # Validation helper: Check if all TrueType metrics are present
+      #
+      # For version 1.0, all max* fields should be present
+      #
+      # @return [Boolean] True if all required fields are present
+      def has_truetype_metrics?
+        version_1_0? &&
+          !max_points.nil? &&
+          !max_contours.nil? &&
+          !max_composite_points.nil? &&
+          !max_composite_contours.nil?
+      end
+
+      # Validation helper: Check if metrics are reasonable
+      #
+      # Checks that values don't exceed reasonable limits
+      #
+      # @return [Boolean] True if metrics are within reasonable bounds
+      def reasonable_metrics?
+        # num_glyphs should not exceed 65535
+        return false if num_glyphs > 65535
+
+        if version_1_0?
+          # Check reasonable limits for TrueType metrics
+          # These are generous limits to allow for complex fonts
+          return false if max_points && max_points > 50000
+          return false if max_contours && max_contours > 10000
+          return false if max_stack_elements && max_stack_elements > 1000
+        end
+
+        true
+      end
+
       # Validate the table and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If table is invalid