fontisan 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f52b19a1d943c0e079127e9699e517b6832a30d46bab88454ae8471a398886d2
-  data.tar.gz: 8395db7eef4bb2bed2169a08f54208e5119209f3336dcf17bf6d27b602e7fd5f
+  metadata.gz: d342cbc82376aa9327747fd679edf9199ab0e1fbed9a729d4385aae52d6c5de9
+  data.tar.gz: 8427c56d4e65ca035a5bff415ef7020e3f6e17c31f4c43d8b28b5ca8e41e4fe4
 SHA512:
-  metadata.gz: 65003981ab35b7ff61c6f7524e9552278cfff918f0bbbfeb9a28271042e91033aa4623f8f301b66e1b6a171bea423ae30c644c32b4d111ce10a1d8bd6a82b61e
-  data.tar.gz: 7ff760af226e26a619cce271e505c92c8c6a3f21e6ec9c3c6582571e8944352ae7ff6be448c9236e11c5f6f023550f492716db5945980ac0607eaee700c9318e
+  metadata.gz: e5c9b89e658113edcd96e98c4c56733538a4e47eb18220d49ca8e21c5117285795759a6e3dd5b4f2a0b29f7a4a66c0bf0bf25757780dd438045eb705feef97ef
+  data.tar.gz: 5ec8c48befb405a5d9911a6f00a2287a9cae461847b52094abe1367cd5f1fd5c451363182ed3c9a924c96d13299659869c6ffa2f192951301d1218eb840e0623

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-12-29 12:26:25 UTC using RuboCop version 1.81.7.
+# on 2025-12-30 09:54:17 UTC using RuboCop version 1.81.7.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -31,21 +31,13 @@ Layout/ExtraSpacing:
   Exclude:
     - 'lib/fontisan/hints/truetype_instruction_analyzer.rb'
 
-# Offense count: 1101
+# Offense count: 1109
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: final_newline, final_blank_line
-Layout/TrailingEmptyLines:
-  Exclude:
-    - 'spec/fontisan_spec.rb'
-
 # Offense count: 26
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
 Lint/DuplicateBranch:
@@ -106,7 +98,7 @@ Lint/UselessAssignment:
     - 'lib/fontisan/hints/truetype_instruction_analyzer.rb'
     - 'spec/fontisan/hints/hint_round_trip_spec.rb'
 
-# Offense count: 431
+# Offense count: 432
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -122,7 +114,7 @@ Metrics/BlockLength:
 Metrics/BlockNesting:
   Max: 5
 
-# Offense count: 220
+# Offense count: 223
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
@@ -138,7 +130,7 @@ Metrics/ParameterLists:
   Max: 39
   MaxOptionalParameters: 4
 
-# Offense count: 154
+# Offense count: 157
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -192,10 +184,11 @@ Performance/CollectionLiteralInLoop:
     - 'spec/fontisan/commands/info_command_spec.rb'
     - 'spec/fontisan/commands/tables_command_spec.rb'
 
-# Offense count: 1
+# Offense count: 3
 # This cop supports unsafe autocorrection (--autocorrect-all).
 Performance/TimesMap:
   Exclude:
+    - 'lib/fontisan/font_loader.rb'
     - 'lib/fontisan/tables/cff2.rb'
 
 # Offense count: 24
@@ -225,7 +218,7 @@ RSpec/DescribeMethod:
   Exclude:
     - 'spec/fontisan/collection/variable_font_builder_spec.rb'
 
-# Offense count: 1152
+# Offense count: 1156
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -295,11 +288,11 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 1488
+# Offense count: 1494
 RSpec/MultipleExpectations:
   Max: 22
 
-# Offense count: 132
+# Offense count: 134
 # Configuration parameters: AllowSubject.
 RSpec/MultipleMemoizedHelpers:
   Max: 13
@@ -400,7 +393,7 @@ Style/CombinableLoops:
   Exclude:
     - 'lib/fontisan/woff2_font.rb'
 
-# Offense count: 1
+# Offense count: 2
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, SingleLineConditionsOnly, IncludeTernaryExpressions.
 # SupportedStyles: assign_to_condition, assign_inside_condition
@@ -434,13 +427,14 @@ Style/HashLikeCase:
     - 'lib/fontisan/commands/unpack_command.rb'
     - 'lib/fontisan/models/validation_report.rb'
 
-# Offense count: 4
+# Offense count: 6
 # This cop supports unsafe autocorrection (--autocorrect-all).
 # Configuration parameters: EnforcedStyle, AllowedMethods, AllowedPatterns.
 # SupportedStyles: predicate, comparison
 Style/NumericPredicate:
   Exclude:
     - 'spec/**/*'
+    - 'lib/fontisan/font_loader.rb'
     - 'lib/fontisan/hints/hint_converter.rb'
     - 'lib/fontisan/hints/hint_validator.rb'
     - 'lib/fontisan/hints/truetype_instruction_analyzer.rb'

data/README.adoc

@@ -1043,6 +1043,37 @@ Fontisan provides comprehensive tools for managing TrueType Collections (TTC)
 and OpenType Collections (OTC). You can list fonts in a collection, extract
 individual fonts, unpack entire collections, and validate collection integrity.
 
+Both TTC and OTC files use the same `ttcf` tag in their binary format, but
+differ in the type of font data they contain:
+
+TTC (TrueType Collection):: Supported since OpenType 1.4. Contains fonts with
+TrueType outlines (glyf table). Multiple fonts can share identical tables for
+efficient storage. File extension: `.ttc`
+
+OTC (OpenType Collection):: Supported since OpenType 1.8. Contains fonts with
+CFF-format outlines (CFF table). Provides the same storage benefits and
+glyph-count advantages as TTC but for CFF fonts. File extension: `.otc`
+
+The collection format allows:
+
+Table sharing::
+Identical tables are stored once and referenced by multiple fonts
+
+Gap mode::
+Overcomes the 65,535 glyph limit per font by distributing glyphs across multiple
+fonts in a single file
+
+Efficient storage::
+Significant size reduction, especially for CJK fonts (e.g., Noto CJK OTC is ~10
+MB smaller than separate OTF files)
+
+Fontist returns the appropriate collection type based on the font data:
+
+* Examines font data within collection to determine type (TTC vs OTC)
+* TTC contains fonts with TrueType outlines (glyf table)
+* OTC contains fonts with CFF outlines (CFF table)
+* If ANY font in the collection has CFF outlines, use OpenTypeCollection
+* Only use TrueTypeCollection if ALL fonts have TrueType outlines
 
 === List fonts
 

data/lib/fontisan/base_collection.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "bindata"
+require_relative "constants"
+
+module Fontisan
+  # Abstract base class for font collections (TTC/OTC)
+  #
+  # This class implements the shared logic for TrueTypeCollection and OpenTypeCollection
+  # using the Template Method pattern. Subclasses must implement the abstract methods
+  # to specify their font class and collection format.
+  #
+  # The BinData structure definition is shared between both collection types since
+  # both TTC and OTC files use the same "ttcf" tag and binary format. The only
+  # differences are:
+  # 1. The type of fonts contained (TrueType vs OpenType)
+  # 2. The format string used for display ("TTC" vs "OTC")
+  #
+  # @abstract Subclass and override {font_class} and {collection_format}
+  #
+  # @example Implementing a collection subclass
+  #   class TrueTypeCollection < BaseCollection
+  #     def self.font_class
+  #       TrueTypeFont
+  #     end
+  #
+  #     def self.collection_format
+  #       "TTC"
+  #     end
+  #   end
+  class BaseCollection < 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
+
+    # Abstract method: Get the font class for this collection type
+    #
+    # Subclasses must override this to return their specific font class
+    # (TrueTypeFont or OpenTypeFont).
+    #
+    # @return [Class] The font class (TrueTypeFont or OpenTypeFont)
+    # @raise [NotImplementedError] if not overridden by subclass
+    def self.font_class
+      raise NotImplementedError,
+            "#{name} must implement self.font_class"
+    end
+
+    # Abstract method: Get the collection format string
+    #
+    # Subclasses must override this to return "TTC" or "OTC".
+    #
+    # @return [String] Collection format ("TTC" or "OTC")
+    # @raise [NotImplementedError] if not overridden by subclass
+    def self.collection_format
+      raise NotImplementedError,
+            "#{name} must implement self.collection_format"
+    end
+
+    # Read collection from a file
+    #
+    # @param path [String] Path to the collection file
+    # @return [BaseCollection] 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 #{collection_format} file: #{e.message}"
+    rescue EOFError => e
+      raise "Invalid #{collection_format} file: unexpected end of file - #{e.message}"
+    end
+
+    # Extract fonts from the collection
+    #
+    # Reads each font from the collection file and returns them as font objects.
+    #
+    # @param io [IO] Open file handle to read fonts from
+    # @return [Array] Array of font objects (TrueTypeFont or OpenTypeFont)
+    def extract_fonts(io)
+      font_class = self.class.font_class
+
+      font_offsets.map do |offset|
+        font_class.from_collection(io, offset)
+      end
+    end
+
+    # Get a single font from the collection
+    #
+    # @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, OpenTypeFont, nil] Font object or nil if index out of range
+    def font(index, io, mode: LoadingModes::FULL)
+      return nil if index >= num_fonts
+
+      font_class = self.class.font_class
+      font_class.from_collection(io, font_offsets[index], mode: mode)
+    end
+
+    # Get font count
+    #
+    # @return [Integer] Number of fonts in collection
+    def font_count
+      num_fonts
+    end
+
+    # Validate format correctness
+    #
+    # @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
+
+    # Get the collection version as a single integer
+    #
+    # @return [Integer] Version number (e.g., 0x00010000 for version 1.0)
+    def version
+      (major_version << 16) | minor_version
+    end
+
+    # Get the collection version as a string
+    #
+    # @return [String] Version string (e.g., "1.0")
+    def version_string
+      "#{major_version}.#{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|
+    #     collection = TrueTypeCollection.read(io)
+    #     list = collection.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 "tables/name"
+
+      font_class = self.class.font_class
+
+      fonts = font_offsets.map.with_index do |offset, index|
+        font = font_class.from_collection(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|
+    #     collection = TrueTypeCollection.read(io)
+    #     info = collection.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: self.class.collection_format,
+        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"
+
+      font_class = self.class.font_class
+
+      # Extract all fonts
+      fonts = font_offsets.map do |offset|
+        font_class.from_collection(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

data/lib/fontisan/commands/info_command.rb

@@ -50,62 +50,80 @@ module Fontisan
             # Brief mode: load each font and populate brief info
             brief_info = Models::CollectionBriefInfo.new
             brief_info.collection_path = @font_path
+            brief_info.collection_type = collection.class.collection_format
+            brief_info.collection_version = collection.version_string
             brief_info.num_fonts = collection.num_fonts
-            brief_info.fonts = []
-
-            collection.num_fonts.times do |index|
-              # Load individual font from collection
-              font = FontLoader.load(@font_path, font_index: index, mode: LoadingModes::METADATA)
-
-              # Populate brief info for this font
-              info = Models::FontInfo.new
-
-              # Font format and variable status
-              info.font_format = case font
-                                 when TrueTypeFont
-                                   "truetype"
-                                 when OpenTypeFont
-                                   "cff"
-                                 else
-                                   "unknown"
-                                 end
-              info.is_variable = font.has_table?(Constants::FVAR_TAG)
-
-              # Collection offset (only populated for fonts in collections)
-              info.collection_offset = collection.font_offsets[index]
-
-              # Essential names
-              if font.has_table?(Constants::NAME_TAG)
-                name_table = font.table(Constants::NAME_TAG)
-                info.family_name = name_table.english_name(Tables::Name::FAMILY)
-                info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
-                info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
-                info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
-                info.version = name_table.english_name(Tables::Name::VERSION)
-              end
-
-              # Essential metrics
-              if font.has_table?(Constants::HEAD_TAG)
-                head = font.table(Constants::HEAD_TAG)
-                info.font_revision = head.font_revision
-                info.units_per_em = head.units_per_em
-              end
-
-              # Vendor ID
-              if font.has_table?(Constants::OS2_TAG)
-                os2_table = font.table(Constants::OS2_TAG)
-                info.vendor_id = os2_table.vendor_id
-              end
-
-              brief_info.fonts << info
-            end
+            brief_info.fonts = load_collection_fonts(collection, @font_path)
 
             brief_info
           else
-            # Full mode: show detailed sharing statistics
-            collection.collection_info(io, @font_path)
+            # Full mode: show detailed sharing statistics AND font information
+            full_info = collection.collection_info(io, @font_path)
+
+            # Add font information to full mode
+            full_info.fonts = load_collection_fonts(collection, @font_path)
+
+            full_info
+          end
+        end
+      end
+
+      # Load font information for all fonts in a collection
+      #
+      # @param collection [TrueTypeCollection, OpenTypeCollection] The collection
+      # @param collection_path [String] Path to the collection file
+      # @return [Array<Models::FontInfo>] Array of font info objects
+      def load_collection_fonts(collection, collection_path)
+        fonts = []
+
+        collection.num_fonts.times do |index|
+          # Load individual font from collection
+          font = FontLoader.load(collection_path, font_index: index, mode: LoadingModes::METADATA)
+
+          # Populate font info
+          info = Models::FontInfo.new
+
+          # Font format and variable status
+          info.font_format = case font
+                             when TrueTypeFont
+                               "truetype"
+                             when OpenTypeFont
+                               "cff"
+                             else
+                               "unknown"
+                             end
+          info.is_variable = font.has_table?(Constants::FVAR_TAG)
+
+          # Collection offset (only populated for fonts in collections)
+          info.collection_offset = collection.font_offsets[index]
+
+          # Essential names
+          if font.has_table?(Constants::NAME_TAG)
+            name_table = font.table(Constants::NAME_TAG)
+            info.family_name = name_table.english_name(Tables::Name::FAMILY)
+            info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+            info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+            info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+            info.version = name_table.english_name(Tables::Name::VERSION)
+          end
+
+          # Essential metrics
+          if font.has_table?(Constants::HEAD_TAG)
+            head = font.table(Constants::HEAD_TAG)
+            info.font_revision = head.font_revision
+            info.units_per_em = head.units_per_em
           end
+
+          # Vendor ID
+          if font.has_table?(Constants::OS2_TAG)
+            os2_table = font.table(Constants::OS2_TAG)
+            info.vendor_id = os2_table.vendor_id
+          end
+
+          fonts << info
         end
+
+        fonts
       end
 
       # Get individual font information