fontisan 0.2.2 → 0.2.4

data/lib/fontisan/tables/svg.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "zlib"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # SVG (Scalable Vector Graphics) table parser
+    #
+    # The SVG table contains embedded SVG documents for glyphs, typically used
+    # for color emoji or graphic elements. Each document can cover a range of
+    # glyph IDs and may be compressed with gzip.
+    #
+    # SVG Table Structure:
+    # ```
+    # SVG Table = Header (10 bytes)
+    #           + Document Index
+    #           + SVG Documents
+    # ```
+    #
+    # Header (10 bytes):
+    # - version (uint16): Table version (0)
+    # - svgDocumentListOffset (uint32): Offset to SVG Document Index
+    # - reserved (uint32): Reserved, set to 0
+    #
+    # Document Index:
+    # - numEntries (uint16): Number of SVG Document Index Entries
+    # - entries[numEntries]: Array of SVG Document Index Entries
+    #
+    # SVG Document Index Entry (12 bytes):
+    # - startGlyphID (uint16): First glyph ID
+    # - endGlyphID (uint16): Last glyph ID (inclusive)
+    # - svgDocOffset (uint32): Offset to SVG document
+    # - svgDocLength (uint32): Length of SVG document
+    #
+    # SVG documents may be compressed with gzip (identified by magic bytes 0x1f 0x8b).
+    #
+    # Reference: OpenType SVG specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/svg
+    #
+    # @example Reading an SVG table
+    #   data = font.table_data['SVG ']
+    #   svg = Fontisan::Tables::Svg.read(data)
+    #   svg_content = svg.svg_for_glyph(42)
+    #   puts "Glyph 42 SVG: #{svg_content}"
+    class Svg < Binary::BaseRecord
+      # OpenType table tag for SVG (note: includes trailing space)
+      TAG = "SVG "
+
+      # SVG Document Index Entry structure
+      #
+      # Each entry associates a glyph range with an SVG document.
+      # Structure (12 bytes): start_glyph_id, end_glyph_id, svg_doc_offset, svg_doc_length
+      class SvgDocumentRecord < Binary::BaseRecord
+        endian :big
+        uint16 :start_glyph_id
+        uint16 :end_glyph_id
+        uint32 :svg_doc_offset
+        uint32 :svg_doc_length
+
+        # Check if this record includes a specific glyph ID
+        #
+        # @param glyph_id [Integer] Glyph ID to check
+        # @return [Boolean] True if glyph is in range
+        def includes_glyph?(glyph_id)
+          glyph_id >= start_glyph_id && glyph_id <= end_glyph_id
+        end
+
+        # Get the glyph range for this record
+        #
+        # @return [Range] Range of glyph IDs
+        def glyph_range
+          start_glyph_id..end_glyph_id
+        end
+      end
+
+      # @return [Integer] SVG table version (0)
+      attr_reader :version
+
+      # @return [Integer] Offset to SVG Document Index
+      attr_reader :svg_document_list_offset
+
+      # @return [Integer] Number of SVG document entries
+      attr_reader :num_entries
+
+      # @return [Array<SvgDocumentRecord>] Parsed document records
+      attr_reader :document_records
+
+      # @return [String] Raw binary data for the entire SVG table
+      attr_reader :raw_data
+
+      # Override read to parse SVG structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Svg] Parsed SVG table
+      def self.read(io)
+        svg = new
+        return svg if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        svg.parse!(data)
+        svg
+      end
+
+      # Parse the SVG table structure
+      #
+      # @param data [String] Binary data for the SVG table
+      # @raise [CorruptedTableError] If SVG structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse SVG header (10 bytes)
+        parse_header(io)
+        validate_header!
+
+        # Parse document index
+        parse_document_index(io)
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse SVG table: #{e.message}"
+      end
+
+      # Get SVG document for a specific glyph ID
+      #
+      # Returns the SVG XML content for the specified glyph.
+      # Automatically decompresses gzipped content.
+      # Returns nil if glyph has no SVG data.
+      #
+      # @param glyph_id [Integer] Glyph ID to look up
+      # @return [String, nil] SVG XML content or nil
+      def svg_for_glyph(glyph_id)
+        record = find_document_record(glyph_id)
+        return nil unless record
+
+        extract_svg_document(record)
+      end
+
+      # Check if glyph has SVG data
+      #
+      # @param glyph_id [Integer] Glyph ID to check
+      # @return [Boolean] True if glyph has SVG
+      def has_svg_for_glyph?(glyph_id)
+        !find_document_record(glyph_id).nil?
+      end
+
+      # Get all glyph IDs that have SVG data
+      #
+      # @return [Array<Integer>] Array of glyph IDs with SVG
+      def glyph_ids_with_svg
+        document_records.flat_map do |record|
+          record.glyph_range.to_a
+        end
+      end
+
+      # Get the number of SVG documents in this table
+      #
+      # @return [Integer] Number of SVG documents
+      def num_svg_documents
+        num_entries
+      end
+
+      # Validate the SVG table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if version.nil?
+        return false if version != 0 # Only version 0 supported
+        return false if num_entries.nil? || num_entries.negative?
+        return false unless document_records
+
+        true
+      end
+
+      private
+
+      # Parse SVG header (10 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @version = io.read(2).unpack1("n")
+        @svg_document_list_offset = io.read(4).unpack1("N")
+        @reserved = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless version.zero?
+          raise CorruptedTableError,
+                "Unsupported SVG version: #{version} (only version 0 supported)"
+        end
+
+        if svg_document_list_offset > raw_data.length
+          raise CorruptedTableError,
+                "Invalid svgDocumentListOffset: #{svg_document_list_offset}"
+        end
+      end
+
+      # Parse document index
+      #
+      # @param io [StringIO] Input stream
+      def parse_document_index(io)
+        # Seek to document index
+        io.seek(svg_document_list_offset)
+
+        # Check if there's enough data to read num_entries
+        return if io.eof?
+
+        # Parse number of entries
+        num_entries_data = io.read(2)
+        return if num_entries_data.nil? || num_entries_data.length < 2
+
+        @num_entries = num_entries_data.unpack1("n")
+        @document_records = []
+
+        return if num_entries.zero?
+
+        # Parse each document record (12 bytes each)
+        num_entries.times do
+          record_data = io.read(12)
+          record = SvgDocumentRecord.read(record_data)
+          @document_records << record
+        end
+      end
+
+      # Find document record for a specific glyph ID
+      #
+      # Uses binary search since document records should be sorted by glyph ID.
+      #
+      # @param glyph_id [Integer] Glyph ID to find
+      # @return [SvgDocumentRecord, nil] Document record or nil if not found
+      def find_document_record(glyph_id)
+        # Binary search through document records
+        left = 0
+        right = document_records.length - 1
+
+        while left <= right
+          mid = (left + right) / 2
+          record = document_records[mid]
+
+          if record.includes_glyph?(glyph_id)
+            return record
+          elsif glyph_id < record.start_glyph_id
+            right = mid - 1
+          else
+            left = mid + 1
+          end
+        end
+
+        nil
+      end
+
+      # Extract SVG document from record
+      #
+      # Calculates absolute offset and extracts SVG data.
+      # Automatically decompresses gzipped content.
+      #
+      # @param record [SvgDocumentRecord] Document record
+      # @return [String] SVG XML content
+      def extract_svg_document(record)
+        # Calculate absolute offset
+        # Offset is relative to start of SVG Document List
+        # Document List = numEntries (2 bytes) + entries array + documents
+        documents_offset = svg_document_list_offset + 2 + (num_entries * 12)
+        absolute_offset = documents_offset + record.svg_doc_offset
+
+        # Extract SVG data
+        svg_data = raw_data[absolute_offset, record.svg_doc_length]
+
+        # Check if compressed (gzip magic bytes: 0x1f 0x8b)
+        if gzipped?(svg_data)
+          decompress_gzip(svg_data)
+        else
+          svg_data
+        end
+      end
+
+      # Check if data is gzipped
+      #
+      # @param data [String] Binary data
+      # @return [Boolean] True if gzipped
+      def gzipped?(data)
+        return false if data.nil? || data.length < 2
+
+        data[0..1].unpack("C*") == [0x1f, 0x8b]
+      end
+
+      # Decompress gzipped data
+      #
+      # @param data [String] Gzipped binary data
+      # @return [String] Decompressed data
+      def decompress_gzip(data)
+        Zlib::GzipReader.new(StringIO.new(data)).read
+      rescue Zlib::Error => e
+        raise CorruptedTableError, "Failed to decompress SVG data: #{e.message}"
+      end
+    end
+  end
+end

data/lib/fontisan/true_type_collection.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require "bindata"
-require_relative "constants"
+require_relative "base_collection"
 
 module Fontisan
-  # TrueType Collection domain object using BinData
+  # TrueType Collection domain object
   #
-  # Represents a complete TrueType Collection file using BinData's declarative
-  # DSL for binary structure definition. The structure definition IS the
-  # documentation, and BinData handles all low-level reading/writing.
+  # Represents a complete TrueType Collection file. Inherits all shared
+  # functionality from BaseCollection and implements TTC-specific behavior.
   #
   # @example Reading and extracting fonts
   #   File.open("Helvetica.ttc", "rb") do |io|
@@ -16,51 +14,25 @@ module Fontisan
   #     puts ttc.num_fonts  # => 6
   #     fonts = ttc.extract_fonts(io)  # => [TrueTypeFont, TrueTypeFont, ...]
   #   end
-  class TrueTypeCollection < BinData::Record
-    endian :big
-
-    string :tag, length: 4, assert: "ttcf"
-    uint16 :major_version
-    uint16 :minor_version
-    uint32 :num_fonts
-    array :font_offsets, type: :uint32, initial_length: :num_fonts
-
-    # Read TrueType Collection from a file
+  class TrueTypeCollection < BaseCollection
+    # Get the font class for TrueType collections
     #
-    # @param path [String] Path to the TTC file
-    # @return [TrueTypeCollection] A new instance
-    # @raise [ArgumentError] if path is nil or empty
-    # @raise [Errno::ENOENT] if file does not exist
-    # @raise [RuntimeError] if file format is invalid
-    def self.from_file(path)
-      if path.nil? || path.to_s.empty?
-        raise ArgumentError,
-              "path cannot be nil or empty"
-      end
-      raise Errno::ENOENT, "File not found: #{path}" unless File.exist?(path)
-
-      File.open(path, "rb") { |io| read(io) }
-    rescue BinData::ValidityError => e
-      raise "Invalid TTC file: #{e.message}"
-    rescue EOFError => e
-      raise "Invalid TTC file: unexpected end of file - #{e.message}"
+    # @return [Class] TrueTypeFont class
+    def self.font_class
+      require_relative "true_type_font"
+      TrueTypeFont
     end
 
-    # Extract fonts as TrueTypeFont objects
+    # Get the collection format identifier
     #
-    # Reads each font from the TTC file and returns them as TrueTypeFont objects.
-    #
-    # @param io [IO] Open file handle to read fonts from
-    # @return [Array<TrueTypeFont>] Array of font objects
-    def extract_fonts(io)
-      require_relative "true_type_font"
-
-      font_offsets.map do |offset|
-        TrueTypeFont.from_ttc(io, offset)
-      end
+    # @return [String] "TTC" for TrueType Collection
+    def self.collection_format
+      "TTC"
     end
 
-    # Get a single font from the collection (Fontisan extension)
+    # Get a single font from the collection
+    #
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param index [Integer] Index of the font (0-based)
     # @param io [IO] Open file handle
@@ -73,43 +45,27 @@ module Fontisan
       TrueTypeFont.from_ttc(io, font_offsets[index], mode: mode)
     end
 
-    # Get font count (Fontisan extension)
+    # Extract fonts as TrueTypeFont objects
     #
-    # @return [Integer] Number of fonts in collection
-    def font_count
-      num_fonts
-    end
-
-    # Validate format correctness
+    # Reads each font from the TTC file and returns them as TrueTypeFont objects.
+    # This method uses the TTC-specific from_ttc method.
     #
-    # @return [Boolean] true if the format is valid, false otherwise
-    def valid?
-      tag == Constants::TTC_TAG && num_fonts.positive? && font_offsets.length == num_fonts
-    rescue StandardError
-      false
-    end
+    # @param io [IO] Open file handle to read fonts from
+    # @return [Array<TrueTypeFont>] Array of font objects
+    def extract_fonts(io)
+      require_relative "true_type_font"
 
-    # Get the TTC version as a single integer
-    #
-    #  @return [Integer] Version number (e.g., 0x00010000 for version 1.0)
-    def version
-      (major_version << 16) | minor_version
+      font_offsets.map do |offset|
+        TrueTypeFont.from_ttc(io, offset)
+      end
     end
 
     # List all fonts in the collection with basic metadata
     #
-    # Returns a CollectionListInfo model containing summaries of all fonts.
-    # This is the API method used by the `ls` command for collections.
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param io [IO] Open file handle to read fonts from
     # @return [CollectionListInfo] List of fonts with metadata
-    #
-    # @example List fonts in collection
-    #   File.open("fonts.ttc", "rb") do |io|
-    #     ttc = TrueTypeCollection.read(io)
-    #     list = ttc.list_fonts(io)
-    #     list.fonts.each { |f| puts "#{f.index}: #{f.family_name}" }
-    #   end
     def list_fonts(io)
       require_relative "models/collection_list_info"
       require_relative "models/collection_font_summary"
@@ -159,51 +115,11 @@ module Fontisan
       )
     end
 
-    # Get comprehensive collection metadata
-    #
-    # Returns a CollectionInfo model with header information, offsets,
-    # and table sharing statistics.
-    # This is the API method used by the `info` command for collections.
-    #
-    # @param io [IO] Open file handle to read fonts from
-    # @param path [String] Collection file path (for file size)
-    # @return [CollectionInfo] Collection metadata
-    #
-    # @example Get collection info
-    #   File.open("fonts.ttc", "rb") do |io|
-    #     ttc = TrueTypeCollection.read(io)
-    #     info = ttc.collection_info(io, "fonts.ttc")
-    #     puts "Version: #{info.version_string}"
-    #   end
-    def collection_info(io, path)
-      require_relative "models/collection_info"
-      require_relative "models/table_sharing_info"
-
-      # Calculate table sharing statistics
-      table_sharing = calculate_table_sharing(io)
-
-      # Get file size
-      file_size = path ? File.size(path) : 0
-
-      Models::CollectionInfo.new(
-        collection_path: path,
-        collection_format: "TTC",
-        ttc_tag: tag,
-        major_version: major_version,
-        minor_version: minor_version,
-        num_fonts: num_fonts,
-        font_offsets: font_offsets.to_a,
-        file_size_bytes: file_size,
-        table_sharing: table_sharing,
-      )
-    end
-
     private
 
     # Calculate table sharing statistics
     #
-    # Analyzes which tables are shared between fonts and calculates
-    # space savings from deduplication.
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param io [IO] Open file handle
     # @return [TableSharingInfo] Sharing statistics

data/lib/fontisan/true_type_font.rb

@@ -532,6 +532,12 @@ module Fontisan
         Constants::GPOS_TAG => Tables::Gpos,
         Constants::GLYF_TAG => Tables::Glyf,
         Constants::LOCA_TAG => Tables::Loca,
+        "SVG " => Tables::Svg,
+        "COLR" => Tables::Colr,
+        "CPAL" => Tables::Cpal,
+        "CBDT" => Tables::Cbdt,
+        "CBLC" => Tables::Cblc,
+        "sbix" => Tables::Sbix,
       }[tag]
     end