fontisan 0.1.0 → 0.2.0

data/lib/fontisan/tables/vvar.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "../binary/base_record"
+require_relative "variation_common"
+
+module Fontisan
+  module Tables
+    # Parser for the 'VVAR' (Vertical Metrics Variations) table
+    #
+    # The VVAR table provides variation data for vertical metrics including:
+    # - Advance height variations
+    # - Top side bearing (TSB) variations
+    #
+    # This table uses the ItemVariationStore structure to efficiently store
+    # delta values for different regions in the design space.
+    #
+    # Reference: OpenType specification, VVAR table
+    #
+    # @example Reading a VVAR table
+    #   data = font.table_data("VVAR")
+    #   vvar = Fontisan::Tables::Vvar.read(data)
+    #   advance_deltas = vvar.advance_height_deltas(glyph_id, coordinates)
+    class Vvar < Binary::BaseRecord
+      uint16 :major_version
+      uint16 :minor_version
+      uint32 :item_variation_store_offset
+      uint32 :advance_height_mapping_offset
+      uint32 :tsb_mapping_offset
+      uint32 :bsb_mapping_offset
+      uint32 :v_org_mapping_offset
+
+      # Get version as a float
+      #
+      # @return [Float] Version number (e.g., 1.0)
+      def version
+        major_version + (minor_version / 10.0)
+      end
+
+      # Parse the item variation store
+      #
+      # @return [VariationCommon::ItemVariationStore, nil] Variation store
+      def item_variation_store
+        return @item_variation_store if defined?(@item_variation_store)
+        return @item_variation_store = nil if item_variation_store_offset.zero?
+
+        data = raw_data
+        offset = item_variation_store_offset
+
+        return @item_variation_store = nil if offset >= data.bytesize
+
+        store_data = data.byteslice(offset..-1)
+        @item_variation_store = VariationCommon::ItemVariationStore.read(store_data)
+      rescue StandardError => e
+        warn "Failed to parse VVAR item variation store: #{e.message}"
+        @item_variation_store = nil
+      end
+
+      # Parse advance height mapping
+      #
+      # @return [VariationCommon::DeltaSetIndexMap, nil] Advance height map
+      def advance_height_mapping
+        return @advance_height_mapping if defined?(@advance_height_mapping)
+        return @advance_height_mapping = nil if advance_height_mapping_offset.zero?
+
+        data = raw_data
+        offset = advance_height_mapping_offset
+
+        return @advance_height_mapping = nil if offset >= data.bytesize
+
+        map_data = data.byteslice(offset..-1)
+        @advance_height_mapping = VariationCommon::DeltaSetIndexMap.read(map_data)
+      rescue StandardError => e
+        warn "Failed to parse VVAR advance height mapping: #{e.message}"
+        @advance_height_mapping = nil
+      end
+
+      # Parse TSB (top side bearing) mapping
+      #
+      # @return [VariationCommon::DeltaSetIndexMap, nil] TSB map
+      def tsb_mapping
+        return @tsb_mapping if defined?(@tsb_mapping)
+        return @tsb_mapping = nil if tsb_mapping_offset.zero?
+
+        data = raw_data
+        offset = tsb_mapping_offset
+
+        return @tsb_mapping = nil if offset >= data.bytesize
+
+        map_data = data.byteslice(offset..-1)
+        @tsb_mapping = VariationCommon::DeltaSetIndexMap.read(map_data)
+      rescue StandardError => e
+        warn "Failed to parse VVAR TSB mapping: #{e.message}"
+        @tsb_mapping = nil
+      end
+
+      # Parse BSB (bottom side bearing) mapping
+      #
+      # @return [VariationCommon::DeltaSetIndexMap, nil] BSB map
+      def bsb_mapping
+        return @bsb_mapping if defined?(@bsb_mapping)
+        return @bsb_mapping = nil if bsb_mapping_offset.zero?
+
+        data = raw_data
+        offset = bsb_mapping_offset
+
+        return @bsb_mapping = nil if offset >= data.bytesize
+
+        map_data = data.byteslice(offset..-1)
+        @bsb_mapping = VariationCommon::DeltaSetIndexMap.read(map_data)
+      rescue StandardError => e
+        warn "Failed to parse VVAR BSB mapping: #{e.message}"
+        @bsb_mapping = nil
+      end
+
+      # Parse vertical origin mapping
+      #
+      # @return [VariationCommon::DeltaSetIndexMap, nil] VOrig map
+      def v_org_mapping
+        return @v_org_mapping if defined?(@v_org_mapping)
+        return @v_org_mapping = nil if v_org_mapping_offset.zero?
+
+        data = raw_data
+        offset = v_org_mapping_offset
+
+        return @v_org_mapping = nil if offset >= data.bytesize
+
+        map_data = data.byteslice(offset..-1)
+        @v_org_mapping = VariationCommon::DeltaSetIndexMap.read(map_data)
+      rescue StandardError => e
+        warn "Failed to parse VVAR vertical origin mapping: #{e.message}"
+        @v_org_mapping = nil
+      end
+
+      # Get advance height delta set for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<Integer>, nil] Delta values or nil
+      def advance_height_delta_set(glyph_id)
+        return nil unless item_variation_store
+
+        # If no mapping, use glyph_id directly
+        if advance_height_mapping.nil?
+          return item_variation_store.delta_set(0, glyph_id)
+        end
+
+        # Use mapping to get delta set indices
+        map_data = advance_height_mapping.map_data
+        return nil if glyph_id >= map_data.length
+
+        delta_index = map_data[glyph_id]
+        outer_index = (delta_index >> 16) & 0xFFFF
+        inner_index = delta_index & 0xFFFF
+
+        item_variation_store.delta_set(outer_index, inner_index)
+      end
+
+      # Get TSB delta set for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<Integer>, nil] Delta values or nil
+      def tsb_delta_set(glyph_id)
+        return nil unless item_variation_store
+
+        # If no mapping, use glyph_id directly
+        if tsb_mapping.nil?
+          return item_variation_store.delta_set(0, glyph_id)
+        end
+
+        # Use mapping to get delta set indices
+        map_data = tsb_mapping.map_data
+        return nil if glyph_id >= map_data.length
+
+        delta_index = map_data[glyph_id]
+        outer_index = (delta_index >> 16) & 0xFFFF
+        inner_index = delta_index & 0xFFFF
+
+        item_variation_store.delta_set(outer_index, inner_index)
+      end
+
+      # Get BSB delta set for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<Integer>, nil] Delta values or nil
+      def bsb_delta_set(glyph_id)
+        return nil unless item_variation_store
+
+        # If no mapping, use glyph_id directly
+        if bsb_mapping.nil?
+          return item_variation_store.delta_set(0, glyph_id)
+        end
+
+        # Use mapping to get delta set indices
+        map_data = bsb_mapping.map_data
+        return nil if glyph_id >= map_data.length
+
+        delta_index = map_data[glyph_id]
+        outer_index = (delta_index >> 16) & 0xFFFF
+        inner_index = delta_index & 0xFFFF
+
+        item_variation_store.delta_set(outer_index, inner_index)
+      end
+
+      # Get vertical origin delta set for a glyph
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @return [Array<Integer>, nil] Delta values or nil
+      def v_org_delta_set(glyph_id)
+        return nil unless item_variation_store
+
+        # If no mapping, use glyph_id directly
+        if v_org_mapping.nil?
+          return item_variation_store.delta_set(0, glyph_id)
+        end
+
+        # Use mapping to get delta set indices
+        map_data = v_org_mapping.map_data
+        return nil if glyph_id >= map_data.length
+
+        delta_index = map_data[glyph_id]
+        outer_index = (delta_index >> 16) & 0xFFFF
+        inner_index = delta_index & 0xFFFF
+
+        item_variation_store.delta_set(outer_index, inner_index)
+      end
+
+      # Check if table is valid
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        major_version == 1 && minor_version.zero?
+      end
+    end
+  end
+end

data/lib/fontisan/true_type_collection.rb

@@ -64,12 +64,13 @@ module Fontisan
     #
     # @param index [Integer] Index of the font (0-based)
     # @param io [IO] Open file handle
+    # @param mode [Symbol] Loading mode (:metadata or :full, default: :full)
     # @return [TrueTypeFont, nil] Font object or nil if index out of range
-    def font(index, io)
+    def font(index, io, mode: LoadingModes::FULL)
       return nil if index >= num_fonts
 
       require_relative "true_type_font"
-      TrueTypeFont.from_ttc(io, font_offsets[index])
+      TrueTypeFont.from_ttc(io, font_offsets[index], mode: mode)
     end
 
     # Get font count (Fontisan extension)
@@ -94,5 +95,158 @@ module Fontisan
     def version
       (major_version << 16) | minor_version
     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.
+    #
+    # @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"
+      require_relative "true_type_font"
+      require_relative "tables/name"
+
+      fonts = font_offsets.map.with_index do |offset, index|
+        font = TrueTypeFont.from_ttc(io, offset)
+
+        # Extract basic font info
+        name_table = font.table("name")
+        post_table = font.table("post")
+
+        family_name = name_table&.english_name(Tables::Name::FAMILY) || "Unknown"
+        subfamily_name = name_table&.english_name(Tables::Name::SUBFAMILY) || "Regular"
+        postscript_name = name_table&.english_name(Tables::Name::POSTSCRIPT_NAME) || "Unknown"
+
+        # Determine font format
+        sfnt = font.header.sfnt_version
+        font_format = case sfnt
+                      when 0x00010000, 0x74727565 # 0x74727565 = 'true'
+                        "TrueType"
+                      when 0x4F54544F # 'OTTO'
+                        "OpenType"
+                      else
+                        "Unknown"
+                      end
+
+        num_glyphs = post_table&.glyph_names&.length || 0
+        num_tables = font.table_names.length
+
+        Models::CollectionFontSummary.new(
+          index: index,
+          family_name: family_name,
+          subfamily_name: subfamily_name,
+          postscript_name: postscript_name,
+          font_format: font_format,
+          num_glyphs: num_glyphs,
+          num_tables: num_tables,
+        )
+      end
+
+      Models::CollectionListInfo.new(
+        collection_path: nil, # Will be set by command
+        num_fonts: num_fonts,
+        fonts: fonts,
+      )
+    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.
+    #
+    # @param io [IO] Open file handle
+    # @return [TableSharingInfo] Sharing statistics
+    def calculate_table_sharing(io)
+      require_relative "models/table_sharing_info"
+      require_relative "true_type_font"
+
+      # Extract all fonts
+      fonts = font_offsets.map do |offset|
+        TrueTypeFont.from_ttc(io, offset)
+      end
+
+      # Build table hash map (checksum -> size)
+      table_map = {}
+      total_table_size = 0
+
+      fonts.each do |font|
+        font.tables.each do |entry|
+          key = entry.checksum
+          size = entry.table_length
+          table_map[key] ||= size
+          total_table_size += size
+        end
+      end
+
+      # Count unique vs shared
+      unique_tables = table_map.size
+      total_tables = fonts.sum { |f| f.tables.length }
+      shared_tables = total_tables - unique_tables
+
+      # Calculate space saved
+      unique_size = table_map.values.sum
+      space_saved = total_table_size - unique_size
+
+      # Calculate sharing percentage
+      sharing_pct = total_tables.positive? ? (shared_tables.to_f / total_tables * 100).round(2) : 0.0
+
+      Models::TableSharingInfo.new(
+        shared_tables: shared_tables,
+        unique_tables: unique_tables,
+        sharing_percentage: sharing_pct,
+        space_saved_bytes: space_saved,
+      )
+    end
   end
 end