fontisan 0.2.4 → 0.2.6

data/lib/fontisan/dfont_collection.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "parsers/dfont_parser"
+require_relative "error"
+
+module Fontisan
+  # DfontCollection represents an Apple dfont suitcase containing multiple fonts
+  #
+  # dfont (Data Fork Font) is an Apple-specific format that stores Mac font
+  # suitcase resources in the data fork. It can contain multiple SFNT fonts
+  # (TrueType or OpenType).
+  #
+  # This class provides a collection interface similar to TrueTypeCollection
+  # and OpenTypeCollection for consistency.
+  #
+  # @example Load dfont collection
+  #   collection = DfontCollection.from_file("family.dfont")
+  #   puts "Collection has #{collection.num_fonts} fonts"
+  #
+  # @example Extract fonts from dfont
+  #   File.open("family.dfont", "rb") do |io|
+  #     fonts = collection.extract_fonts(io)
+  #     fonts.each { |font| puts font.class.name }
+  #   end
+  class DfontCollection
+    # Path to dfont file
+    # @return [String]
+    attr_reader :path
+
+    # Number of fonts in collection
+    # @return [Integer]
+    attr_reader :num_fonts
+    alias font_count num_fonts
+
+    # Load dfont collection from file
+    #
+    # @param path [String] Path to dfont file
+    # @return [DfontCollection] Collection object
+    # @raise [InvalidFontError] if not valid dfont
+    def self.from_file(path)
+      File.open(path, "rb") do |io|
+        unless Parsers::DfontParser.dfont?(io)
+          raise InvalidFontError, "Not a valid dfont file: #{path}"
+        end
+
+        num_fonts = Parsers::DfontParser.sfnt_count(io)
+        new(path, num_fonts)
+      end
+    end
+
+    # Initialize collection
+    #
+    # @param path [String] Path to dfont file
+    # @param num_fonts [Integer] Number of fonts
+    # @api private
+    def initialize(path, num_fonts)
+      @path = path
+      @num_fonts = num_fonts
+    end
+
+    # Check if collection is valid
+    #
+    # @return [Boolean] true if valid
+    def valid?
+      File.exist?(@path) && @num_fonts.positive?
+    end
+
+    # Extract all fonts from dfont
+    #
+    # @param io [IO] Open file handle
+    # @return [Array<TrueTypeFont, OpenTypeFont>] Array of fonts
+    def extract_fonts(io)
+      require "stringio"
+
+      fonts = []
+
+      @num_fonts.times do |index|
+        io.rewind
+        sfnt_data = Parsers::DfontParser.extract_sfnt(io, index: index)
+
+        # Load font from SFNT binary
+        sfnt_io = StringIO.new(sfnt_data)
+        signature = sfnt_io.read(4)
+        sfnt_io.rewind
+
+        # Create font based on signature
+        font = case signature
+               when [Constants::SFNT_VERSION_TRUETYPE].pack("N"), "true"
+                 TrueTypeFont.read(sfnt_io)
+               when "OTTO"
+                 OpenTypeFont.read(sfnt_io)
+               else
+                 raise InvalidFontError,
+                       "Invalid SFNT signature in dfont at index #{index}: #{signature.inspect}"
+               end
+
+        font.initialize_storage
+        font.loading_mode = LoadingModes::FULL
+        font.lazy_load_enabled = false
+        font.read_table_data(sfnt_io)
+
+        fonts << font
+      end
+
+      fonts
+    end
+
+    # List fonts in collection (brief info)
+    #
+    # @param io [IO] Open file handle
+    # @return [Models::CollectionListInfo] Collection list info
+    def list_fonts(io)
+      require_relative "models/collection_list_info"
+      require_relative "models/collection_font_summary"
+
+      fonts = extract_fonts(io)
+
+      summaries = fonts.map.with_index do |font, index|
+        name_table = font.table("name")
+        family = name_table.english_name(Models::Tables::Name::FAMILY) || "Unknown"
+        subfamily = name_table.english_name(Models::Tables::Name::SUBFAMILY) || "Regular"
+
+        # Detect font format
+        format = if font.has_table?("CFF ") || font.has_table?("CFF2")
+                   "OpenType"
+                 else
+                   "TrueType"
+                 end
+
+        Models::CollectionFontSummary.new(
+          index: index,
+          family_name: family,
+          subfamily_name: subfamily,
+          font_format: format,
+        )
+      end
+
+      Models::CollectionListInfo.new(
+        num_fonts: @num_fonts,
+        fonts: summaries,
+      )
+    end
+
+    # Get specific font from collection
+    #
+    # @param index [Integer] Font index
+    # @param io [IO] Open file handle
+    # @param mode [Symbol] Loading mode
+    # @return [TrueTypeFont, OpenTypeFont] Font object
+    # @raise [InvalidFontError] if index out of range
+    def font(index, io, mode: LoadingModes::FULL)
+      if index >= @num_fonts
+        raise InvalidFontError,
+              "Font index #{index} out of range (collection has #{@num_fonts} fonts)"
+      end
+
+      io.rewind
+      sfnt_data = Parsers::DfontParser.extract_sfnt(io, index: index)
+
+      # Load font from SFNT binary
+      require "stringio"
+      sfnt_io = StringIO.new(sfnt_data)
+      signature = sfnt_io.read(4)
+      sfnt_io.rewind
+
+      # Create font based on signature
+      font = case signature
+             when [Constants::SFNT_VERSION_TRUETYPE].pack("N"), "true"
+               TrueTypeFont.read(sfnt_io)
+             when "OTTO"
+               OpenTypeFont.read(sfnt_io)
+             else
+               raise InvalidFontError,
+                     "Invalid SFNT signature: #{signature.inspect}"
+             end
+
+      font.initialize_storage
+      font.loading_mode = mode
+      font.lazy_load_enabled = false
+      font.read_table_data(sfnt_io)
+
+      font
+    end
+  end
+end

data/lib/fontisan/font_loader.rb

@@ -63,7 +63,7 @@ module Fontisan
         when Constants::TTC_TAG
           load_from_collection(io, path, font_index, mode: resolved_mode,
                                                      lazy: resolved_lazy)
-        when pack_uint32(Constants::SFNT_VERSION_TRUETYPE)
+        when pack_uint32(Constants::SFNT_VERSION_TRUETYPE), "true"
           TrueTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "OTTO"
           OpenTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
@@ -71,6 +71,8 @@ module Fontisan
           WoffFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "wOF2"
           Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
+        when Constants::DFONT_RESOURCE_HEADER
+          extract_and_load_dfont(io, path, font_index, resolved_mode, resolved_lazy)
         else
           raise InvalidFontError,
                 "Unknown font format. Expected TTF, OTF, TTC, OTC, WOFF, or WOFF2 file."
@@ -92,13 +94,25 @@ module Fontisan
 
       File.open(path, "rb") do |io|
         signature = io.read(4)
-        signature == Constants::TTC_TAG
+        io.rewind
+
+        # Check for TTC/OTC signature
+        return true if signature == Constants::TTC_TAG
+
+        # Check for multi-font dfont (suitcase) - only if it's actually a dfont
+        if signature == Constants::DFONT_RESOURCE_HEADER
+          require_relative "parsers/dfont_parser"
+          # Verify it's a valid dfont and has multiple fonts
+          return Parsers::DfontParser.dfont?(io) && Parsers::DfontParser.sfnt_count(io) > 1
+        end
+
+        false
       end
     end
 
     # Load a collection object without extracting fonts
     #
-    # Returns the collection object (TrueTypeCollection or OpenTypeCollection)
+    # Returns the collection object (TrueTypeCollection, OpenTypeCollection, or DfontCollection)
     # without extracting individual fonts. Useful for inspecting collection
     # metadata and structure.
     #
@@ -112,6 +126,10 @@ module Fontisan
     # - OTC typically contains OpenType fonts (CFF/CFF2 outlines)
     # - Mixed collections are possible (both TTF and OTF in same collection)
     #
+    # dfont (Data Fork Font) is an Apple-specific format that contains Mac
+    # font suitcase resources. It can contain multiple SFNT fonts (TrueType
+    # or OpenType).
+    #
     # Each collection can contain multiple SFNT-format font files, with table
     # deduplication to save space. Individual fonts within a collection are
     # stored at different offsets within the file, each with their own table
@@ -128,13 +146,16 @@ module Fontisan
     # 4. If ANY font is OpenType (CFF), returns OpenTypeCollection
     # 5. Only returns TrueTypeCollection if ALL fonts are TrueType
     #
+    # For dfont files, returns DfontCollection.
+    #
     # This approach correctly handles:
     # - Homogeneous collections (all TTF or all OTF)
     # - Mixed collections (both TTF and OTF fonts) - uses OpenTypeCollection
     # - Large collections with many fonts (like NotoSerifCJK.ttc with 35 fonts)
+    # - dfont suitcases (Apple-specific)
     #
     # @param path [String] Path to the collection file
-    # @return [TrueTypeCollection, OpenTypeCollection] The collection object
+    # @return [TrueTypeCollection, OpenTypeCollection, DfontCollection] The collection object
     # @raise [Errno::ENOENT] if file does not exist
     # @raise [InvalidFontError] if file is not a collection or type cannot be determined
     #
@@ -146,10 +167,18 @@ module Fontisan
 
       File.open(path, "rb") do |io|
         signature = io.read(4)
+        io.rewind
+
+        # Check for dfont
+        if signature == Constants::DFONT_RESOURCE_HEADER || dfont_signature?(io)
+          require_relative "dfont_collection"
+          return DfontCollection.from_file(path)
+        end
 
+        # Check for TTC/OTC
         unless signature == Constants::TTC_TAG
           raise InvalidFontError,
-                "File is not a collection (TTC/OTC). Use FontLoader.load instead."
+                "File is not a collection (TTC/OTC/dfont). Use FontLoader.load instead."
         end
 
         # Read version and num_fonts
@@ -291,6 +320,50 @@ mode: LoadingModes::FULL, lazy: true)
       end
     end
 
+    # Extract and load font from dfont resource fork
+    #
+    # @param io [IO] Open file handle
+    # @param path [String] Path to dfont file
+    # @param font_index [Integer] Font index in suitcase
+    # @param mode [Symbol] Loading mode
+    # @param lazy [Boolean] Lazy loading flag
+    # @return [TrueTypeFont, OpenTypeFont] Loaded font
+    # @api private
+    def self.extract_and_load_dfont(io, path, font_index, mode, lazy)
+      require_relative "parsers/dfont_parser"
+
+      # Extract SFNT data from resource fork
+      sfnt_data = Parsers::DfontParser.extract_sfnt(io, index: font_index)
+
+      # Create StringIO with SFNT data
+      sfnt_io = StringIO.new(sfnt_data)
+
+      # Detect SFNT signature
+      signature = sfnt_io.read(4)
+      sfnt_io.rewind
+
+      # Read and setup font based on signature
+      case signature
+      when pack_uint32(Constants::SFNT_VERSION_TRUETYPE), "true"
+        font = TrueTypeFont.read(sfnt_io)
+        font.initialize_storage
+        font.loading_mode = mode
+        font.lazy_load_enabled = lazy
+        font.read_table_data(sfnt_io) unless lazy
+        font
+      when "OTTO"
+        font = OpenTypeFont.read(sfnt_io)
+        font.initialize_storage
+        font.loading_mode = mode
+        font.lazy_load_enabled = lazy
+        font.read_table_data(sfnt_io) unless lazy
+        font
+      else
+        raise InvalidFontError,
+              "Invalid SFNT data in dfont resource (signature: #{signature.inspect})"
+      end
+    end
+
     # Pack uint32 value to big-endian bytes
     #
     # @param value [Integer] The uint32 value
@@ -301,6 +374,18 @@ mode: LoadingModes::FULL, lazy: true)
     end
 
     private_class_method :load_from_collection, :pack_uint32, :env_mode,
-                         :env_lazy
+                         :env_lazy, :extract_and_load_dfont
+
+    # Check if file has dfont signature
+    #
+    # @param io [IO] Open file handle
+    # @return [Boolean] true if dfont
+    # @api private
+    def self.dfont_signature?(io)
+      require_relative "parsers/dfont_parser"
+      Parsers::DfontParser.dfont?(io)
+    end
+
+    private_class_method :dfont_signature?
   end
 end

data/lib/fontisan/models/validation_report.rb

@@ -46,6 +46,34 @@ module Fontisan
         end
       end
 
+      # Individual check result from DSL-based validation
+      class CheckResult < Lutaml::Model::Serializable
+        attribute :check_id, :string
+        attribute :passed, :boolean
+        attribute :severity, :string
+        attribute :messages, :string, collection: true, default: -> { [] }
+        attribute :table, :string
+        attribute :field, :string
+
+        yaml do
+          map "check_id", to: :check_id
+          map "passed", to: :passed
+          map "severity", to: :severity
+          map "messages", to: :messages
+          map "table", to: :table
+          map "field", to: :field
+        end
+
+        json do
+          map "check_id", to: :check_id
+          map "passed", to: :passed
+          map "severity", to: :severity
+          map "messages", to: :messages
+          map "table", to: :table
+          map "field", to: :field
+        end
+      end
+
       # Validation summary counts
       class Summary < Lutaml::Model::Serializable
         attribute :errors, :integer, default: -> { 0 }
@@ -69,12 +97,22 @@ module Fontisan
       attribute :valid, :boolean
       attribute :issues, Issue, collection: true, default: -> { [] }
       attribute :summary, Summary, default: -> { Summary.new }
+      attribute :profile, :string
+      attribute :status, :string
+      attribute :use_case, :string
+      attribute :checks_performed, :string, collection: true, default: -> { [] }
+      attribute :check_results, CheckResult, collection: true, default: -> { [] }
 
       yaml do
         map "font_path", to: :font_path
         map "valid", to: :valid
         map "summary", to: :summary
         map "issues", to: :issues
+        map "profile", to: :profile
+        map "status", to: :status
+        map "use_case", to: :use_case
+        map "checks_performed", to: :checks_performed
+        map "check_results", to: :check_results
       end
 
       json do
@@ -82,6 +120,11 @@ module Fontisan
         map "valid", to: :valid
         map "summary", to: :summary
         map "issues", to: :issues
+        map "profile", to: :profile
+        map "status", to: :status
+        map "use_case", to: :use_case
+        map "checks_performed", to: :checks_performed
+        map "check_results", to: :check_results
       end
 
       # Add an error to the report
@@ -198,6 +241,190 @@ module Fontisan
 
         lines.join("\n")
       end
+
+      # Check if font passed validation (alias for valid)
+      #
+      # @return [Boolean] true if font passed validation
+      def passed?
+        valid
+      end
+
+      # Check if font is valid (alias for valid attribute)
+      #
+      # @return [Boolean] true if font is valid
+      def valid?
+        valid
+      end
+
+      # Get result for a specific check by ID
+      #
+      # @param check_id [Symbol, String] The check identifier
+      # @return [CheckResult, nil] The check result or nil if not found
+      def result_of(check_id)
+        check_results.find { |cr| cr.check_id == check_id.to_s }
+      end
+
+      # Get all passed checks
+      #
+      # @return [Array<CheckResult>] Array of passed checks
+      def passed_checks
+        check_results.select(&:passed)
+      end
+
+      # Get all failed checks
+      #
+      # @return [Array<CheckResult>] Array of failed checks
+      def failed_checks
+        check_results.reject(&:passed)
+      end
+
+      # Severity filtering methods
+
+      # Get issues by severity level
+      #
+      # @param severity [Symbol, String] Severity level
+      # @return [Array<Issue>] Array of issues with the specified severity
+      def issues_by_severity(severity)
+        issues.select { |issue| issue.severity == severity.to_s }
+      end
+
+      # Get fatal error issues
+      #
+      # @return [Array<Issue>] Array of fatal error issues
+      def fatal_errors
+        issues_by_severity(:fatal)
+      end
+
+      # Get error issues only
+      #
+      # @return [Array<Issue>] Array of error issues
+      def errors_only
+        issues_by_severity(:error)
+      end
+
+      # Get warning issues only
+      #
+      # @return [Array<Issue>] Array of warning issues
+      def warnings_only
+        issues_by_severity(:warning)
+      end
+
+      # Get info issues only
+      #
+      # @return [Array<Issue>] Array of info issues
+      def info_only
+        issues_by_severity(:info)
+      end
+
+      # Category filtering methods
+
+      # Get issues by category
+      #
+      # @param category [String] Category name
+      # @return [Array<Issue>] Array of issues in the specified category
+      def issues_by_category(category)
+        issues.select { |issue| issue.category == category.to_s }
+      end
+
+      # Get check results for a specific table
+      #
+      # @param table_tag [String] Table tag (e.g., 'name', 'head')
+      # @return [Array<CheckResult>] Array of check results for the table
+      def table_issues(table_tag)
+        check_results.select { |cr| cr.table == table_tag.to_s }
+      end
+
+      # Get check results for a specific field in a table
+      #
+      # @param table_tag [String] Table tag
+      # @param field_name [String, Symbol] Field name
+      # @return [Array<CheckResult>] Array of check results for the field
+      def field_issues(table_tag, field_name)
+        check_results.select { |cr| cr.table == table_tag.to_s && cr.field == field_name.to_s }
+      end
+
+      # Check filtering methods
+
+      # Get checks by status
+      #
+      # @param passed [Boolean] true for passed checks, false for failed checks
+      # @return [Array<CheckResult>] Array of checks with the specified status
+      def checks_by_status(passed:)
+        check_results.select { |cr| cr.passed == passed }
+      end
+
+      # Get IDs of failed checks
+      #
+      # @return [Array<String>] Array of failed check IDs
+      def failed_check_ids
+        failed_checks.map(&:check_id)
+      end
+
+      # Get IDs of passed checks
+      #
+      # @return [Array<String>] Array of passed check IDs
+      def passed_check_ids
+        passed_checks.map(&:check_id)
+      end
+
+      # Statistics methods
+
+      # Calculate failure rate as percentage
+      #
+      # @return [Float] Failure rate (0.0 to 1.0)
+      def failure_rate
+        return 0.0 if check_results.empty?
+        failed_checks.length.to_f / check_results.length
+      end
+
+      # Calculate pass rate as percentage
+      #
+      # @return [Float] Pass rate (0.0 to 1.0)
+      def pass_rate
+        1.0 - failure_rate
+      end
+
+      # Get severity distribution
+      #
+      # @return [Hash] Hash with :errors, :warnings, :info counts
+      def severity_distribution
+        {
+          errors: summary.errors,
+          warnings: summary.warnings,
+          info: summary.info,
+        }
+      end
+
+      # Export format methods
+
+      # Generate full detailed text report
+      #
+      # @return [String] Detailed text report
+      def to_text_report
+        text_summary
+      end
+
+      # Generate brief summary
+      #
+      # @return [String] Brief summary string
+      def to_summary
+        "#{summary.errors} errors, #{summary.warnings} warnings, #{summary.info} info"
+      end
+
+      # Generate tabular format for CLI
+      #
+      # @return [String] Tabular format output
+      def to_table_format
+        lines = []
+        lines << "CHECK_ID | STATUS | SEVERITY | TABLE"
+        lines << "-" * 60
+        check_results.each do |cr|
+          status = cr.passed ? "PASS" : "FAIL"
+          table = cr.table || "N/A"
+          lines << "#{cr.check_id} | #{status} | #{cr.severity} | #{table}"
+        end
+        lines.join("\n")
+      end
     end
   end
 end