fontisan 0.2.7 → 0.2.9

data/lib/fontisan/models/collection_validation_report.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "font_report"
+require_relative "validation_report"
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # CollectionValidationReport aggregates validation results for all fonts
+    # in a TTC/OTC/dfont collection.
+    #
+    # Provides collection-level summary statistics and per-font validation
+    # details with clear formatting.
+    class CollectionValidationReport < Lutaml::Model::Serializable
+      attribute :collection_path, :string
+      attribute :collection_type, :string
+      attribute :num_fonts, :integer
+      attribute :font_reports, FontReport, collection: true,
+                                           initialize_empty: true
+      attribute :valid, :boolean, default: -> { true }
+
+      key_value do
+        map "collection_path", to: :collection_path
+        map "collection_type", to: :collection_type
+        map "num_fonts", to: :num_fonts
+        map "font_reports", to: :font_reports
+        map "valid", to: :valid
+      end
+
+      # Add a font report to the collection
+      #
+      # @param font_report [FontReport] The font report to add
+      # @return [void]
+      def add_font_report(font_report)
+        font_reports << font_report
+        # Mark that we're no longer using the default value
+        value_set_for(:font_reports)
+        # Update overall validity
+        self.valid = valid && font_report.report.valid?
+      end
+
+      # Get overall validation status for the collection
+      #
+      # @return [String] "valid", "invalid", or "valid_with_warnings"
+      def overall_status
+        return "invalid" unless font_reports.all? { |fr| fr.report.valid? }
+        return "valid_with_warnings" if font_reports.any? do |fr|
+          fr.report.has_warnings?
+        end
+
+        "valid"
+      end
+
+      # Generate text summary with collection header and per-font sections
+      #
+      # @return [String] Formatted validation report
+      def text_summary
+        lines = []
+        lines << "Collection: #{collection_path}"
+        lines << "Type: #{collection_type}"
+        lines << "Fonts: #{num_fonts}"
+        lines << ""
+        lines << "Summary:"
+        lines << "  Total Errors: #{total_errors}"
+        lines << "  Total Warnings: #{total_warnings}"
+        lines << "  Total Info: #{total_info}"
+
+        if font_reports.any?
+          lines << ""
+          font_reports.each do |font_report|
+            lines << "=== Font #{font_report.font_index}: #{font_report.font_name} ==="
+            # Indent each line of the font's report
+            font_lines = font_report.report.text_summary.split("\n")
+            lines.concat(font_lines)
+            lines << "" unless font_report == font_reports.last
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      # Calculate total errors across all fonts
+      #
+      # @return [Integer] Total error count
+      def total_errors
+        font_reports.sum { |fr| fr.report.summary.errors }
+      end
+
+      # Calculate total warnings across all fonts
+      #
+      # @return [Integer] Total warning count
+      def total_warnings
+        font_reports.sum { |fr| fr.report.summary.warnings }
+      end
+
+      # Calculate total info messages across all fonts
+      #
+      # @return [Integer] Total info count
+      def total_info
+        font_reports.sum { |fr| fr.report.summary.info }
+      end
+    end
+  end
+end

data/lib/fontisan/models/font_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "validation_report"
+require "lutaml/model"
+
+module Fontisan
+  module Models
+    # FontReport wraps a single font's validation report with collection context
+    #
+    # Used within CollectionValidationReport to associate validation results
+    # with a specific font index and name in the collection.
+    class FontReport < Lutaml::Model::Serializable
+      attribute :font_index, :integer
+      attribute :font_name, :string
+      attribute :report, ValidationReport
+
+      key_value do
+        map "font_index", to: :font_index
+        map "font_name", to: :font_name
+        map "report", to: :report
+      end
+    end
+  end
+end

data/lib/fontisan/models/validation_report.rb

@@ -101,7 +101,9 @@ module Fontisan
       attribute :status, :string
       attribute :use_case, :string
       attribute :checks_performed, :string, collection: true, default: -> { [] }
-      attribute :check_results, CheckResult, collection: true, default: -> { [] }
+      attribute :check_results, CheckResult, collection: true, default: -> {
+        []
+      }
 
       yaml do
         map "font_path", to: :font_path
@@ -340,7 +342,9 @@ module Fontisan
       # @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 }
+        check_results.select do |cr|
+          cr.table == table_tag.to_s && cr.field == field_name.to_s
+        end
       end
 
       # Check filtering methods
@@ -374,6 +378,7 @@ module Fontisan
       # @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
 

data/lib/fontisan/open_type_font.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-require "bindata"
-require_relative "constants"
-require_relative "loading_modes"
-require_relative "utilities/checksum_calculator"
+require_relative "sfnt_font"
 
 module Fontisan
-  # OpenType Font domain object using BinData
+  # OpenType Font domain object
   #
-  # Represents a complete OpenType Font file (CFF outlines) using BinData's declarative
-  # DSL for binary structure definition. Parallel to TrueTypeFont but for CFF format.
+  # Represents an OpenType Font file (CFF outlines). Inherits all shared
+  # SFNT functionality from SfntFont and adds OpenType-specific behavior
+  # including page-aligned lazy loading for optimal performance.
   #
   # @example Reading and analyzing a font
   #   otf = OpenTypeFont.from_file("font.otf")
@@ -24,29 +22,10 @@ module Fontisan
   #
   # @example Writing a font
   #   otf.to_file("output.otf")
-  class OpenTypeFont < BinData::Record
-    endian :big
-
-    offset_table :header
-    array :tables, type: :table_directory, initial_length: lambda {
-      header.num_tables
-    }
-
-    # Table data is stored separately since it's at variable offsets
-    attr_accessor :table_data
-
-    # Parsed table instances cache
-    attr_accessor :parsed_tables
-
-    # Loading mode for this font (:metadata or :full)
-    attr_accessor :loading_mode
-
-    # IO source for lazy loading
-    attr_accessor :io_source
-
-    # Whether lazy loading is enabled
-    attr_accessor :lazy_load_enabled
-
+  #
+  # @example Reading from TTC collection
+  #   otf = OpenTypeFont.from_collection(io, offset)
+  class OpenTypeFont < SfntFont
     # Page cache for lazy loading (maps page_start_offset => page_data)
     attr_accessor :page_cache
 
@@ -57,7 +36,7 @@ module Fontisan
     #
     # @param path [String] Path to the OTF file
     # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
-    # @param lazy [Boolean] If true, load tables on demand (default: false for eager loading)
+    # @param lazy [Boolean] If true, load tables on demand (default: false)
     # @return [OpenTypeFont] A new instance
     # @raise [ArgumentError] if path is nil or empty, or if mode is invalid
     # @raise [Errno::ENOENT] if file does not exist
@@ -93,167 +72,23 @@ module Fontisan
       raise "Invalid OTF file: #{e.message}"
     end
 
-    # Read OpenType Font from collection at specific offset
-    #
-    # @param io [IO] Open file handle
-    # @param offset [Integer] Byte offset to the font
-    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
-    # @return [OpenTypeFont] A new instance
-    def self.from_collection(io, offset, mode: LoadingModes::FULL)
-      LoadingModes.validate_mode!(mode)
-
-      io.seek(offset)
-      font = read(io)
-      font.initialize_storage
-      font.loading_mode = mode
-      font.read_table_data(io)
-      font
-    end
-
     # Initialize storage hashes
     #
+    # Extends base class to add page_cache for lazy loading.
+    #
     # @return [void]
     def initialize_storage
-      @table_data = {}
-      @parsed_tables = {}
-      @loading_mode = LoadingModes::FULL
-      @lazy_load_enabled = false
-      @io_source = nil
+      super
       @page_cache = {}
     end
 
-    # Read table data for all tables
-    #
-    # In metadata mode, only reads metadata tables. In full mode, reads all tables.
-    # In lazy load mode, doesn't read data upfront.
-    #
-    # @param io [IO] Open file handle
-    # @return [void]
-    def read_table_data(io)
-      @table_data = {}
-
-      if @lazy_load_enabled
-        # Don't read data, just keep IO reference
-        @io_source = io
-        return
-      end
-
-      if @loading_mode == LoadingModes::METADATA
-        # Only read metadata tables for performance
-        # Use page-aware batched reading to maximize filesystem prefetching
-        read_metadata_tables_batched(io)
-      else
-        # Read all tables
-        tables.each do |entry|
-          io.seek(entry.offset)
-          # Force UTF-8 encoding on tag for hash key consistency
-          tag_key = entry.tag.dup.force_encoding("UTF-8")
-          @table_data[tag_key] = io.read(entry.table_length)
-        end
-      end
-    end
-
-    # Read metadata tables using page-aware batching
-    #
-    # Groups adjacent tables within page boundaries and reads them together
-    # to maximize filesystem prefetching and minimize random seeks.
-    #
-    # @param io [IO] Open file handle
-    # @return [void]
-    def read_metadata_tables_batched(io)
-      # Typical filesystem page size (4KB is common, but 8KB gives better prefetch window)
-      page_threshold = 8192
-
-      # Get metadata tables sorted by offset for sequential access
-      metadata_entries = tables.select { |entry| LoadingModes::METADATA_TABLES_SET.include?(entry.tag) }
-      metadata_entries.sort_by!(&:offset)
-
-      return if metadata_entries.empty?
-
-      # Group adjacent tables within page threshold for batched reading
-      i = 0
-      while i < metadata_entries.size
-        batch_start = metadata_entries[i]
-        batch_end = batch_start
-        batch_entries = [batch_start]
-
-        # Extend batch while next table is within page threshold
-        j = i + 1
-        while j < metadata_entries.size
-          next_entry = metadata_entries[j]
-          gap = next_entry.offset - (batch_end.offset + batch_end.table_length)
-
-          # If gap is small (within page threshold), include in batch
-          if gap <= page_threshold
-            batch_end = next_entry
-            batch_entries << next_entry
-            j += 1
-          else
-            break
-          end
-        end
-
-        # Read batch
-        if batch_entries.size == 1
-          # Single table, read normally
-          io.seek(batch_start.offset)
-          tag_key = batch_start.tag.dup.force_encoding("UTF-8")
-          @table_data[tag_key] = io.read(batch_start.table_length)
-        else
-          # Multiple tables, read contiguous segment
-          batch_offset = batch_start.offset
-          batch_length = (batch_end.offset + batch_end.table_length) - batch_start.offset
-
-          io.seek(batch_offset)
-          batch_data = io.read(batch_length)
-
-          # Extract individual tables from batch
-          batch_entries.each do |entry|
-            relative_offset = entry.offset - batch_offset
-            tag_key = entry.tag.dup.force_encoding("UTF-8")
-            @table_data[tag_key] =
-              batch_data[relative_offset, entry.table_length]
-          end
-        end
-
-        i = j
-      end
-    end
-
-    # Write OpenType Font to a file
-    #
-    # Writes the complete OTF structure to disk, including proper checksum
-    # calculation and table alignment.
-    #
-    # @param path [String] Path where the OTF file will be written
-    # @return [Integer] Number of bytes written
-    # @raise [IOError] if writing fails
-    def to_file(path)
-      File.open(path, "wb") do |io|
-        # Write header and tables (directory)
-        write_structure(io)
-
-        # Write table data with updated offsets
-        write_table_data_with_offsets(io)
-
-        io.pos
-      end
-
-      # Update checksum adjustment in head table
-      update_checksum_adjustment_in_file(path) if head_table
-
-      File.size(path)
-    end
-
     # Validate format correctness
     #
+    # Extends base class to check for CFF table (OpenType-specific).
+    #
     # @return [Boolean] true if the OTF format is valid, false otherwise
     def valid?
-      return false unless header
-      return false unless tables.respond_to?(:length)
-      return false unless @table_data.is_a?(Hash)
-      return false if tables.length != header.num_tables
-      return false unless head_table
+      return false unless super
       return false unless has_table?(Constants::CFF_TAG)
 
       true
@@ -273,158 +108,6 @@ module Fontisan
       true
     end
 
-    # Check if font has a specific table
-    #
-    # @param tag [String] The table tag to check for
-    # @return [Boolean] true if table exists, false otherwise
-    def has_table?(tag)
-      tables.any? { |entry| entry.tag == tag }
-    end
-
-    # Check if a table is available in the current loading mode
-    #
-    # @param tag [String] The table tag to check
-    # @return [Boolean] true if table is available in current mode
-    def table_available?(tag)
-      return false unless has_table?(tag)
-
-      LoadingModes.table_allowed?(@loading_mode, tag)
-    end
-
-    # Find a table entry by tag
-    #
-    # @param tag [String] The table tag to find
-    # @return [TableDirectory, nil] The table entry or nil
-    def find_table_entry(tag)
-      tables.find { |entry| entry.tag == tag }
-    end
-
-    # Get the head table entry
-    #
-    # @return [TableDirectory, nil] The head table entry or nil
-    def head_table
-      find_table_entry(Constants::HEAD_TAG)
-    end
-
-    # Get list of all table tags
-    #
-    # @return [Array<String>] Array of table tag strings
-    def table_names
-      tables.map(&:tag)
-    end
-
-    # Get parsed table instance
-    #
-    # This method parses the raw table data into a structured table object
-    # and caches the result for subsequent calls. Enforces mode restrictions.
-    #
-    # @param tag [String] The table tag to retrieve
-    # @return [Tables::*, nil] Parsed table object or nil if not found
-    # @raise [ArgumentError] if table is not available in current loading mode
-    def table(tag)
-      # Check mode restrictions
-      unless table_available?(tag)
-        if has_table?(tag)
-          raise ArgumentError,
-                "Table '#{tag}' is not available in #{@loading_mode} mode. " \
-                "Available tables: #{LoadingModes.tables_for(@loading_mode).inspect}"
-        else
-          return nil
-        end
-      end
-
-      return @parsed_tables[tag] if @parsed_tables.key?(tag)
-
-      # Lazy load table data if enabled
-      if @lazy_load_enabled && !@table_data.key?(tag)
-        load_table_data(tag)
-      end
-
-      @parsed_tables[tag] ||= parse_table(tag)
-    end
-
-    # Get units per em from head table
-    #
-    # @return [Integer, nil] Units per em value
-    def units_per_em
-      head = table(Constants::HEAD_TAG)
-      head&.units_per_em
-    end
-
-    # Convenience methods for accessing common name table fields
-    # These are particularly useful in minimal mode
-
-    # Get font family name
-    #
-    # @return [String, nil] Family name or nil if not found
-    def family_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::FAMILY)
-    end
-
-    # Get font subfamily name (e.g., Regular, Bold, Italic)
-    #
-    # @return [String, nil] Subfamily name or nil if not found
-    def subfamily_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::SUBFAMILY)
-    end
-
-    # Get full font name
-    #
-    # @return [String, nil] Full name or nil if not found
-    def full_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::FULL_NAME)
-    end
-
-    # Get PostScript name
-    #
-    # @return [String, nil] PostScript name or nil if not found
-    def post_script_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::POSTSCRIPT_NAME)
-    end
-
-    # Get preferred family name
-    #
-    # @return [String, nil] Preferred family name or nil if not found
-    def preferred_family_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::PREFERRED_FAMILY)
-    end
-
-    # Get preferred subfamily name
-    #
-    # @return [String, nil] Preferred subfamily name or nil if not found
-    def preferred_subfamily_name
-      name_table = table(Constants::NAME_TAG)
-      name_table&.english_name(Tables::Name::PREFERRED_SUBFAMILY)
-    end
-
-    # Close the IO source (for lazy loading)
-    #
-    # @return [void]
-    def close
-      @io_source&.close
-      @io_source = nil
-    end
-
-    # Setup finalizer for cleanup
-    #
-    # @return [void]
-    def setup_finalizer
-      ObjectSpace.define_finalizer(self, self.class.finalize(@io_source))
-    end
-
-    # Finalizer proc for closing IO
-    #
-    # @param io [IO] The IO object to close
-    # @return [Proc] The finalizer proc
-    def self.finalize(io)
-      proc { io&.close }
-    end
-
     private
 
     # Load a single table's data on demand
@@ -478,22 +161,10 @@ module Fontisan
       @table_data[tag_key] = table_data_parts.join
     end
 
-    # Parse a table from raw data
-    #
-    # @param tag [String] The table tag to parse
-    # @return [Tables::*, nil] Parsed table object or nil
-    def parse_table(tag)
-      raw_data = @table_data[tag]
-      return nil unless raw_data
-
-      table_class = table_class_for(tag)
-      return nil unless table_class
-
-      table_class.read(raw_data)
-    end
-
     # Map table tag to parser class
     #
+    # OpenType-specific mapping includes CFF table.
+    #
     # @param tag [String] The table tag
     # @return [Class, nil] Table parser class or nil
     def table_class_for(tag)
@@ -520,83 +191,5 @@ module Fontisan
         "sbix" => Tables::Sbix,
       }[tag]
     end
-
-    # Write the structure (header + table directory) to IO
-    #
-    # @param io [IO] Open file handle
-    # @return [void]
-    def write_structure(io)
-      # Write header
-      header.write(io)
-
-      # Write table directory with placeholder offsets
-      tables.each do |entry|
-        io.write(entry.tag)
-        io.write([entry.checksum].pack("N"))
-        io.write([0].pack("N")) # Placeholder offset
-        io.write([entry.table_length].pack("N"))
-      end
-    end
-
-    # Write table data and update offsets in directory
-    #
-    # @param io [IO] Open file handle
-    # @return [void]
-    def write_table_data_with_offsets(io)
-      tables.each_with_index do |entry, index|
-        # Record current position
-        current_position = io.pos
-
-        # Write table data
-        data = @table_data[entry.tag]
-        raise IOError, "Missing table data for tag '#{entry.tag}'" if data.nil?
-
-        io.write(data)
-
-        # Add padding to align to 4-byte boundary
-        padding = (Constants::TABLE_ALIGNMENT - (io.pos % Constants::TABLE_ALIGNMENT)) % Constants::TABLE_ALIGNMENT
-        io.write("\x00" * padding) if padding.positive?
-
-        # Zero out checksumAdjustment field in head table
-        if entry.tag == Constants::HEAD_TAG
-          current_pos = io.pos
-          io.seek(current_position + 8)
-          io.write([0].pack("N"))
-          io.seek(current_pos)
-        end
-
-        # Update offset in table directory
-        # Table directory starts at byte 12, each entry is 16 bytes
-        # Offset field is at byte 8 within each entry
-        directory_offset_position = 12 + (index * 16) + 8
-        current_pos = io.pos
-        io.seek(directory_offset_position)
-        io.write([current_position].pack("N"))
-        io.seek(current_pos)
-      end
-    end
-
-    # Update checksumAdjustment field in head table
-    #
-    # @param path [String] Path to the OTF file
-    # @return [void]
-    def update_checksum_adjustment_in_file(path)
-      # Use tempfile-based checksum calculation for Windows compatibility
-      # This keeps the tempfile alive until we're done with the checksum
-      File.open(path, "r+b") do |io|
-        checksum, _tmpfile = Utilities::ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
-
-        # Calculate adjustment
-        adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)
-
-        # Find head table position
-        head_entry = head_table
-        return unless head_entry
-
-        # Write adjustment to head table (offset 8 within head table)
-        io.seek(head_entry.offset + 8)
-        io.write([adjustment].pack("N"))
-      end
-    end
   end
 end

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -151,7 +151,7 @@ module Fontisan
       # @param charstring [String] CharString to search
       # @param pattern [Pattern] pattern to find
       # @return [Array<Integer>] array of start positions
-      def find_pattern_positions(charstring, pattern, glyph_id = nil)
+      def find_pattern_positions(charstring, pattern, _glyph_id = nil)
         positions = []
         offset = 0
 

data/lib/fontisan/optimizers/subroutine_optimizer.rb

@@ -32,7 +32,9 @@ module Fontisan
         selected = []
         # Sort by savings (descending), then by length (descending), then by min glyph ID,
         # then by byte values for complete determinism across platforms
-        remaining = @patterns.sort_by { |p| [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes] }
+        remaining = @patterns.sort_by do |p|
+          [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes]
+        end
 
         remaining.each do |pattern|
           break if selected.length >= @max_subrs
@@ -53,7 +55,9 @@ module Fontisan
       def optimize_ordering(subroutines)
         # Higher frequency = lower ID (shorter encoding)
         # Use same comprehensive sort keys as optimize_selection for consistency
-        subroutines.sort_by { |subr| [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes] }
+        subroutines.sort_by do |subr|
+          [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes]
+        end
       end
 
       # Check if nesting would be beneficial