fontisan 0.2.2 → 0.2.4

data/lib/fontisan/open_type_collection.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require "bindata"
-require_relative "constants"
+require_relative "base_collection"
 
 module Fontisan
-  # OpenType Collection domain object using BinData
+  # OpenType Collection domain object
   #
-  # Represents a complete OpenType Collection file (OTC) using BinData's declarative
-  # DSL for binary structure definition. Parallel to TrueTypeCollection but for OpenType fonts.
+  # Represents a complete OpenType Collection file (OTC). Inherits all shared
+  # functionality from BaseCollection and implements OTC-specific behavior.
   #
   # @example Reading and extracting fonts
   #   File.open("fonts.otc", "rb") do |io|
@@ -15,39 +14,26 @@ module Fontisan
   #     puts otc.num_fonts  # => 4
   #     fonts = otc.extract_fonts(io)  # => [OpenTypeFont, OpenTypeFont, ...]
   #   end
-  class OpenTypeCollection < 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 OpenType Collection from a file
+  class OpenTypeCollection < BaseCollection
+    # Get the font class for OpenType collections
     #
-    # @param path [String] Path to the OTC file
-    # @return [OpenTypeCollection] 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)
+    # @return [Class] OpenTypeFont class
+    def self.font_class
+      require_relative "open_type_font"
+      OpenTypeFont
+    end
 
-      File.open(path, "rb") { |io| read(io) }
-    rescue BinData::ValidityError => e
-      raise "Invalid OTC file: #{e.message}"
-    rescue EOFError => e
-      raise "Invalid OTC file: unexpected end of file - #{e.message}"
+    # Get the collection format identifier
+    #
+    # @return [String] "OTC" for OpenType Collection
+    def self.collection_format
+      "OTC"
     end
 
     # Extract fonts as OpenTypeFont objects
     #
     # Reads each font from the OTC file and returns them as OpenTypeFont objects.
+    # This method uses the from_collection method.
     #
     # @param io [IO] Open file handle to read fonts from
     # @return [Array<OpenTypeFont>] Array of font objects
@@ -58,194 +44,5 @@ module Fontisan
         OpenTypeFont.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 [OpenTypeFont, nil] Font object or nil if index out of range
-    def font(index, io, mode: LoadingModes::FULL)
-      return nil if index >= num_fonts
-
-      require_relative "open_type_font"
-      OpenTypeFont.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 OTC version as a single integer
-    #
-    # @return [Integer] Version number (e.g., 0x00010000 for version 1.0)
-    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.otc", "rb") do |io|
-    #     otc = OpenTypeCollection.read(io)
-    #     list = otc.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 "open_type_font"
-      require_relative "tables/name"
-
-      fonts = font_offsets.map.with_index do |offset, index|
-        font = OpenTypeFont.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.otc", "rb") do |io|
-    #     otc = OpenTypeCollection.read(io)
-    #     info = otc.collection_info(io, "fonts.otc")
-    #     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: "OTC",
-        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 "open_type_font"
-
-      # Extract all fonts
-      fonts = font_offsets.map do |offset|
-        OpenTypeFont.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/open_type_font.rb

@@ -512,6 +512,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
 

data/lib/fontisan/optimizers/charstring_rewriter.rb

@@ -30,12 +30,13 @@ module Fontisan
       #
       # @param charstring [String] original CharString bytes
       # @param patterns [Array<Pattern>] patterns to replace in this CharString
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [String] rewritten CharString with subroutine calls
-      def rewrite(charstring, patterns)
+      def rewrite(charstring, patterns, glyph_id = nil)
         return charstring if patterns.empty?
 
         # Build list of all replacements: [position, pattern]
-        replacements = build_replacement_list(charstring, patterns)
+        replacements = build_replacement_list(charstring, patterns, glyph_id)
 
         # Remove overlapping replacements
         replacements = remove_overlaps(replacements)
@@ -120,16 +121,26 @@ module Fontisan
       # Build list of all pattern replacements with their positions
       # @param charstring [String] CharString being rewritten
       # @param patterns [Array<Pattern>] patterns to find
+      # @param glyph_id [Integer, nil] glyph ID being rewritten (for position filtering)
       # @return [Array<Array>] array of [position, pattern] pairs
-      def build_replacement_list(charstring, patterns)
+      def build_replacement_list(charstring, patterns, glyph_id = nil)
         replacements = []
 
         patterns.each do |pattern|
-          # Find all positions where this pattern occurs
-          positions = find_pattern_positions(charstring, pattern)
+          if glyph_id && pattern.respond_to?(:positions) && pattern.positions.is_a?(Hash)
+            # Use exact positions from pattern analysis for this glyph
+            glyph_positions = pattern.positions[glyph_id] || []
 
-          positions.each do |position|
-            replacements << [position, pattern]
+            glyph_positions.each do |position|
+              replacements << [position, pattern]
+            end
+          else
+            # Fallback for backward compatibility (unit tests without glyph_id)
+            positions = find_pattern_positions(charstring, pattern)
+
+            positions.each do |position|
+              replacements << [position, pattern]
+            end
           end
         end
 
@@ -140,7 +151,7 @@ module Fontisan
       # @param charstring [String] CharString to search
       # @param pattern [Pattern] pattern to find
       # @return [Array<Integer>] array of start positions
-      def find_pattern_positions(charstring, pattern)
+      def find_pattern_positions(charstring, pattern, glyph_id = nil)
         positions = []
         offset = 0
 

data/lib/fontisan/optimizers/pattern_analyzer.rb

@@ -160,7 +160,9 @@ module Fontisan
                         charstrings.length
                       end
 
-        sampled_glyphs = charstrings.keys.sample(sample_size)
+        # Use deterministic selection instead of random sampling
+        # Sort keys first to ensure consistent ordering across platforms
+        sampled_glyphs = charstrings.keys.sort.take(sample_size)
 
         # NEW: Pre-compute boundaries for sampled glyphs
         # Check if boundaries are useful (more than just start position)
@@ -249,7 +251,7 @@ module Fontisan
           # Build positions hash
           positions = {}
           by_glyph.each do |glyph_id, glyph_occurrences|
-            positions[glyph_id] = glyph_occurrences.map(&:last)
+            positions[glyph_id] = glyph_occurrences.map(&:last).uniq
           end
 
           @patterns[bytes] = Pattern.new(

data/lib/fontisan/optimizers/subroutine_builder.rb

@@ -95,22 +95,23 @@ module Fontisan
       # @return [String] encoded bytes
       def encode_integer(num)
         # Range 1: -107 to 107 (single byte)
+        # CFF spec: byte value = 139 + number
         if num >= -107 && num <= 107
-          return [32 + num].pack("c")
+          return [139 + num].pack("C")
         end
 
         # Range 2: 108 to 1131 (two bytes)
         if num >= 108 && num <= 1131
           b0 = 247 + ((num - 108) >> 8)
           b1 = (num - 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 3: -1131 to -108 (two bytes)
         if num >= -1131 && num <= -108
           b0 = 251 - ((num + 108) >> 8)
           b1 = -(num + 108) & 0xff
-          return [b0, b1].pack("c*")
+          return [b0, b1].pack("C*")
         end
 
         # Range 4: -32768 to 32767 (three bytes)
@@ -118,7 +119,7 @@ module Fontisan
           b0 = 29
           b1 = (num >> 8) & 0xff
           b2 = num & 0xff
-          return [b0, b1, b2].pack("c*")
+          return [b0, b1, b2].pack("C*")
         end
 
         # Range 5: Larger numbers (five bytes)
@@ -127,7 +128,7 @@ module Fontisan
         b2 = (num >> 16) & 0xff
         b3 = (num >> 8) & 0xff
         b4 = num & 0xff
-        [b0, b1, b2, b3, b4].pack("c*")
+        [b0, b1, b2, b3, b4].pack("C*")
       end
     end
   end

data/lib/fontisan/optimizers/subroutine_optimizer.rb

@@ -30,7 +30,9 @@ module Fontisan
       # @return [Array<Pattern>] selected patterns
       def optimize_selection
         selected = []
-        remaining = @patterns.sort_by { |p| -p.savings }
+        # Sort by savings (descending), then by length (descending), then by min glyph ID,
+        # then by byte values for complete determinism across platforms
+        remaining = @patterns.sort_by { |p| [-p.savings, -p.length, p.glyphs.min, p.bytes.bytes] }
 
         remaining.each do |pattern|
           break if selected.length >= @max_subrs
@@ -50,7 +52,8 @@ module Fontisan
       # @return [Array<Pattern>] ordered subroutines
       def optimize_ordering(subroutines)
         # Higher frequency = lower ID (shorter encoding)
-        subroutines.sort_by { |subr| -subr.frequency }
+        # Use same comprehensive sort keys as optimize_selection for consistency
+        subroutines.sort_by { |subr| [-subr.frequency, -subr.length, subr.glyphs.min, subr.bytes.bytes] }
       end
 
       # Check if nesting would be beneficial

data/lib/fontisan/pipeline/output_writer.rb

@@ -96,9 +96,9 @@ module Fontisan
 
         writer = Converters::WoffWriter.new
         font = build_font_from_tables(tables)
-        result = writer.convert(font, @options)
+        woff_data = writer.convert(font, @options)
 
-        File.binwrite(@output_path, result[:woff_data])
+        File.binwrite(@output_path, woff_data)
       end
 
       # Write WOFF2 format

data/lib/fontisan/tables/cbdt.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Tables
+    # CBDT (Color Bitmap Data) table parser
+    #
+    # The CBDT table contains the actual bitmap data for color glyphs. It works
+    # together with the CBLC table which provides the location information for
+    # finding bitmaps in this table.
+    #
+    # CBDT Table Structure:
+    # ```
+    # CBDT Table = Header (8 bytes)
+    #            + Bitmap Data (variable length)
+    # ```
+    #
+    # Header (8 bytes):
+    # - majorVersion (uint16): Major version (2 or 3)
+    # - minorVersion (uint16): Minor version (0)
+    # - reserved (uint32): Reserved, set to 0
+    #
+    # The bitmap data format depends on the index subtable format in CBLC.
+    # Common formats include:
+    # - Format 17: Small metrics, PNG data
+    # - Format 18: Big metrics, PNG data
+    # - Format 19: Metrics in CBLC, PNG data
+    #
+    # This parser provides low-level access to bitmap data. For proper bitmap
+    # extraction, use together with CBLC table which contains the index.
+    #
+    # Reference: OpenType CBDT specification
+    # https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt
+    #
+    # @example Reading a CBDT table
+    #   data = font.table_data['CBDT']
+    #   cbdt = Fontisan::Tables::Cbdt.read(data)
+    #   bitmap_data = cbdt.bitmap_data_at(offset, length)
+    class Cbdt < Binary::BaseRecord
+      # OpenType table tag for CBDT
+      TAG = "CBDT"
+
+      # Supported CBDT versions
+      VERSION_2_0 = 0x0002_0000
+      VERSION_3_0 = 0x0003_0000
+
+      # @return [Integer] Major version (2 or 3)
+      attr_reader :major_version
+
+      # @return [Integer] Minor version (0)
+      attr_reader :minor_version
+
+      # @return [String] Raw binary data for the entire CBDT table
+      attr_reader :raw_data
+
+      # Override read to parse CBDT structure
+      #
+      # @param io [IO, String] Binary data to read
+      # @return [Cbdt] Parsed CBDT table
+      def self.read(io)
+        cbdt = new
+        return cbdt if io.nil?
+
+        data = io.is_a?(String) ? io : io.read
+        cbdt.parse!(data)
+        cbdt
+      end
+
+      # Parse the CBDT table structure
+      #
+      # @param data [String] Binary data for the CBDT table
+      # @raise [CorruptedTableError] If CBDT structure is invalid
+      def parse!(data)
+        @raw_data = data
+        io = StringIO.new(data)
+
+        # Parse CBDT header (8 bytes)
+        parse_header(io)
+        validate_header!
+      rescue StandardError => e
+        raise CorruptedTableError, "Failed to parse CBDT table: #{e.message}"
+      end
+
+      # Get bitmap data at specific offset and length
+      #
+      # Used together with CBLC index to extract bitmap data.
+      #
+      # @param offset [Integer] Offset from start of table
+      # @param length [Integer] Length of bitmap data
+      # @return [String, nil] Binary bitmap data or nil
+      def bitmap_data_at(offset, length)
+        return nil if offset.nil? || length.nil?
+        return nil if offset.negative? || length.negative?
+        return nil if offset + length > raw_data.length
+
+        raw_data[offset, length]
+      end
+
+      # Get combined version number
+      #
+      # @return [Integer] Combined version (e.g., 0x00020000 for v2.0)
+      def version
+        return nil if major_version.nil? || minor_version.nil?
+
+        (major_version << 16) | minor_version
+      end
+
+      # Get table data size
+      #
+      # @return [Integer] Size of CBDT table in bytes
+      def data_size
+        raw_data&.length || 0
+      end
+
+      # Check if offset is valid for this table
+      #
+      # @param offset [Integer] Offset to check
+      # @return [Boolean] True if offset is within table bounds
+      def valid_offset?(offset)
+        return false if offset.nil? || offset.negative?
+        return false if raw_data.nil?
+
+        offset < raw_data.length
+      end
+
+      # Validate the CBDT table structure
+      #
+      # @return [Boolean] True if valid
+      def valid?
+        return false if major_version.nil? || minor_version.nil?
+        return false unless [2, 3].include?(major_version)
+        return false unless minor_version.zero?
+        return false unless raw_data
+
+        true
+      end
+
+      private
+
+      # Parse CBDT header (8 bytes)
+      #
+      # @param io [StringIO] Input stream
+      def parse_header(io)
+        @major_version = io.read(2).unpack1("n")
+        @minor_version = io.read(2).unpack1("n")
+        @reserved = io.read(4).unpack1("N")
+      end
+
+      # Validate header values
+      #
+      # @raise [CorruptedTableError] If validation fails
+      def validate_header!
+        unless [2, 3].include?(major_version)
+          raise CorruptedTableError,
+                "Unsupported CBDT major version: #{major_version} " \
+                "(only versions 2 and 3 supported)"
+        end
+
+        unless minor_version.zero?
+          raise CorruptedTableError,
+                "Unsupported CBDT minor version: #{minor_version} " \
+                "(only version 0 supported)"
+        end
+      end
+    end
+  end
+end