fontisan 0.2.7 → 0.2.9

data/lib/fontisan/true_type_font.rb

@@ -1,42 +1,17 @@
 # frozen_string_literal: true
 
-require "bindata"
-require_relative "constants"
-require_relative "loading_modes"
-require_relative "utilities/checksum_calculator"
+require_relative "sfnt_font"
 
 module Fontisan
-  # TTF Offset Table structure
-  class OffsetTable < BinData::Record
-    endian :big
-    uint32 :sfnt_version
-    uint16 :num_tables
-    uint16 :search_range
-    uint16 :entry_selector
-    uint16 :range_shift
-  end
-
-  # TTF Table Directory Entry structure
-  class TableDirectory < BinData::Record
-    endian :big
-    string :tag, length: 4
-    uint32 :checksum
-    uint32 :offset
-    uint32 :table_length
-  end
-
-  # TrueType Font domain object using BinData
-  #
-  # Represents a complete TrueType Font file using BinData's declarative
-  # DSL for binary structure definition. The structure definition IS the
-  # documentation, and BinData handles all low-level reading/writing.
+  # TrueType Font domain object
   #
-  # Extended from ExtractTTC to support table parsing for analysis.
+  # Represents a TrueType Font file (glyf outlines). Inherits all shared
+  # SFNT functionality from SfntFont and adds TrueType-specific behavior.
   #
   # @example Reading and analyzing a font
   #   ttf = TrueTypeFont.from_file("font.ttf")
   #   puts ttf.header.num_tables  # => 14
-  #   name_table = ttf.table("name")  # Fontisan extension
+  #   name_table = ttf.table("name")
   #   puts name_table.english_name(Tables::Name::FAMILY)
   #
   # @example Loading with metadata mode
@@ -46,34 +21,15 @@ module Fontisan
   #
   # @example Writing a font
   #   ttf.to_file("output.ttf")
-  class TrueTypeFont < 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 (Fontisan extension)
-    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
+  #   ttf = TrueTypeFont.from_ttc(io, offset)
+  class TrueTypeFont < SfntFont
     # Read TrueType Font from a file
     #
     # @param path [String] Path to the TTF 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 [TrueTypeFont] A new instance
     # @raise [ArgumentError] if path is nil or empty, or if mode is invalid
     # @raise [Errno::ENOENT] if file does not exist
@@ -127,153 +83,6 @@ module Fontisan
       font
     end
 
-    # Initialize storage hashes (Fontisan extension)
-    #
-    # @return [void]
-    def initialize_storage
-      @table_data = {}
-      @parsed_tables = {}
-      @loading_mode = LoadingModes::FULL
-      @lazy_load_enabled = false
-      @io_source = nil
-    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 TrueType Font to a file
-    #
-    # Writes the complete TTF structure to disk, including proper checksum
-    # calculation and table alignment.
-    #
-    # @param path [String] Path where the TTF 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
-    #
-    # @return [Boolean] true if the TTF 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
-
-      true
-    end
-
     # Check if font is TrueType flavored
     #
     # @return [Boolean] true for TrueType fonts
@@ -288,194 +97,11 @@ module Fontisan
       false
     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 (Fontisan extension)
-    #
-    # @return [Array<String>] Array of table tag strings
-    def table_names
-      tables.map(&:tag)
-    end
-
-    # Get parsed table instance (Fontisan extension)
-    #
-    # 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 (Fontisan extension)
-    #
-    # @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
-    #
-    # Uses direct seek-and-read for minimal overhead. This ensures lazy loading
-    # performance is comparable to eager loading when accessing all tables.
+    # Map table tag to parser class
     #
-    # @param tag [String] The table tag to load
-    # @return [void]
-    def load_table_data(tag)
-      return unless @io_source
-
-      entry = find_table_entry(tag)
-      return nil unless entry
-
-      # Direct seek and read - same as eager loading but on-demand
-      @io_source.seek(entry.offset)
-      tag_key = tag.dup.force_encoding("UTF-8")
-      @table_data[tag_key] = @io_source.read(entry.table_length)
-    end
-
-    # Parse a table from raw data (Fontisan extension)
-    #
-    # @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 (Fontisan extension)
+    # TrueType-specific mapping includes glyf/loca tables.
     #
     # @param tag [String] The table tag
     # @return [Class, nil] Table parser class or nil
@@ -502,83 +128,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")) # Offset is now known
-        io.seek(current_pos)
-      end
-    end
-
-    # Update checksumAdjustment field in head table
-    #
-    # @param path [String] Path to the TTF 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/utilities/checksum_calculator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "stringio"
-require "tempfile"
 require_relative "../constants"
 
 module Fontisan
@@ -101,49 +100,6 @@ module Fontisan
 
         sum
       end
-
-      # Calculate checksum from an IO object using a tempfile for Windows compatibility.
-      #
-      # This method creates a temporary file from the IO content to ensure proper
-      # file handle semantics on Windows, where file handles must remain open
-      # for checksum calculation. The tempfile reference is returned alongside
-      # the checksum to prevent premature garbage collection on Windows.
-      #
-      # @param io [IO] the IO object to read from (must be rewindable)
-      # @return [Array<Integer, Tempfile>] array containing [checksum, tempfile]
-      #   The checksum value and the tempfile that must be kept alive until
-      #   the caller is done with the checksum.
-      #
-      # @example
-      #   checksum, tmpfile = ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
-      #   # Use checksum...
-      #   # tmpfile will be GC'd when it goes out of scope, which is safe
-      #
-      # @note On Windows, Ruby's Tempfile automatically deletes the temp file when
-      #   the Tempfile object is garbage collected. In multi-threaded environments,
-      #   this can cause PermissionDenied errors if the file is deleted while
-      #   another thread is still using it. By returning the tempfile reference,
-      #   the caller can ensure it remains alive until all operations complete.
-      def self.calculate_checksum_from_io_with_tempfile(io)
-        io.rewind
-
-        # Create a tempfile to handle Windows file locking issues
-        tmpfile = Tempfile.new(["font", ".ttf"])
-        tmpfile.binmode
-
-        # Copy IO content to tempfile
-        IO.copy_stream(io, tmpfile)
-        tmpfile.close
-
-        # Calculate checksum from the tempfile
-        checksum = calculate_file_checksum(tmpfile.path)
-
-        # Return both checksum and tempfile to keep it alive
-        # The caller must keep the tempfile reference until done with checksum
-        [checksum, tmpfile]
-      end
-
-      private_class_method :calculate_checksum_from_io
     end
   end
 end

data/lib/fontisan/validation/collection_validator.rb

@@ -68,7 +68,8 @@ module Fontisan
         issues = []
 
         return ["Font array cannot be empty"] if fonts.nil? || fonts.empty?
-        return ["Invalid format: #{format}"] unless %i[ttc otc dfont].include?(format)
+        return ["Invalid format: #{format}"] unless %i[ttc otc
+                                                       dfont].include?(format)
 
         case format
         when :ttc
@@ -100,7 +101,8 @@ module Fontisan
       # @raise [ArgumentError] if invalid
       def validate_format!(format)
         unless %i[ttc otc dfont].include?(format)
-          raise ArgumentError, "Invalid format: #{format}. Must be :ttc, :otc, or :dfont"
+          raise ArgumentError,
+                "Invalid format: #{format}. Must be :ttc, :otc, or :dfont"
         end
       end
 

data/lib/fontisan/validators/basic_validator.rb

@@ -46,39 +46,29 @@ module Fontisan
         end
 
         # Check 2: Name table version must be valid (0 or 1)
-        check_table :name_version, "name", severity: :error do |table|
-          table.valid_version?
-        end
+        check_table :name_version, "name", severity: :error, &:valid_version?
 
         # Check 3: Family name must be present and non-empty
-        check_table :family_name, "name", severity: :error do |table|
-          table.family_name_present?
-        end
+        check_table :family_name, "name", severity: :error,
+                    &:family_name_present?
 
         # Check 4: PostScript name must be valid (alphanumeric + hyphens)
-        check_table :postscript_name, "name", severity: :error do |table|
-          table.postscript_name_valid?
-        end
+        check_table :postscript_name, "name", severity: :error,
+                    &:postscript_name_valid?
 
         # Check 5: Head table magic number must be correct
-        check_table :head_magic, "head", severity: :error do |table|
-          table.valid_magic?
-        end
+        check_table :head_magic, "head", severity: :error, &:valid_magic?
 
         # Check 6: Units per em must be valid (16-16384)
-        check_table :units_per_em, "head", severity: :error do |table|
-          table.valid_units_per_em?
-        end
+        check_table :units_per_em, "head", severity: :error,
+                    &:valid_units_per_em?
 
         # Check 7: Number of glyphs must be at least 1 (.notdef)
-        check_table :num_glyphs, "maxp", severity: :error do |table|
-          table.valid_num_glyphs?
-        end
+        check_table :num_glyphs, "maxp", severity: :error, &:valid_num_glyphs?
 
         # Check 8: Maxp metrics should be reasonable (not absurd values)
-        check_table :reasonable_metrics, "maxp", severity: :warning do |table|
-          table.reasonable_metrics?
-        end
+        check_table :reasonable_metrics, "maxp", severity: :warning,
+                    &:reasonable_metrics?
       end
     end
   end