fontisan 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56f9d8ef4cfdc6eff4a70e8a6c658d276342e2ef11a272e2ba4e683fa8b1ce6e
-  data.tar.gz: a6a0102247dbd1069785afab4b296bc2ade281be5e81526aa3e89029ca61ac56
+  metadata.gz: d5afdba14f32dbf6e482d0f17c64afdcc5dbe62b0567f59e42287234757ec1c3
+  data.tar.gz: 6bdf19ae13494e1599dbb523bab6e6b7179ac288ac4d65d26b3cefb1e749878b
 SHA512:
-  metadata.gz: f8e8b4df368e19a52bf9c3bc3c2e0d58cb33f7d2235c67b5f077abfa2a4ca1b2e00c21b29d9c56e72cbb167d43b178d295bc95676518c9de7d0c66a3fbc52383
-  data.tar.gz: 7e42e9a834e044c5577523a22a32d79eb92a32769e244c24c1b52cfe6242a2dbb4da0370e536abc8e66cbdfb38ee5eecc53e68e238a643902dc06105d08ac62c
+  metadata.gz: e4e5fe71fe99f4edef0432684799419d4bcd634bffd879b804955a3777728a50828797210766e8cd3c2141cbbd7b0a23adb8feef0f8046557548be3d77ff5bbb
+  data.tar.gz: 287c2f971e1c439de9d1465dbd244247ba65ad57fe2babecb873632429b9f04a935b569e9a1660ab47201e0b4604dac6947642b14b5dc28f353abc97a04c8661

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-01-17 04:54:25 UTC using RuboCop version 1.82.1.
+# on 2026-01-17 10:49:34 UTC using RuboCop version 1.82.1.
 # 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
@@ -11,14 +11,7 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'fontisan.gemspec'
 
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowForAlignment, AllowBeforeTrailingComments, ForceEqualSignAlignment.
-Layout/ExtraSpacing:
-  Exclude:
-    - 'lib/fontisan/sfnt_font.rb'
-
-# Offense count: 1259
+# Offense count: 1261
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -65,6 +58,11 @@ Lint/FloatComparison:
   Exclude:
     - 'lib/fontisan/tables/post.rb'
 
+# Offense count: 2
+Lint/HashCompareByIdentity:
+  Exclude:
+    - 'lib/fontisan/collection/table_analyzer.rb'
+
 # Offense count: 3
 Lint/IneffectiveAccessModifier:
   Exclude:
@@ -97,7 +95,13 @@ Lint/UnusedMethodArgument:
     - 'lib/fontisan/woff2/glyf_transformer.rb'
     - 'lib/fontisan/woff_font.rb'
 
-# Offense count: 477
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+Lint/UselessAssignment:
+  Exclude:
+    - 'lib/fontisan/converters/cff_table_builder.rb'
+
+# Offense count: 480
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -113,23 +117,23 @@ Metrics/BlockLength:
 Metrics/BlockNesting:
   Max: 5
 
-# Offense count: 238
+# Offense count: 239
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 785
+# Offense count: 788
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 135
 
-# Offense count: 20
+# Offense count: 21
 # Configuration parameters: CountKeywordArgs.
 Metrics/ParameterLists:
   Max: 39
   MaxOptionalParameters: 4
 
-# Offense count: 175
+# Offense count: 176
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -377,3 +381,10 @@ Style/HashLikeCase:
     - 'lib/fontisan/commands/convert_command.rb'
     - 'lib/fontisan/commands/unpack_command.rb'
     - 'lib/fontisan/models/validation_report.rb'
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowNamedUnderscoreVariables.
+Style/TrailingUnderscoreVariable:
+  Exclude:
+    - 'lib/fontisan/converters/cff_table_builder.rb'

data/lib/fontisan/collection/table_analyzer.rb

@@ -23,8 +23,10 @@ module Fontisan
       # Initialize analyzer with fonts
       #
       # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Fonts to analyze
+      # @param parallel [Boolean] Use parallel processing for large collections (default: false)
+      # @param thread_count [Integer] Number of threads for parallel processing (default: 4)
       # @raise [ArgumentError] if fonts array is empty or contains invalid fonts
-      def initialize(fonts)
+      def initialize(fonts, parallel: false, thread_count: 4)
         if fonts.nil? || fonts.empty?
           raise ArgumentError,
                 "fonts cannot be nil or empty"
@@ -32,7 +34,10 @@ module Fontisan
         raise ArgumentError, "fonts must be an array" unless fonts.is_a?(Array)
 
         @fonts = fonts
+        @parallel = parallel
+        @thread_count = thread_count
         @report = nil
+        @checksum_cache = {}.compare_by_identity
       end
 
       # Analyze tables across all fonts
@@ -103,6 +108,17 @@ module Fontisan
       #
       # @return [void]
       def collect_table_checksums
+        if @parallel && @fonts.size > 2
+          collect_table_checksums_parallel
+        else
+          collect_table_checksums_sequential
+        end
+      end
+
+      # Collect checksums sequentially (original implementation)
+      #
+      # @return [void]
+      def collect_table_checksums_sequential
         @fonts.each_with_index do |font, font_index|
           font.table_names.each do |tag|
             # Get raw table data
@@ -120,6 +136,71 @@ module Fontisan
         end
       end
 
+      # Collect checksums in parallel using thread pool (lock-free)
+      #
+      # Uses thread-local storage to avoid mutexes. Each thread processes
+      # its assigned fonts with isolated state, then results are aggregated
+      # in a single thread after all parallel work completes.
+      #
+      # @return [void]
+      def collect_table_checksums_parallel
+        # Partition fonts among threads
+        partition_size = (@fonts.size.to_f / @thread_count).ceil
+        partitions = @fonts.each_slice(partition_size).to_a
+
+        # Track starting index for each partition
+        partition_start_indices = []
+        current_index = 0
+        partitions.each do |partition|
+          partition_start_indices << current_index
+          current_index += partition.size
+        end
+
+        # Process each partition in a separate thread with isolated state
+        # No mutexes needed - each thread has its own local_checksum_cache and local_results
+        threads = partitions.each_with_index.map do |partition, partition_index|
+          start_index = partition_start_indices[partition_index]
+
+          Thread.new do
+            local_checksum_cache = {}.compare_by_identity
+            local_results = {}
+
+            partition.each_with_index do |font, relative_index|
+              font_index = start_index + relative_index
+
+              font.table_names.each do |tag|
+                table_data = font.table_data[tag]
+                next unless table_data
+
+                # Thread-local cache - no locks needed
+                checksum = local_checksum_cache[table_data] ||= Digest::SHA256.hexdigest(table_data)
+
+                local_results[tag] ||= {}
+                local_results[tag][checksum] ||= []
+                local_results[tag][checksum] << font_index
+              end
+            end
+
+            # Return thread-local results for aggregation
+            local_results
+          end
+        end
+
+        # Wait for all threads to complete and aggregate results
+        # Single-threaded aggregation - no locks needed
+        threads.each do |thread|
+          local_results = thread.value
+
+          local_results.each do |tag, checksums|
+            @report[:table_checksums][tag] ||= {}
+            checksums.each do |checksum, font_indices|
+              @report[:table_checksums][tag][checksum] ||= []
+              @report[:table_checksums][tag][checksum].concat(font_indices)
+            end
+          end
+        end
+      end
+
       # Identify which tables are shared across fonts
       #
       # A table is considered shared if 2 or more fonts have identical content
@@ -192,12 +273,16 @@ module Fontisan
         end
       end
 
-      # Calculate SHA256 checksum for table data
+      # Calculate SHA256 checksum for table data with caching
+      #
+      # Caches checksums by data object identity to avoid recomputing
+      # SHA256 for identical table data across multiple fonts.
+      # In parallel mode, each thread has its own cache (no locks needed).
       #
       # @param data [String] Binary table data
       # @return [String] Hexadecimal checksum
       def calculate_checksum(data)
-        Digest::SHA256.hexdigest(data)
+        @checksum_cache[data] ||= Digest::SHA256.hexdigest(data)
       end
     end
   end

data/lib/fontisan/converters/cff_table_builder.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "../tables/cff/index_builder"
+require_relative "../tables/cff/dict_builder"
+
+module Fontisan
+  module Converters
+    # Builds CFF table data from glyph outlines
+    #
+    # This module handles the construction of complete CFF tables including
+    # all INDEX structures (name, Top DICT, String, GlobalSubr, CharStrings, LocalSubr)
+    # and the Private DICT.
+    #
+    # The CFF table structure is:
+    # - Header (4 bytes)
+    # - Name INDEX
+    # - Top DICT INDEX
+    # - String INDEX
+    # - Global Subr INDEX
+    # - CharStrings INDEX
+    # - Private DICT (with offset in Top DICT)
+    # - Local Subr INDEX (with offset in Private DICT)
+    module CffTableBuilder
+      # Build complete CFF table from pre-built charstrings
+      #
+      # @param charstrings [Array<String>] Pre-built CharString data (already optimized if needed)
+      # @param local_subrs [Array<String>] Local subroutines from optimization
+      # @param font [TrueTypeFont] Source font (for metadata)
+      # @return [String] Complete CFF table binary data
+      def build_cff_table(charstrings, local_subrs, font)
+        # If we have local subrs from optimization, use them
+        local_subrs = [] unless local_subrs.is_a?(Array)
+
+        # Build font metadata
+        font_name = extract_font_name(font)
+
+        # Build all INDEXes
+        header_size = 4
+        name_index_data = Tables::Cff::IndexBuilder.build([font_name])
+        string_index_data = Tables::Cff::IndexBuilder.build([]) # Empty strings
+        global_subr_index_data = Tables::Cff::IndexBuilder.build([]) # Empty global subrs
+        charstrings_index_data = Tables::Cff::IndexBuilder.build(charstrings)
+        local_subrs_index_data = Tables::Cff::IndexBuilder.build(local_subrs)
+
+        # Build Private DICT with Subrs offset if we have local subroutines
+        private_dict_data, private_dict_size = build_private_dict(local_subrs)
+
+        # Calculate offsets with iterative refinement
+        top_dict_index_data, =
+          calculate_cff_offsets(
+            header_size,
+            name_index_data,
+            string_index_data,
+            global_subr_index_data,
+            charstrings_index_data,
+            private_dict_size,
+          )
+
+        # Build CFF Header
+        header = build_cff_header
+
+        # Assemble complete CFF table
+        header +
+          name_index_data +
+          top_dict_index_data +
+          string_index_data +
+          global_subr_index_data +
+          charstrings_index_data +
+          private_dict_data +
+          local_subrs_index_data
+      end
+
+      private
+
+      # Build Private DICT with optional Subrs offset
+      #
+      # @param local_subrs [Array<String>] Local subroutines
+      # @return [Array<String, Integer>] [Private DICT data, size]
+      def build_private_dict(local_subrs)
+        private_dict_hash = {
+          default_width_x: 1000,
+          nominal_width_x: 0,
+        }
+
+        # If we have local subroutines, add Subrs offset
+        # Subrs offset is relative to Private DICT start
+        if local_subrs.any?
+          # Add a placeholder Subrs offset first to get accurate size
+          private_dict_hash[:subrs] = 0
+
+          # Calculate size of Private DICT with Subrs entry
+          temp_private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
+          subrs_offset = temp_private_dict_data.bytesize
+
+          # Update with actual Subrs offset
+          private_dict_hash[:subrs] = subrs_offset
+        end
+
+        # Build final Private DICT
+        private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
+        [private_dict_data, private_dict_data.bytesize]
+      end
+
+      # Calculate CFF table offsets with iterative refinement
+      #
+      # @param header_size [Integer] CFF header size
+      # @param name_index_data [String] Name INDEX data
+      # @param string_index_data [String] String INDEX data
+      # @param global_subr_index_data [String] Global Subr INDEX data
+      # @param charstrings_index_data [String] CharStrings INDEX data
+      # @param private_dict_size [Integer] Private DICT size
+      # @return [Array<String, Integer, Integer>] [Top DICT INDEX, CharStrings offset, Private DICT offset]
+      def calculate_cff_offsets(
+        header_size,
+        name_index_data,
+        string_index_data,
+        global_subr_index_data,
+        charstrings_index_data,
+        private_dict_size
+      )
+        # Initial pass
+        top_dict_index_start = header_size + name_index_data.bytesize
+        string_index_start = top_dict_index_start + 100 # Approximate
+        global_subr_index_start = string_index_start + string_index_data.bytesize
+        charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
+
+        # Build Top DICT
+        top_dict_hash = {
+          charset: 0,
+          encoding: 0,
+          charstrings: charstrings_offset,
+        }
+        top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
+        top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
+
+        # Recalculate with actual Top DICT size
+        string_index_start = top_dict_index_start + top_dict_index_data.bytesize
+        global_subr_index_start = string_index_start + string_index_data.bytesize
+        charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
+        private_dict_offset = charstrings_offset + charstrings_index_data.bytesize
+
+        # Update Top DICT with Private DICT info
+        top_dict_hash = {
+          charset: 0,
+          encoding: 0,
+          charstrings: charstrings_offset,
+          private: [private_dict_size, private_dict_offset],
+        }
+        top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
+        top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
+
+        # Final recalculation
+        string_index_start = top_dict_index_start + top_dict_index_data.bytesize
+        global_subr_index_start = string_index_start + string_index_data.bytesize
+        charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
+        private_dict_offset = charstrings_offset + charstrings_index_data.bytesize
+
+        # Final Top DICT
+        top_dict_hash = {
+          charset: 0,
+          encoding: 0,
+          charstrings: charstrings_offset,
+          private: [private_dict_size, private_dict_offset],
+        }
+        top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
+        top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
+
+        [top_dict_index_data, charstrings_offset, private_dict_offset]
+      end
+
+      # Build CFF Header
+      #
+      # @return [String] 4-byte CFF header
+      def build_cff_header
+        [
+          1,    # major version
+          0,    # minor version
+          4,    # header size
+          4,    # offSize (will be in INDEX)
+        ].pack("C4")
+      end
+
+      # Extract font name from name table
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font
+      # @return [String] Font name
+      def extract_font_name(font)
+        name_table = font.table("name")
+        if name_table
+          font_name = name_table.english_name(Tables::Name::FAMILY)
+          return font_name.dup.force_encoding("ASCII-8BIT") if font_name
+        end
+
+        "UnnamedFont"
+      end
+    end
+  end
+end

data/lib/fontisan/converters/glyf_table_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../tables/glyf/glyph_builder"
+
+module Fontisan
+  module Converters
+    # Builds glyf and loca tables from glyph outlines
+    #
+    # This module handles the construction of TrueType glyph tables:
+    # - glyf table: Contains actual glyph outline data
+    # - loca table: Contains offsets to glyph data in glyf table
+    #
+    # The loca table format depends on the maximum offset:
+    # - Short format (offsets/2) if max offset <= 0x1FFFE
+    # - Long format (raw offsets) if max offset > 0x1FFFE
+    module GlyfTableBuilder
+      # Build glyf and loca tables from outlines
+      #
+      # @param outlines [Array<Outline>] Glyph outlines
+      # @return [Array<String, String, Integer>] [glyf_data, loca_data, loca_format]
+      def build_glyf_loca_tables(outlines)
+        glyf_data = "".b
+        offsets = []
+
+        # Build each glyph
+        outlines.each do |outline|
+          offsets << glyf_data.bytesize
+
+          if outline.empty?
+            # Empty glyph - no data
+            next
+          end
+
+          # Build glyph data using GlyphBuilder class method
+          glyph_data = Fontisan::Tables::GlyphBuilder.build_simple_glyph(outline)
+          glyf_data << glyph_data
+
+          # Add padding to 4-byte boundary
+          padding = (4 - (glyf_data.bytesize % 4)) % 4
+          glyf_data << ("\x00" * padding) if padding.positive?
+        end
+
+        # Add final offset
+        offsets << glyf_data.bytesize
+
+        # Build loca table
+        # Determine format based on max offset
+        max_offset = offsets.max
+        if max_offset <= 0x1FFFE
+          # Short format (offsets / 2)
+          loca_format = 0
+          loca_data = offsets.map { |off| off / 2 }.pack("n*")
+        else
+          # Long format
+          loca_format = 1
+          loca_data = offsets.pack("N*")
+        end
+
+        [glyf_data, loca_data, loca_format]
+      end
+    end
+  end
+end

data/lib/fontisan/converters/outline_converter.rb

@@ -4,14 +4,10 @@ require_relative "conversion_strategy"
 require_relative "../outline_extractor"
 require_relative "../models/outline"
 require_relative "../tables/cff/charstring_builder"
-require_relative "../tables/cff/index_builder"
-require_relative "../tables/cff/dict_builder"
-require_relative "../tables/glyf/glyph_builder"
-require_relative "../tables/glyf/compound_glyph_resolver"
-require_relative "../optimizers/pattern_analyzer"
-require_relative "../optimizers/subroutine_optimizer"
-require_relative "../optimizers/subroutine_builder"
-require_relative "../optimizers/charstring_rewriter"
+require_relative "outline_extraction"
+require_relative "cff_table_builder"
+require_relative "glyf_table_builder"
+require_relative "outline_optimizer"
 require_relative "../hints/truetype_hint_extractor"
 require_relative "../hints/postscript_hint_extractor"
 require_relative "../hints/hint_converter"
@@ -67,6 +63,10 @@ module Fontisan
     #   otf_font = converter.convert(ttf_font, target_format: :otf, preserve_hints: true)
     class OutlineConverter
       include ConversionStrategy
+      include OutlineExtraction
+      include CffTableBuilder
+      include GlyfTableBuilder
+      include OutlineOptimizer
 
       # Supported outline formats
       SUPPORTED_FORMATS = %i[ttf otf cff2].freeze
@@ -138,8 +138,30 @@ module Fontisan
         # Extract hints if preservation is enabled
         hints_per_glyph = @preserve_hints ? extract_ttf_hints(font) : {}
 
-        # Build CFF table from outlines and hints
-        cff_data = build_cff_table(outlines, font, hints_per_glyph)
+        # Build CharStrings from outlines
+        charstrings = outlines.map do |outline|
+          builder = Tables::Cff::CharStringBuilder.new
+          if outline.empty?
+            builder.build_empty
+          else
+            builder.build(outline)
+          end
+        end
+
+        # Apply subroutine optimization if enabled
+        local_subrs = []
+        if @optimize_cff
+          begin
+            charstrings, local_subrs = optimize_charstrings(charstrings)
+          rescue StandardError => e
+            # If optimization fails, fall back to unoptimized CharStrings
+            warn "CFF optimization failed: #{e.message}, using unoptimized CharStrings"
+            local_subrs = []
+          end
+        end
+
+        # Build CFF table from charstrings and local subrs
+        cff_data = build_cff_table(charstrings, local_subrs, font)
 
         # Copy all tables except glyf/loca
         tables = copy_tables(font, %w[glyf loca])
@@ -184,8 +206,7 @@ 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)
 
         # Copy all tables except CFF
         tables = copy_tables(font, ["CFF ", "CFF2"])
@@ -279,285 +300,6 @@ module Fontisan
         true
       end
 
-      # Extract outlines from TrueType font
-      #
-      # @param font [TrueTypeFont] Source font
-      # @return [Array<Outline>] Array of outline objects
-      def extract_ttf_outlines(font)
-        # Get required tables
-        head = font.table("head")
-        maxp = font.table("maxp")
-        loca = font.table("loca")
-        glyf = font.table("glyf")
-
-        # Parse loca with context
-        loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
-
-        # Create resolver for compound glyphs
-        resolver = Tables::CompoundGlyphResolver.new(glyf, loca, head)
-
-        # Extract all glyphs
-        outlines = []
-        maxp.num_glyphs.times do |glyph_id|
-          glyph = glyf.glyph_for(glyph_id, loca, head)
-
-          outlines << if glyph.nil? || glyph.empty?
-                        # Empty glyph - create empty outline
-                        Models::Outline.new(
-                          glyph_id: glyph_id,
-                          commands: [],
-                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
-                        )
-                      elsif glyph.simple?
-                        # Convert simple glyph to outline
-                        Models::Outline.from_truetype(glyph, glyph_id)
-                      else
-                        # Compound glyph - resolve to simple outline
-                        resolver.resolve(glyph)
-                      end
-        end
-
-        outlines
-      end
-
-      # Extract outlines from CFF font
-      #
-      # @param font [OpenTypeFont] Source font
-      # @return [Array<Outline>] Array of outline objects
-      def extract_cff_outlines(font)
-        # Get CFF table
-        cff = font.table("CFF ")
-        raise Fontisan::Error, "CFF table not found" unless cff
-
-        # Get number of glyphs
-        num_glyphs = cff.glyph_count
-
-        # Extract all glyphs
-        outlines = []
-        num_glyphs.times do |glyph_id|
-          charstring = cff.charstring_for_glyph(glyph_id)
-
-          outlines << if charstring.nil? || charstring.path.empty?
-                        # Empty glyph
-                        Models::Outline.new(
-                          glyph_id: glyph_id,
-                          commands: [],
-                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
-                        )
-                      else
-                        # Convert CharString to outline
-                        Models::Outline.from_cff(charstring, glyph_id)
-                      end
-        end
-
-        outlines
-      end
-
-      # Build CFF table from outlines
-      #
-      # @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)
-        # Build CharStrings INDEX from outlines
-        begin
-          charstrings = outlines.map do |outline|
-            builder = Tables::Cff::CharStringBuilder.new
-            if outline.empty?
-              builder.build_empty
-            else
-              builder.build(outline)
-            end
-          end
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to build CharStrings: #{e.message}"
-        end
-
-        # Apply subroutine optimization if enabled
-        local_subrs = []
-
-        if @optimize_cff
-          begin
-            charstrings, local_subrs = optimize_charstrings(charstrings)
-          rescue StandardError => e
-            # If optimization fails, fall back to unoptimized CharStrings
-            warn "CFF optimization failed: #{e.message}, using unoptimized CharStrings"
-            local_subrs = []
-          end
-        end
-
-        # Build font metadata
-        begin
-          font_name = extract_font_name(font)
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to extract font name: #{e.message}"
-        end
-
-        # Build all INDEXes
-        begin
-          header_size = 4
-          name_index_data = Tables::Cff::IndexBuilder.build([font_name])
-          string_index_data = Tables::Cff::IndexBuilder.build([]) # Empty strings
-          global_subr_index_data = Tables::Cff::IndexBuilder.build([]) # Empty global subrs
-          charstrings_index_data = Tables::Cff::IndexBuilder.build(charstrings)
-          local_subrs_index_data = Tables::Cff::IndexBuilder.build(local_subrs)
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to build CFF indexes: #{e.message}"
-        end
-
-        # Build Private DICT with Subrs offset if we have local subroutines
-        begin
-          private_dict_hash = {
-            default_width_x: 1000,
-            nominal_width_x: 0,
-          }
-
-          # If we have local subroutines, add Subrs offset
-          # Subrs offset is relative to Private DICT start
-          if local_subrs.any?
-            # Add a placeholder Subrs offset first to get accurate size
-            private_dict_hash[:subrs] = 0
-
-            # Calculate size of Private DICT with Subrs entry
-            temp_private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
-            subrs_offset = temp_private_dict_data.bytesize
-
-            # Update with actual Subrs offset
-            private_dict_hash[:subrs] = subrs_offset
-          end
-
-          # Build final Private DICT
-          private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
-          private_dict_size = private_dict_data.bytesize
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to build Private DICT: #{e.message}"
-        end
-
-        # Calculate offsets with iterative refinement
-        begin
-          # Initial pass
-          top_dict_index_start = header_size + name_index_data.bytesize
-          string_index_start = top_dict_index_start + 100 # Approximate
-          global_subr_index_start = string_index_start + string_index_data.bytesize
-          charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
-
-          # Build Top DICT
-          top_dict_hash = {
-            charset: 0,
-            encoding: 0,
-            charstrings: charstrings_offset,
-          }
-          top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
-          top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
-
-          # Recalculate with actual Top DICT size
-          string_index_start = top_dict_index_start + top_dict_index_data.bytesize
-          global_subr_index_start = string_index_start + string_index_data.bytesize
-          charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
-          private_dict_offset = charstrings_offset + charstrings_index_data.bytesize
-
-          # Update Top DICT with Private DICT info
-          top_dict_hash = {
-            charset: 0,
-            encoding: 0,
-            charstrings: charstrings_offset,
-            private: [private_dict_size, private_dict_offset],
-          }
-          top_dict_data = Tables::Cff::DictBuilder.build(top_dict_hash)
-          top_dict_index_data = Tables::Cff::IndexBuilder.build([top_dict_data])
-
-          # Final recalculation
-          string_index_start = top_dict_index_start + top_dict_index_data.bytesize
-          global_subr_index_start = string_index_start + string_index_data.bytesize
-          charstrings_offset = global_subr_index_start + global_subr_index_data.bytesize
-          private_dict_offset = charstrings_offset + charstrings_index_data.bytesize
-
-          # Final Top DICT
-          top_dict_hash = {
-            charset: 0,
-            encoding: 0,
-            charstrings: charstrings_offset,
-            private: [private_dict_size, private_dict_offset],
-          }
-          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}"
-        end
-
-        # Build CFF Header
-        begin
-          header = [
-            1,    # major version
-            0,    # minor version
-            4,    # header size
-            4,    # offSize (will be in INDEX)
-          ].pack("C4")
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to build CFF header: #{e.message}"
-        end
-
-        # Assemble complete CFF table
-        begin
-          header +
-            name_index_data +
-            top_dict_index_data +
-            string_index_data +
-            global_subr_index_data +
-            charstrings_index_data +
-            private_dict_data +
-            local_subrs_index_data
-        rescue StandardError => e
-          raise Fontisan::Error, "Failed to assemble CFF table: #{e.message}"
-        end
-      end
-
-      # Build glyf and loca tables from outlines
-      #
-      # @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)
-        glyf_data = "".b
-        offsets = []
-
-        # Build each glyph
-        outlines.each do |outline|
-          offsets << glyf_data.bytesize
-
-          if outline.empty?
-            # Empty glyph - no data
-            next
-          end
-
-          # Build glyph data using GlyphBuilder class method
-          glyph_data = Fontisan::Tables::GlyphBuilder.build_simple_glyph(outline)
-          glyf_data << glyph_data
-
-          # Add padding to 4-byte boundary
-          padding = (4 - (glyf_data.bytesize % 4)) % 4
-          glyf_data << ("\x00" * padding) if padding.positive?
-        end
-
-        # Add final offset
-        offsets << glyf_data.bytesize
-
-        # Build loca table
-        # Determine format based on max offset
-        max_offset = offsets.max
-        if max_offset <= 0x1FFFE
-          # Short format (offsets / 2)
-          loca_format = 0
-          loca_data = offsets.map { |off| off / 2 }.pack("n*")
-        else
-          # Long format
-          loca_format = 1
-          loca_data = offsets.pack("N*")
-        end
-
-        [glyf_data, loca_data, loca_format]
-      end
-
       # Copy non-outline tables from source to target
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font
@@ -664,85 +406,6 @@ module Fontisan
         head_data
       end
 
-      # Extract font name from name table
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] Font
-      # @return [String] Font name
-      def extract_font_name(font)
-        name_table = font.table("name")
-        if name_table
-          font_name = name_table.english_name(Tables::Name::FAMILY)
-          return font_name.dup.force_encoding("ASCII-8BIT") if font_name
-        end
-
-        "UnnamedFont"
-      end
-
-      # Optimize CharStrings using subroutine extraction
-      #
-      # @param charstrings [Array<String>] Original CharString bytes
-      # @return [Array<Array<String>, Array<String>>] [optimized_charstrings, local_subrs]
-      def optimize_charstrings(charstrings)
-        # Convert to hash format expected by PatternAnalyzer
-        charstrings_hash = {}
-        charstrings.each_with_index do |cs, index|
-          charstrings_hash[index] = cs
-        end
-
-        # Analyze patterns
-        analyzer = Optimizers::PatternAnalyzer.new(
-          min_length: 10,
-          stack_aware: true,
-        )
-        patterns = analyzer.analyze(charstrings_hash)
-
-        # Return original if no patterns found
-        return [charstrings, []] if patterns.empty?
-
-        # Optimize selection
-        optimizer = Optimizers::SubroutineOptimizer.new(patterns,
-                                                        max_subrs: 65_535)
-        selected_patterns = optimizer.optimize_selection
-
-        # Optimize ordering
-        selected_patterns = optimizer.optimize_ordering(selected_patterns)
-
-        # Return original if no patterns selected
-        return [charstrings, []] if selected_patterns.empty?
-
-        # Build subroutines
-        builder = Optimizers::SubroutineBuilder.new(selected_patterns,
-                                                    type: :local)
-        local_subrs = builder.build
-
-        # Build subroutine map
-        subroutine_map = {}
-        selected_patterns.each_with_index do |pattern, index|
-          subroutine_map[pattern.bytes] = index
-        end
-
-        # Rewrite CharStrings
-        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 do |p|
-            p.glyphs.include?(glyph_id)
-          end
-
-          if glyph_patterns.empty?
-            charstring
-          else
-            rewriter.rewrite(charstring, glyph_patterns, glyph_id)
-          end
-        end
-
-        [optimized_charstrings, local_subrs]
-      rescue StandardError => e
-        # If optimization fails for any reason, return original CharStrings
-        warn "Optimization warning: #{e.message}"
-        [charstrings, []]
-      end
-
       # Generate static instance from variable font
       #
       # @param font [TrueTypeFont, OpenTypeFont] Variable font

data/lib/fontisan/converters/outline_extraction.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../outline_extractor"
+require_relative "../tables/cff/charstring_builder"
+require_relative "../tables/glyf/glyph_builder"
+require_relative "../tables/glyf/compound_glyph_resolver"
+
+module Fontisan
+  module Converters
+    # Extracts all glyph outlines from a font for conversion purposes
+    #
+    # Unlike [`OutlineExtractor`](../outline_extractor.rb) which extracts
+    # single glyphs, this module extracts ALL glyphs from a font for
+    # bulk conversion operations.
+    #
+    # @see OutlineExtractor for single glyph extraction
+    module OutlineExtraction
+      # Extract all outlines from TrueType font
+      #
+      # @param font [TrueTypeFont] Source font
+      # @return [Array<Outline>] Array of outline objects
+      def extract_ttf_outlines(font)
+        # Get required tables
+        head = font.table("head")
+        maxp = font.table("maxp")
+        loca = font.table("loca")
+        glyf = font.table("glyf")
+
+        # Parse loca with context
+        loca.parse_with_context(head.index_to_loc_format, maxp.num_glyphs)
+
+        # Create resolver for compound glyphs
+        resolver = Tables::CompoundGlyphResolver.new(glyf, loca, head)
+
+        # Extract all glyphs
+        outlines = []
+        maxp.num_glyphs.times do |glyph_id|
+          glyph = glyf.glyph_for(glyph_id, loca, head)
+
+          outlines << if glyph.nil? || glyph.empty?
+                        # Empty glyph - create empty outline
+                        Models::Outline.new(
+                          glyph_id: glyph_id,
+                          commands: [],
+                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
+                        )
+                      elsif glyph.simple?
+                        # Convert simple glyph to outline
+                        Models::Outline.from_truetype(glyph, glyph_id)
+                      else
+                        # Compound glyph - resolve to simple outline
+                        resolver.resolve(glyph)
+                      end
+        end
+
+        outlines
+      end
+
+      # Extract all outlines from CFF font
+      #
+      # @param font [OpenTypeFont] Source font
+      # @return [Array<Outline>] Array of outline objects
+      def extract_cff_outlines(font)
+        # Get CFF table
+        cff = font.table("CFF ")
+        raise Fontisan::Error, "CFF table not found" unless cff
+
+        # Get number of glyphs
+        num_glyphs = cff.glyph_count
+
+        # Extract all glyphs
+        outlines = []
+        num_glyphs.times do |glyph_id|
+          charstring = cff.charstring_for_glyph(glyph_id)
+
+          outlines << if charstring.nil? || charstring.path.empty?
+                        # Empty glyph
+                        Models::Outline.new(
+                          glyph_id: glyph_id,
+                          commands: [],
+                          bbox: { x_min: 0, y_min: 0, x_max: 0, y_max: 0 },
+                        )
+                      else
+                        # Convert CharString to outline
+                        Models::Outline.from_cff(charstring, glyph_id)
+                      end
+        end
+
+        outlines
+      end
+    end
+  end
+end

data/lib/fontisan/converters/outline_optimizer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../optimizers/pattern_analyzer"
+require_relative "../optimizers/subroutine_optimizer"
+require_relative "../optimizers/subroutine_builder"
+require_relative "../optimizers/charstring_rewriter"
+
+module Fontisan
+  module Converters
+    # Optimizes CFF CharStrings using subroutine extraction
+    #
+    # This module analyzes CharStrings for repeated patterns, extracts
+    # them as subroutines, and rewrites the CharStrings to call the
+    # subroutines instead of repeating the code.
+    #
+    # The optimization process:
+    # 1. Analyze patterns across all CharStrings
+    # 2. Select optimal set of patterns for subroutines
+    # 3. Optimize subroutine ordering
+    # 4. Build subroutines from selected patterns
+    # 5. Rewrite CharStrings to call subroutines
+    module OutlineOptimizer
+      # Optimize CharStrings using subroutine extraction
+      #
+      # @param charstrings [Array<String>] Original CharString bytes
+      # @return [Array<Array<String>, Array<String>>] [optimized_charstrings, local_subrs]
+      def optimize_charstrings(charstrings)
+        # Convert to hash format expected by PatternAnalyzer
+        charstrings_hash = {}
+        charstrings.each_with_index do |cs, index|
+          charstrings_hash[index] = cs
+        end
+
+        # Analyze patterns
+        analyzer = Optimizers::PatternAnalyzer.new(
+          min_length: 10,
+          stack_aware: true,
+        )
+        patterns = analyzer.analyze(charstrings_hash)
+
+        # Return original if no patterns found
+        return [charstrings, []] if patterns.empty?
+
+        # Optimize selection
+        optimizer = Optimizers::SubroutineOptimizer.new(patterns,
+                                                        max_subrs: 65_535)
+        selected_patterns = optimizer.optimize_selection
+
+        # Optimize ordering
+        selected_patterns = optimizer.optimize_ordering(selected_patterns)
+
+        # Return original if no patterns selected
+        return [charstrings, []] if selected_patterns.empty?
+
+        # Build subroutines
+        builder = Optimizers::SubroutineBuilder.new(selected_patterns,
+                                                    type: :local)
+        local_subrs = builder.build
+
+        # Build subroutine map
+        subroutine_map = {}
+        selected_patterns.each_with_index do |pattern, index|
+          subroutine_map[pattern.bytes] = index
+        end
+
+        # Rewrite CharStrings
+        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 do |p|
+            p.glyphs.include?(glyph_id)
+          end
+
+          if glyph_patterns.empty?
+            charstring
+          else
+            rewriter.rewrite(charstring, glyph_patterns, glyph_id)
+          end
+        end
+
+        [optimized_charstrings, local_subrs]
+      rescue StandardError => e
+        # If optimization fails for any reason, return original CharStrings
+        warn "Optimization warning: #{e.message}"
+        [charstrings, []]
+      end
+    end
+  end
+end

data/lib/fontisan/glyph_accessor.rb

@@ -17,6 +17,7 @@ module Fontisan
   # - Metrics retrieval (advance width, left sidebearing)
   # - Glyph closure calculation for subsetting (tracks composite dependencies)
   # - Validation of glyph IDs and character mappings
+  # - Bounded LRU cache to prevent unbounded memory growth
   #
   # @example Basic usage
   #   font = Fontisan::TrueTypeFont.from_file('font.ttf')
@@ -41,6 +42,8 @@ module Fontisan
   #
   # Reference: [`docs/ttfunk-feature-analysis.md:541-575`](docs/ttfunk-feature-analysis.md:541)
   class GlyphAccessor
+    # Maximum number of glyphs to cache before LRU eviction
+    MAX_GLYPH_CACHE_SIZE = 10_000
     # Font instance this accessor operates on
     # @return [TrueTypeFont, OpenTypeFont]
     attr_reader :font
@@ -59,6 +62,7 @@ module Fontisan
       @font = font
       @glyph_cache = {}
       @closure_cache = {}
+      @glyph_access_times = {}
     end
 
     # Get glyph object for a glyph ID
@@ -83,7 +87,11 @@ module Fontisan
     def glyph_for_id(glyph_id)
       validate_glyph_id!(glyph_id)
 
-      return @glyph_cache[glyph_id] if @glyph_cache.key?(glyph_id)
+      # Check cache first and update access time
+      if @glyph_cache.key?(glyph_id)
+        @glyph_access_times[glyph_id] = Time.now.to_f
+        return @glyph_cache[glyph_id]
+      end
 
       glyph = if truetype?
                 truetype_glyph(glyph_id)
@@ -94,7 +102,12 @@ module Fontisan
                       "Font has neither glyf nor CFF table"
               end
 
+      # Evict least recently used entry if cache is full
+      evict_lru_glyph if @glyph_cache.size >= MAX_GLYPH_CACHE_SIZE
+
       @glyph_cache[glyph_id] = glyph
+      @glyph_access_times[glyph_id] = Time.now.to_f
+      glyph
     end
 
     # Get glyph object for a Unicode character code
@@ -367,6 +380,7 @@ module Fontisan
     def clear_cache
       @glyph_cache.clear
       @closure_cache.clear
+      @glyph_access_times.clear
 
       # Also clear glyf table cache if present
       glyf = font.table("glyf")
@@ -375,6 +389,20 @@ module Fontisan
 
     private
 
+    # Evict least recently used glyph from cache
+    #
+    # @return [void]
+    def evict_lru_glyph
+      return if @glyph_access_times.empty?
+
+      # Find least recently used entry
+      lru_id = @glyph_access_times.min_by { |_id, time| time }&.first
+      return unless lru_id
+
+      @glyph_cache.delete(lru_id)
+      @glyph_access_times.delete(lru_id)
+    end
+
     # Validate a glyph ID
     #
     # @param glyph_id [Integer] Glyph ID to validate

data/lib/fontisan/variation/cache.rb

@@ -229,6 +229,7 @@ module Fontisan
         return unless full?
 
         # Remove least recently used entry
+        # O(n) operation but acceptable for typical cache sizes (< 10,000)
         lru_key = @access_times.min_by { |_k, v| v }&.first
         return unless lru_key
 

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.10"
+  VERSION = "0.2.11"
 end

data/lib/fontisan/woff2_font.rb

@@ -168,7 +168,7 @@ module Fontisan
         end
 
         # Fallback to decompressed_tables
-        return @decompressed_tables.dup
+        return @decompressed_tables
       end
 
       # Tag provided - return specific table
@@ -189,8 +189,8 @@ module Fontisan
 
       # Fallback to parsed_tables hash
       # Normalize tag to UTF-8 string for hash lookup
-      # Use dup to create mutable copy since force_encoding modifies in place
-      tag_key = tag.to_s.dup.force_encoding("UTF-8")
+      tag_key = tag.to_s
+      tag_key.force_encoding("UTF-8") unless tag_key.encoding == Encoding::UTF_8
       @parsed_tables[tag_key]
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - Ribose Inc.
@@ -168,10 +168,14 @@ files:
 - lib/fontisan/config/variable_settings.yml
 - lib/fontisan/config/woff2_settings.yml
 - lib/fontisan/constants.rb
+- lib/fontisan/converters/cff_table_builder.rb
 - lib/fontisan/converters/collection_converter.rb
 - lib/fontisan/converters/conversion_strategy.rb
 - lib/fontisan/converters/format_converter.rb
+- lib/fontisan/converters/glyf_table_builder.rb
 - lib/fontisan/converters/outline_converter.rb
+- lib/fontisan/converters/outline_extraction.rb
+- lib/fontisan/converters/outline_optimizer.rb
 - lib/fontisan/converters/svg_generator.rb
 - lib/fontisan/converters/table_copier.rb
 - lib/fontisan/converters/woff2_encoder.rb