fontisan 0.2.1 → 0.2.3

data/lib/fontisan/converters/format_converter.rb

@@ -103,7 +103,8 @@ module Fontisan
         end
 
         strategy = select_strategy(source_format, target_format)
-        tables = strategy.convert(font, options.merge(target_format: target_format))
+        tables = strategy.convert(font,
+                                  options.merge(target_format: target_format))
 
         # Preserve variation data if requested and font is variable
         if options.fetch(:preserve_variation, true) && variable_font?(font)
@@ -204,7 +205,8 @@ module Fontisan
       # @param target_format [Symbol] Target format
       # @param options [Hash] Preservation options
       # @return [Hash<String, String>] Tables with variation preserved
-      def preserve_variation_data(font, tables, source_format, target_format, options)
+      def preserve_variation_data(font, tables, source_format, target_format,
+options)
         # Case 1: Compatible formats (same outline format) - just copy tables
         if compatible_variation_formats?(source_format, target_format)
           require_relative "../variation/variation_preserver"
@@ -212,7 +214,8 @@ module Fontisan
 
         # Case 2: Different outline formats - convert variation data
         elsif convertible_variation_formats?(source_format, target_format)
-          convert_variation_data(font, tables, source_format, target_format, options)
+          convert_variation_data(font, tables, source_format, target_format,
+                                 options)
 
         # Case 3: Unsupported conversion
         else
@@ -268,7 +271,8 @@ module Fontisan
       # @param target_format [Symbol] Target format
       # @param options [Hash] Conversion options
       # @return [Hash<String, String>] Tables with converted variation
-      def convert_variation_data(font, tables, source_format, target_format, _options)
+      def convert_variation_data(font, tables, source_format, target_format,
+_options)
         require_relative "../variation/variation_preserver"
         require_relative "../variation/converter"
 

data/lib/fontisan/converters/outline_converter.rb

@@ -131,7 +131,7 @@ module Fontisan
       # @param font [TrueTypeFont] Source font
       # @param options [Hash] Conversion options (currently unused)
       # @return [Hash<String, String>] Target tables
-      def convert_ttf_to_otf(font, options = {})
+      def convert_ttf_to_otf(font, _options = {})
         # Extract all glyphs from glyf table
         outlines = extract_ttf_outlines(font)
 
@@ -184,7 +184,8 @@ module Fontisan
         hints_per_glyph = @preserve_hints ? extract_cff_hints(font) : {}
 
         # Build glyf and loca tables
-        glyf_data, loca_data, loca_format = build_glyf_loca_tables(outlines, hints_per_glyph)
+        glyf_data, loca_data, loca_format = build_glyf_loca_tables(outlines,
+                                                                   hints_per_glyph)
 
         # Copy all tables except CFF
         tables = copy_tables(font, ["CFF ", "CFF2"])
@@ -357,7 +358,7 @@ module Fontisan
       # @param outlines [Array<Outline>] Glyph outlines
       # @param font [TrueTypeFont] Source font (for metadata)
       # @return [String] CFF table binary data
-      def build_cff_table(outlines, font, hints_per_glyph)
+      def build_cff_table(outlines, font, _hints_per_glyph)
         # Build CharStrings INDEX from outlines
         begin
           charstrings = outlines.map do |outline|
@@ -478,7 +479,8 @@ module Fontisan
           top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
           top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
         rescue StandardError => e
-          raise Fontisan::Error, "Failed to calculate CFF table offsets: #{e.message}"
+          raise Fontisan::Error,
+                "Failed to calculate CFF table offsets: #{e.message}"
         end
 
         # Build CFF Header
@@ -512,7 +514,7 @@ module Fontisan
       #
       # @param outlines [Array<Outline>] Glyph outlines
       # @return [Array<String, String, Integer>] [glyf_data, loca_data, loca_format]
-      def build_glyf_loca_tables(outlines, hints_per_glyph)
+      def build_glyf_loca_tables(outlines, _hints_per_glyph)
         glyf_data = "".b
         offsets = []
 
@@ -687,7 +689,7 @@ module Fontisan
         # Analyze patterns
         analyzer = Optimizers::PatternAnalyzer.new(
           min_length: 10,
-          stack_aware: true
+          stack_aware: true,
         )
         patterns = analyzer.analyze(charstrings_hash)
 
@@ -695,7 +697,8 @@ module Fontisan
         return [charstrings, []] if patterns.empty?
 
         # Optimize selection
-        optimizer = Optimizers::SubroutineOptimizer.new(patterns, max_subrs: 65_535)
+        optimizer = Optimizers::SubroutineOptimizer.new(patterns,
+                                                        max_subrs: 65_535)
         selected_patterns = optimizer.optimize_selection
 
         # Optimize ordering
@@ -705,7 +708,8 @@ module Fontisan
         return [charstrings, []] if selected_patterns.empty?
 
         # Build subroutines
-        builder = Optimizers::SubroutineBuilder.new(selected_patterns, type: :local)
+        builder = Optimizers::SubroutineBuilder.new(selected_patterns,
+                                                    type: :local)
         local_subrs = builder.build
 
         # Build subroutine map
@@ -718,7 +722,9 @@ module Fontisan
         rewriter = Optimizers::CharstringRewriter.new(subroutine_map, builder)
         optimized_charstrings = charstrings.map.with_index do |charstring, glyph_id|
           # Find patterns for this glyph
-          glyph_patterns = selected_patterns.select { |p| p.glyphs.include?(glyph_id) }
+          glyph_patterns = selected_patterns.select do |p|
+            p.glyphs.include?(glyph_id)
+          end
 
           if glyph_patterns.empty?
             charstring
@@ -743,13 +749,16 @@ module Fontisan
       def generate_static_instance(font, source_format, target_format)
         # Generate instance at specified coordinates
         fvar = font.table("fvar")
-        axes = fvar ? fvar.axes : []
+        fvar ? fvar.axes : []
 
-        generator = Variation::InstanceGenerator.new(font, @instance_coordinates)
+        generator = Variation::InstanceGenerator.new(font,
+                                                     @instance_coordinates)
         instance_tables = generator.generate
 
         # If target format differs from source, convert outlines
-        if source_format != target_format
+        if source_format == target_format
+          instance_tables
+        else
           # Create temporary font with instance tables
           temp_font = font.class.new
           temp_font.instance_variable_set(:@table_data, instance_tables)
@@ -763,8 +772,6 @@ module Fontisan
           else
             instance_tables
           end
-        else
-          instance_tables
         end
       end
 
@@ -801,8 +808,6 @@ module Fontisan
                  when %i[otf ttf], %i[cff2 ttf]
                    # blend → gvar
                    converter.blend_to_gvar(glyph_id)
-                 else
-                   nil
                  end
 
           variation_data[glyph_id] = data if data

data/lib/fontisan/converters/woff_writer.rb

@@ -128,7 +128,8 @@ module Fontisan
       # @raise [ArgumentError] if compression level is invalid
       def validate_compression_level!
         unless @compression_level.between?(0, 9)
-          raise ArgumentError, "Compression level must be between 0 and 9, got #{@compression_level}"
+          raise ArgumentError,
+                "Compression level must be between 0 and 9, got #{@compression_level}"
         end
       end
 
@@ -235,7 +236,9 @@ module Fontisan
         metadata_size = compressed_metadata ? compressed_metadata[:compressed_length] : 0
 
         # Calculate total compressed data size
-        total_compressed_size = compressed_tables.values.sum { |table| table[:compressed_length] }
+        total_compressed_size = compressed_tables.values.sum do |table|
+          table[:compressed_length]
+        end
 
         # Calculate private data offset (after table data + metadata)
         private_offset = data_offset + total_compressed_size + metadata_size
@@ -245,7 +248,9 @@ module Fontisan
         total_size = private_offset + private_size
 
         # Calculate total SFNT size (uncompressed)
-        total_sfnt_size = compressed_tables.values.sum { |table| table[:original_length] } +
+        total_sfnt_size = compressed_tables.values.sum do |table|
+          table[:original_length]
+        end +
           header_size + table_dir_size
 
         # Write WOFF header

data/lib/fontisan/font_loader.rb

@@ -46,7 +46,11 @@ module Fontisan
 
       # Resolve mode and lazy parameters with environment variables
       resolved_mode = mode || env_mode || LoadingModes::FULL
-      resolved_lazy = lazy.nil? ? (env_lazy.nil? ? false : env_lazy) : lazy
+      resolved_lazy = if lazy.nil?
+                        env_lazy.nil? ? false : env_lazy
+                      else
+                        lazy
+                      end
 
       # Validate mode
       LoadingModes.validate_mode!(resolved_mode)
@@ -57,7 +61,8 @@ module Fontisan
 
         case signature
         when Constants::TTC_TAG
-          load_from_collection(io, path, font_index, mode: resolved_mode, lazy: resolved_lazy)
+          load_from_collection(io, path, font_index, mode: resolved_mode,
+                                                     lazy: resolved_lazy)
         when pack_uint32(Constants::SFNT_VERSION_TRUETYPE)
           TrueTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "OTTO"
@@ -97,6 +102,37 @@ module Fontisan
     # without extracting individual fonts. Useful for inspecting collection
     # metadata and structure.
     #
+    # = Collection Format Understanding
+    #
+    # Both TTC (TrueType Collection) and OTC (OpenType Collection) files use
+    # the same "ttcf" signature. The distinction between TTC and OTC is NOT
+    # in the collection format itself, but in the fonts contained within:
+    #
+    # - TTC typically contains TrueType fonts (glyf outlines)
+    # - OTC typically contains OpenType fonts (CFF/CFF2 outlines)
+    # - Mixed collections are possible (both TTF and OTF in same collection)
+    #
+    # Each collection can contain multiple SFNT-format font files, with table
+    # deduplication to save space. Individual fonts within a collection are
+    # stored at different offsets within the file, each with their own table
+    # directory and data tables.
+    #
+    # = Detection Strategy
+    #
+    # This method scans ALL fonts in the collection to determine the collection
+    # type accurately:
+    #
+    # 1. Reads all font offsets from the collection header
+    # 2. Examines the sfnt_version of each font in the collection
+    # 3. Counts TrueType fonts (0x00010000 or 0x74727565 "true") vs OpenType fonts (0x4F54544F "OTTO")
+    # 4. If ANY font is OpenType (CFF), returns OpenTypeCollection
+    # 5. Only returns TrueTypeCollection if ALL fonts are TrueType
+    #
+    # This approach correctly handles:
+    # - Homogeneous collections (all TTF or all OTF)
+    # - Mixed collections (both TTF and OTF fonts) - uses OpenTypeCollection
+    # - Large collections with many fonts (like NotoSerifCJK.ttc with 35 fonts)
+    #
     # @param path [String] Path to the collection file
     # @return [TrueTypeCollection, OpenTypeCollection] The collection object
     # @raise [Errno::ENOENT] if file does not exist
@@ -116,23 +152,43 @@ module Fontisan
                 "File is not a collection (TTC/OTC). Use FontLoader.load instead."
         end
 
-        # Read first font offset to detect collection type
-        io.seek(12) # Skip tag (4) + versions (4) + num_fonts (4)
-        first_offset = io.read(4).unpack1("N")
+        # Read version and num_fonts
+        io.seek(8) # Skip tag (4) + version (4)
+        num_fonts = io.read(4).unpack1("N")
+
+        # Read all font offsets
+        font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+
+        # Scan all fonts to determine collection type (not just first)
+        truetype_count = 0
+        opentype_count = 0
+
+        font_offsets.each do |offset|
+          io.rewind
+          io.seek(offset)
+          sfnt_version = io.read(4).unpack1("N")
+
+          case sfnt_version
+          when Constants::SFNT_VERSION_TRUETYPE, 0x74727565 # 0x74727565 = 'true'
+            truetype_count += 1
+          when Constants::SFNT_VERSION_OTTO
+            opentype_count += 1
+          else
+            raise InvalidFontError,
+                  "Unknown font type in collection at offset #{offset} (sfnt version: 0x#{sfnt_version.to_s(16)})"
+          end
+        end
 
-        # Peek at first font's sfnt_version
-        io.seek(first_offset)
-        sfnt_version = io.read(4).unpack1("N")
         io.rewind
 
-        case sfnt_version
-        when Constants::SFNT_VERSION_TRUETYPE
-          TrueTypeCollection.from_file(path)
-        when Constants::SFNT_VERSION_OTTO
+        # Determine collection type based on what fonts are inside
+        # If ANY font is OpenType, use OpenTypeCollection (more general format)
+        # Only use TrueTypeCollection if ALL fonts are TrueType
+        if opentype_count > 0
           OpenTypeCollection.from_file(path)
         else
-          raise InvalidFontError,
-                "Unknown font type in collection (sfnt version: 0x#{sfnt_version.to_s(16)})"
+          # All fonts are TrueType
+          TrueTypeCollection.from_file(path)
         end
       end
     end
@@ -162,6 +218,23 @@ module Fontisan
 
     # Load from a collection file (TTC or OTC)
     #
+    # This is the internal method that handles loading individual fonts from
+    # collection files. It reads the collection header to determine the type
+    # (TTC vs OTC) and extracts the requested font.
+    #
+    # = Collection Header Structure
+    #
+    # TTC/OTC files start with:
+    # - Bytes 0-3: "ttcf" tag (4 bytes)
+    # - Bytes 4-7: version (2 bytes major + 2 bytes minor)
+    # - Bytes 8-11: num_fonts (4 bytes, big-endian uint32)
+    # - Bytes 12+: font offset array (4 bytes per font, big-endian uint32)
+    #
+    # CRITICAL: The method seeks to position 8 (after tag and version) to read
+    # num_fonts, NOT position 12 which is where the offset array starts. This
+    # was a bug that caused "Unknown font type" errors when the first offset
+    # was misread as num_fonts.
+    #
     # @param io [IO] Open file handle
     # @param path [String] Path to the collection file
     # @param font_index [Integer] Index of font to extract
@@ -169,9 +242,10 @@ module Fontisan
     # @param lazy [Boolean] If true, load tables on demand
     # @return [TrueTypeFont, OpenTypeFont] The loaded font object
     # @raise [InvalidFontError] if collection type cannot be determined
-    def self.load_from_collection(io, path, font_index, mode: LoadingModes::FULL, lazy: true)
+    def self.load_from_collection(io, path, font_index,
+mode: LoadingModes::FULL, lazy: true)
       # Read collection header to get font offsets
-      io.seek(12) # Skip tag (4) + major_version (2) + minor_version (2) + num_fonts marker (4)
+      io.seek(8) # Skip tag (4) + version (4)
       num_fonts = io.read(4).unpack1("N")
 
       if font_index >= num_fonts
@@ -179,26 +253,41 @@ module Fontisan
               "Font index #{font_index} out of range (collection has #{num_fonts} fonts)"
       end
 
-      # Read first offset to detect collection type
-      first_offset = io.read(4).unpack1("N")
+      # Read all font offsets
+      font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+
+      # Scan all fonts to determine collection type (not just first)
+      truetype_count = 0
+      opentype_count = 0
+
+      font_offsets.each do |offset|
+        io.rewind
+        io.seek(offset)
+        sfnt_version = io.read(4).unpack1("N")
+
+        case sfnt_version
+        when Constants::SFNT_VERSION_TRUETYPE, 0x74727565 # 0x74727565 = 'true'
+          truetype_count += 1
+        when Constants::SFNT_VERSION_OTTO
+          opentype_count += 1
+        else
+          raise InvalidFontError,
+                "Unknown font type in collection at offset #{offset} (sfnt version: 0x#{sfnt_version.to_s(16)})"
+        end
+      end
 
-      # Peek at first font's sfnt_version to determine TTC vs OTC
-      io.seek(first_offset)
-      sfnt_version = io.read(4).unpack1("N")
       io.rewind
 
-      case sfnt_version
-      when Constants::SFNT_VERSION_TRUETYPE
-        # TrueType Collection
-        ttc = TrueTypeCollection.from_file(path)
-        File.open(path, "rb") { |f| ttc.font(font_index, f, mode: mode) }
-      when Constants::SFNT_VERSION_OTTO
+      # If ANY font is OpenType, use OpenTypeCollection (more general format)
+      # Only use TrueTypeCollection if ALL fonts are TrueType
+      if opentype_count > 0
         # OpenType Collection
         otc = OpenTypeCollection.from_file(path)
         File.open(path, "rb") { |f| otc.font(font_index, f, mode: mode) }
       else
-        raise InvalidFontError,
-              "Unknown font type in collection (sfnt version: 0x#{sfnt_version.to_s(16)})"
+        # TrueType Collection (all fonts are TrueType)
+        ttc = TrueTypeCollection.from_file(path)
+        File.open(path, "rb") { |f| ttc.font(font_index, f, mode: mode) }
       end
     end
 
@@ -211,6 +300,7 @@ module Fontisan
       [value].pack("N")
     end
 
-    private_class_method :load_from_collection, :pack_uint32, :env_mode, :env_lazy
+    private_class_method :load_from_collection, :pack_uint32, :env_mode,
+                         :env_lazy
   end
 end

data/lib/fontisan/font_writer.rb

@@ -113,6 +113,7 @@ module Fontisan
       # Write offset table (sfnt header)
       font_data << write_offset_table(table_entries.size)
 
+      # rubocop:disable Style/CombinableLoops
       # Write table directory (ALL entries first)
       table_entries.each do |entry|
         font_data << write_table_entry(entry)
@@ -123,6 +124,7 @@ module Fontisan
         font_data << entry[:data]
         font_data << entry[:padding]
       end
+      # rubocop:enable Style/CombinableLoops
 
       # Calculate and update head table checksum adjustment
       update_checksum_adjustment!(font_data, table_entries)

data/lib/fontisan/formatters/text_formatter.rb

@@ -42,6 +42,8 @@ module Fontisan
           format_font_summary(model)
         when Models::CollectionInfo
           format_collection_info(model)
+        when Models::CollectionBriefInfo
+          format_collection_brief_info(model)
         else
           model.to_s
         end
@@ -312,7 +314,8 @@ module Fontisan
                  font_format
                end
 
-        type += " (Variable)" if is_variable
+        # Always show variable status explicitly
+        type += is_variable ? " (Variable)" : " (Not Variable)"
         type
       end
 
@@ -361,20 +364,36 @@ module Fontisan
       def format_collection_info(info)
         lines = []
 
-        # Header section
-        lines << "=== Collection Information ==="
-        lines << ""
-        lines << "File: #{info.collection_path}"
-        lines << "Format: #{info.collection_format}"
+        # Header section with type and version (like brief mode)
+        lines << "Collection: #{info.collection_path}"
+
+        # Format collection type for display with OpenType version
+        if info.collection_format
+          collection_type_display = case info.collection_format
+                                    when "TTC"
+                                      "TrueType Collection (OpenType 1.4)"
+                                    when "OTC"
+                                      "OpenType Collection (OpenType 1.8)"
+                                    else
+                                      info.collection_format
+                                    end
+          lines << "Type: #{collection_type_display}"
+        end
+
+        lines << "Version: #{info.version_string}"
         lines << "Size: #{format_bytes(info.file_size_bytes)}"
+        lines << "Fonts: #{info.num_fonts}"
         lines << ""
 
-        # Header details
-        lines << "=== Header ==="
-        lines << "Tag: #{info.ttc_tag}"
-        lines << "Version: #{info.version_string} (#{info.version_hex})"
-        lines << "Number of fonts: #{info.num_fonts}"
-        lines << ""
+        # Table sharing statistics
+        if info.table_sharing
+          lines << "=== Table Sharing ==="
+          lines << "Shared tables: #{info.table_sharing.shared_tables}"
+          lines << "Unique tables: #{info.table_sharing.unique_tables}"
+          lines << "Sharing: #{format_float(info.table_sharing.sharing_percentage)}%"
+          lines << "Space saved: #{format_bytes(info.table_sharing.space_saved_bytes)}"
+          lines << ""
+        end
 
         # Font offsets
         lines << "=== Font Offsets ==="
@@ -384,13 +403,91 @@ module Fontisan
         end
         lines << ""
 
-        # Table sharing statistics
-        if info.table_sharing
-          lines << "=== Table Sharing ==="
-          lines << "Shared tables: #{info.table_sharing.shared_tables}"
-          lines << "Unique tables: #{info.table_sharing.unique_tables}"
-          lines << "Sharing: #{format_float(info.table_sharing.sharing_percentage)}%"
-          lines << "Space saved: #{format_bytes(info.table_sharing.space_saved_bytes)}"
+        # Individual font information (like brief mode)
+        if info.fonts && !info.fonts.empty?
+          lines << "=== Fonts ==="
+          lines << ""
+
+          info.fonts.each_with_index do |font_info, index|
+            # Show font index with offset
+            if font_info.collection_offset
+              lines << "Font #{index} (offset: #{font_info.collection_offset}):"
+            else
+              lines << "Font #{index}:"
+            end
+            lines << ""
+
+            # Format each font using same structure as brief mode
+            font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+            add_line(lines, "Font type", font_type_display)
+            add_line(lines, "Family", font_info.family_name)
+            add_line(lines, "Subfamily", font_info.subfamily_name)
+            add_line(lines, "Full name", font_info.full_name)
+            add_line(lines, "PostScript name", font_info.postscript_name)
+            add_line(lines, "Version", font_info.version)
+            add_line(lines, "Vendor ID", font_info.vendor_id)
+            add_line(lines, "Font revision", format_float(font_info.font_revision))
+            add_line(lines, "Units per em", font_info.units_per_em)
+
+            # Blank line between fonts (except after last)
+            lines << "" unless index == info.num_fonts - 1
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      # Format CollectionBriefInfo as human-readable text.
+      #
+      # @param info [Models::CollectionBriefInfo] Collection brief information to format
+      # @return [String] Formatted text with collection header and each font's brief info
+      def format_collection_brief_info(info)
+        lines = []
+
+        # Collection header with type and version
+        lines << "Collection: #{info.collection_path}"
+
+        # Format collection type for display with OpenType version
+        if info.collection_type
+          collection_type_display = case info.collection_type
+                                    when "TTC"
+                                      "TrueType Collection (OpenType 1.4)"
+                                    when "OTC"
+                                      "OpenType Collection (OpenType 1.8)"
+                                    else
+                                      info.collection_type
+                                    end
+          lines << "Type: #{collection_type_display}"
+        end
+
+        lines << "Version: #{info.collection_version}" if info.collection_version
+        lines << "Fonts: #{info.num_fonts}"
+        lines << ""
+
+        # Each font's brief info
+        info.fonts.each_with_index do |font_info, index|
+          # Show font index with offset
+          if font_info.collection_offset
+            lines << "Font #{index} (offset: #{font_info.collection_offset}):"
+          else
+            lines << "Font #{index}:"
+          end
+          lines << ""
+
+          # Format each font using same structure as individual fonts
+          font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+          add_line(lines, "Font type", font_type_display)
+          add_line(lines, "Family", font_info.family_name)
+          add_line(lines, "Subfamily", font_info.subfamily_name)
+          add_line(lines, "Full name", font_info.full_name)
+          add_line(lines, "PostScript name", font_info.postscript_name)
+          add_line(lines, "Version", font_info.version)
+          add_line(lines, "Vendor ID", font_info.vendor_id)
+          add_line(lines, "Font revision", format_float(font_info.font_revision))
+          add_line(lines, "Units per em", font_info.units_per_em)
+
+          # Blank line between fonts (except after last)
+          lines << "" unless index == info.num_fonts - 1
         end
 
         lines.join("\n")