fontisan 0.2.1 → 0.2.3

data/lib/fontisan/tables/cff2/table_reader.rb

@@ -61,7 +61,7 @@ module Fontisan
             major_version: read_uint8,
             minor_version: read_uint8,
             header_size: read_uint8,
-            top_dict_length: read_uint16
+            top_dict_length: read_uint16,
           }
 
           # Validate CFF2 version
@@ -105,7 +105,7 @@ module Fontisan
           # Parse Variable Store structure
           @variable_store = {
             regions: read_region_list,
-            item_variation_data: read_item_variation_data
+            item_variation_data: read_item_variation_data,
           }
 
           @variable_store
@@ -140,7 +140,7 @@ module Fontisan
             axes << {
               start_coord: read_f2dot14,
               peak_coord: read_f2dot14,
-              end_coord: read_f2dot14
+              end_coord: read_f2dot14,
             }
           end
 
@@ -158,13 +158,11 @@ module Fontisan
 
           item_variation_data = []
 
-          data_count.times do |idx|
-            begin
-              item_data = read_single_item_variation_data
-              item_variation_data << item_data
-            rescue EOFError => e
-              # break
-            end
+          data_count.times do |_idx|
+            item_data = read_single_item_variation_data
+            item_variation_data << item_data
+          rescue EOFError
+            # break
           end
 
           item_variation_data
@@ -186,32 +184,32 @@ module Fontisan
 
           # Read delta sets
           delta_sets = []
-          item_count.times do |item_idx|
-            begin
-              deltas = []
-
-              # Short deltas (16-bit)
-              short_delta_count.times do
-                break if @io.eof?
-                deltas << read_int16
-              end
-
-              # Long deltas (8-bit) for remaining regions
-              (region_index_count - short_delta_count).times do
-                break if @io.eof?
-                deltas << read_int8
-              end
-
-              delta_sets << deltas
-            rescue EOFError => e
-              # break
+          item_count.times do |_item_idx|
+            deltas = []
+
+            # Short deltas (16-bit)
+            short_delta_count.times do
+              break if @io.eof?
+
+              deltas << read_int16
+            end
+
+            # Long deltas (8-bit) for remaining regions
+            (region_index_count - short_delta_count).times do
+              break if @io.eof?
+
+              deltas << read_int8
             end
+
+            delta_sets << deltas
+          rescue EOFError
+            # break
           end
 
           {
             item_count: item_count,
             region_indices: region_indices,
-            delta_sets: delta_sets
+            delta_sets: delta_sets,
           }
         end
 
@@ -249,7 +247,10 @@ module Fontisan
         # @raise [EOFError] If not enough bytes available
         def read_safely(bytes, description)
           data = @io.read(bytes)
-          raise EOFError, "Unexpected EOF while reading #{description}" if data.nil? || data.bytesize < bytes
+          if data.nil? || data.bytesize < bytes
+            raise EOFError,
+                  "Unexpected EOF while reading #{description}"
+          end
 
           data
         end
@@ -269,7 +270,8 @@ module Fontisan
 
             if operator_byte?(byte)
               operator = read_dict_operator(io, byte)
-              dict[operator] = operands.size == 1 ? operands.first : operands.dup
+              dict[operator] =
+                operands.size == 1 ? operands.first : operands.dup
               operands.clear
             else
               # Operand (number)
@@ -416,4 +418,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2/variation_data_extractor.rb

@@ -148,7 +148,7 @@ module Fontisan
               {
                 start: axis[:start_coord],
                 peak: axis[:peak_coord],
-                end: axis[:end_coord]
+                end: axis[:end_coord],
               }
             end
           end
@@ -209,4 +209,4 @@ module Fontisan
       end
     end
   end
-end
+end

data/lib/fontisan/tables/cff2.rb

@@ -111,7 +111,7 @@ module Fontisan
           @num_axes,
           @global_subr_index,
           nil, # local subrs (CFF2 may not have them)
-          0    # vsindex
+          0, # vsindex
         ).parse
       end
 

data/lib/fontisan/tables/glyf/compound_glyph_resolver.rb

@@ -118,7 +118,8 @@ module Fontisan
                                 resolve(component_glyph, visited, depth + 1)
                               else
                                 # Convert simple glyph to outline
-                                Models::Outline.from_truetype(component_glyph, component.glyph_index)
+                                Models::Outline.from_truetype(component_glyph,
+                                                              component.glyph_index)
                               end
 
           # Apply transformation matrix

data/lib/fontisan/tables/glyf/curve_converter.rb

@@ -119,7 +119,10 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.calculate_error(cubic, quadratics)
         validate_cubic_curve!(cubic)
-        raise ArgumentError, "quadratics must be Array" unless quadratics.is_a?(Array)
+        unless quadratics.is_a?(Array)
+          raise ArgumentError,
+                "quadratics must be Array"
+        end
         raise ArgumentError, "quadratics cannot be empty" if quadratics.empty?
 
         max_error = 0.0
@@ -305,7 +308,8 @@ module Fontisan
         required.each do |key|
           value = quad[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "quad[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "quad[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
@@ -324,14 +328,16 @@ module Fontisan
         required.each do |key|
           value = cubic[key]
           unless value.is_a?(Numeric)
-            raise ArgumentError, "cubic[:#{key}] must be Numeric, got: #{value.class}"
+            raise ArgumentError,
+                  "cubic[:#{key}] must be Numeric, got: #{value.class}"
           end
         end
       end
 
       private_class_method def self.validate_max_error!(max_error)
         unless max_error.is_a?(Numeric)
-          raise ArgumentError, "max_error must be Numeric, got: #{max_error.class}"
+          raise ArgumentError,
+                "max_error must be Numeric, got: #{max_error.class}"
         end
 
         if max_error <= 0

data/lib/fontisan/tables/glyf/glyph_builder.rb

@@ -106,7 +106,11 @@ module Fontisan
       # @raise [ArgumentError] If parameters are invalid
       def self.build_compound_glyph(components, bbox, instructions: "".b)
         raise ArgumentError, "components cannot be nil" if components.nil?
-        raise ArgumentError, "components must be Array" unless components.is_a?(Array)
+
+        unless components.is_a?(Array)
+          raise ArgumentError,
+                "components must be Array"
+        end
         raise ArgumentError, "components cannot be empty" if components.empty?
 
         validate_bbox!(bbox)
@@ -114,7 +118,8 @@ module Fontisan
         build_compound_glyph_data(components, bbox, instructions)
       end
 
-      private_class_method def self.build_simple_glyph_data(contours, bbox, instructions)
+      private_class_method def self.build_simple_glyph_data(contours, bbox,
+instructions)
         num_contours = contours.length
 
         # Build endPtsOfContours array
@@ -136,7 +141,8 @@ module Fontisan
 
         # Header (10 bytes)
         data << [num_contours].pack("n") # numberOfContours
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # endPtsOfContours
         data << end_pts_of_contours.pack("n*")
@@ -155,18 +161,21 @@ module Fontisan
         data
       end
 
-      private_class_method def self.build_compound_glyph_data(components, bbox, instructions)
+      private_class_method def self.build_compound_glyph_data(components, bbox,
+instructions)
         data = (+"").force_encoding(Encoding::BINARY)
 
         # Header (10 bytes) - numberOfContours = -1 for compound
         data << [-1].pack("n") # Use signed pack, will convert to 0xFFFF
-        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max], bbox[:y_max]].pack("n4")
+        data << [bbox[:x_min], bbox[:y_min], bbox[:x_max],
+                 bbox[:y_max]].pack("n4")
 
         # Encode components
         has_instructions = instructions.bytesize.positive?
         components.each_with_index do |component, index|
           is_last = (index == components.length - 1)
-          component_data = encode_component(component, is_last, has_instructions)
+          component_data = encode_component(component, is_last,
+                                            has_instructions)
           data << component_data
         end
 
@@ -179,7 +188,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_component(component, is_last, has_instructions)
+      private_class_method def self.encode_component(component, is_last,
+has_instructions)
         validate_component!(component)
 
         glyph_index = component[:glyph_index]
@@ -344,7 +354,8 @@ module Fontisan
         data
       end
 
-      private_class_method def self.encode_coordinate_values(flags, deltas, axis)
+      private_class_method def self.encode_coordinate_values(flags, deltas,
+axis)
         data = (+"").force_encoding(Encoding::BINARY)
         short_flag = axis == :x ? X_SHORT_VECTOR : Y_SHORT_VECTOR
         same_flag = axis == :x ? X_IS_SAME_OR_POSITIVE_X_SHORT : Y_IS_SAME_OR_POSITIVE_Y_SHORT
@@ -400,7 +411,10 @@ module Fontisan
         # Convert float to F2DOT14 fixed-point format
         # F2DOT14: 2 bits integer, 14 bits fractional
         # Range: -2.0 to ~1.99993896484375
-        raise ArgumentError, "value out of F2DOT14 range" if value < -2.0 || value > 2.0
+        if value < -2.0 || value > 2.0
+          raise ArgumentError,
+                "value out of F2DOT14 range"
+        end
 
         fixed = (value * 16_384.0).round
         # Convert to unsigned 16-bit
@@ -434,7 +448,10 @@ module Fontisan
       end
 
       private_class_method def self.validate_component!(component)
-        raise ArgumentError, "component must be Hash" unless component.is_a?(Hash)
+        unless component.is_a?(Hash)
+          raise ArgumentError,
+                "component must be Hash"
+        end
         unless component[:glyph_index]
           raise ArgumentError, "component must have :glyph_index"
         end

data/lib/fontisan/tables/name.rb

@@ -173,13 +173,13 @@ module Fontisan
         record = find_name_record(
           name_id,
           platform: PLATFORM_WINDOWS,
-          language: WINDOWS_LANGUAGE_EN_US
+          language: WINDOWS_LANGUAGE_EN_US,
         )
 
         record ||= find_name_record(
           name_id,
           platform: PLATFORM_MACINTOSH,
-          language: MAC_LANGUAGE_ENGLISH
+          language: MAC_LANGUAGE_ENGLISH,
         )
 
         return nil unless record
@@ -236,10 +236,10 @@ module Fontisan
         decoded = case record.platform_id
                   when PLATFORM_WINDOWS, PLATFORM_UNICODE
                     string_data.dup.force_encoding("UTF-16BE")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   when PLATFORM_MACINTOSH
                     string_data.dup.force_encoding("ASCII-8BIT")
-                               .encode("UTF-8", invalid: :replace, undef: :replace)
+                      .encode("UTF-8", invalid: :replace, undef: :replace)
                   else
                     string_data.dup.force_encoding("UTF-8")
                   end

data/lib/fontisan/true_type_collection.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require "bindata"
-require_relative "constants"
+require_relative "base_collection"
 
 module Fontisan
-  # TrueType Collection domain object using BinData
+  # TrueType Collection domain object
   #
-  # Represents a complete TrueType Collection file using BinData's declarative
-  # DSL for binary structure definition. The structure definition IS the
-  # documentation, and BinData handles all low-level reading/writing.
+  # Represents a complete TrueType Collection file. Inherits all shared
+  # functionality from BaseCollection and implements TTC-specific behavior.
   #
   # @example Reading and extracting fonts
   #   File.open("Helvetica.ttc", "rb") do |io|
@@ -16,51 +14,25 @@ module Fontisan
   #     puts ttc.num_fonts  # => 6
   #     fonts = ttc.extract_fonts(io)  # => [TrueTypeFont, TrueTypeFont, ...]
   #   end
-  class TrueTypeCollection < 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 TrueType Collection from a file
+  class TrueTypeCollection < BaseCollection
+    # Get the font class for TrueType collections
     #
-    # @param path [String] Path to the TTC file
-    # @return [TrueTypeCollection] A new instance
-    # @raise [ArgumentError] if path is nil or empty
-    # @raise [Errno::ENOENT] if file does not exist
-    # @raise [RuntimeError] if file format is invalid
-    def self.from_file(path)
-      if path.nil? || path.to_s.empty?
-        raise ArgumentError,
-              "path cannot be nil or empty"
-      end
-      raise Errno::ENOENT, "File not found: #{path}" unless File.exist?(path)
-
-      File.open(path, "rb") { |io| read(io) }
-    rescue BinData::ValidityError => e
-      raise "Invalid TTC file: #{e.message}"
-    rescue EOFError => e
-      raise "Invalid TTC file: unexpected end of file - #{e.message}"
+    # @return [Class] TrueTypeFont class
+    def self.font_class
+      require_relative "true_type_font"
+      TrueTypeFont
     end
 
-    # Extract fonts as TrueTypeFont objects
+    # Get the collection format identifier
     #
-    # Reads each font from the TTC file and returns them as TrueTypeFont objects.
-    #
-    # @param io [IO] Open file handle to read fonts from
-    # @return [Array<TrueTypeFont>] Array of font objects
-    def extract_fonts(io)
-      require_relative "true_type_font"
-
-      font_offsets.map do |offset|
-        TrueTypeFont.from_ttc(io, offset)
-      end
+    # @return [String] "TTC" for TrueType Collection
+    def self.collection_format
+      "TTC"
     end
 
-    # Get a single font from the collection (Fontisan extension)
+    # Get a single font from the collection
+    #
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param index [Integer] Index of the font (0-based)
     # @param io [IO] Open file handle
@@ -73,43 +45,27 @@ module Fontisan
       TrueTypeFont.from_ttc(io, font_offsets[index], mode: mode)
     end
 
-    # Get font count (Fontisan extension)
+    # Extract fonts as TrueTypeFont objects
     #
-    # @return [Integer] Number of fonts in collection
-    def font_count
-      num_fonts
-    end
-
-    # Validate format correctness
+    # Reads each font from the TTC file and returns them as TrueTypeFont objects.
+    # This method uses the TTC-specific from_ttc method.
     #
-    # @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
+    # @param io [IO] Open file handle to read fonts from
+    # @return [Array<TrueTypeFont>] Array of font objects
+    def extract_fonts(io)
+      require_relative "true_type_font"
 
-    # Get the TTC version as a single integer
-    #
-    #  @return [Integer] Version number (e.g., 0x00010000 for version 1.0)
-    def version
-      (major_version << 16) | minor_version
+      font_offsets.map do |offset|
+        TrueTypeFont.from_ttc(io, offset)
+      end
     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.
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param io [IO] Open file handle to read fonts from
     # @return [CollectionListInfo] List of fonts with metadata
-    #
-    # @example List fonts in collection
-    #   File.open("fonts.ttc", "rb") do |io|
-    #     ttc = TrueTypeCollection.read(io)
-    #     list = ttc.list_fonts(io)
-    #     list.fonts.each { |f| puts "#{f.index}: #{f.family_name}" }
-    #   end
     def list_fonts(io)
       require_relative "models/collection_list_info"
       require_relative "models/collection_font_summary"
@@ -159,51 +115,11 @@ module Fontisan
       )
     end
 
-    # Get comprehensive collection metadata
-    #
-    # Returns a CollectionInfo model with header information, offsets,
-    # and table sharing statistics.
-    # This is the API method used by the `info` command for collections.
-    #
-    # @param io [IO] Open file handle to read fonts from
-    # @param path [String] Collection file path (for file size)
-    # @return [CollectionInfo] Collection metadata
-    #
-    # @example Get collection info
-    #   File.open("fonts.ttc", "rb") do |io|
-    #     ttc = TrueTypeCollection.read(io)
-    #     info = ttc.collection_info(io, "fonts.ttc")
-    #     puts "Version: #{info.version_string}"
-    #   end
-    def collection_info(io, path)
-      require_relative "models/collection_info"
-      require_relative "models/table_sharing_info"
-
-      # Calculate table sharing statistics
-      table_sharing = calculate_table_sharing(io)
-
-      # Get file size
-      file_size = path ? File.size(path) : 0
-
-      Models::CollectionInfo.new(
-        collection_path: path,
-        collection_format: "TTC",
-        ttc_tag: tag,
-        major_version: major_version,
-        minor_version: minor_version,
-        num_fonts: num_fonts,
-        font_offsets: font_offsets.to_a,
-        file_size_bytes: file_size,
-        table_sharing: table_sharing,
-      )
-    end
-
     private
 
     # Calculate table sharing statistics
     #
-    # Analyzes which tables are shared between fonts and calculates
-    # space savings from deduplication.
+    # Overrides BaseCollection to use TrueType-specific from_ttc method.
     #
     # @param io [IO] Open file handle
     # @return [TableSharingInfo] Sharing statistics

data/lib/fontisan/true_type_font.rb

@@ -233,7 +233,8 @@ module Fontisan
           batch_entries.each do |entry|
             relative_offset = entry.offset - batch_offset
             tag_key = entry.tag.dup.force_encoding("UTF-8")
-            @table_data[tag_key] = batch_data[relative_offset, entry.table_length]
+            @table_data[tag_key] =
+              batch_data[relative_offset, entry.table_length]
           end
         end
 
@@ -307,6 +308,7 @@ module Fontisan
     # @return [Boolean] true if table is available in current mode
     def table_available?(tag)
       return false unless has_table?(tag)
+
       LoadingModes.table_allowed?(@loading_mode, tag)
     end
 

data/lib/fontisan/validation/checksum_validator.rb

@@ -114,7 +114,7 @@ module Fontisan
         skip_tables = @checksum_config["skip_tables"] || []
 
         font.tables.each do |table_entry|
-          tag = table_entry.tag.to_s  # Convert BinData field to string
+          tag = table_entry.tag.to_s # Convert BinData field to string
 
           # Skip tables that are exempt from checksum validation
           next if skip_tables.include?(tag)
@@ -125,7 +125,7 @@ module Fontisan
 
           # Calculate checksum for the table
           calculated_checksum = calculate_table_checksum(table_data)
-          declared_checksum = table_entry.checksum.to_i  # Convert BinData field to integer
+          declared_checksum = table_entry.checksum.to_i # Convert BinData field to integer
 
           # Special handling for head table (checksum adjustment field should be 0)
           if tag == Constants::HEAD_TAG

data/lib/fontisan/variation/cache.rb

@@ -44,6 +44,7 @@ module Fontisan
         @ttl = ttl
         @cache = {}
         @access_times = {}
+        @access_counter = 0
         @stats = {
           hits: 0,
           misses: 0,
@@ -219,7 +220,8 @@ module Fontisan
       #
       # @param key [String] Cache key
       def touch(key)
-        @access_times[key] = Time.now
+        @access_counter += 1
+        @access_times[key] = @access_counter
       end
 
       # Evict entries if cache is full

data/lib/fontisan/variation/converter.rb

@@ -162,7 +162,8 @@ module Fontisan
               # Note: CFF2 blend deltas are per-coordinate, we need to map to x/y
               # This is a simplified mapping - full implementation would track
               # which coordinates are being varied
-              regions_map[region_key][:deltas_per_point][idx / 2] ||= { x: 0, y: 0 }
+              regions_map[region_key][:deltas_per_point][idx / 2] ||= { x: 0,
+                                                                        y: 0 }
               if idx.even?
                 regions_map[region_key][:deltas_per_point][idx / 2][:x] = delta
               else

data/lib/fontisan/variation/delta_applier.rb

@@ -79,7 +79,8 @@ module Fontisan
         # Apply each active tuple's deltas
         adjusted_points = base_points.dup
         matches.each do |match|
-          apply_tuple_deltas(adjusted_points, match, tuple_data, base_points.length)
+          apply_tuple_deltas(adjusted_points, match, tuple_data,
+                             base_points.length)
         end
 
         adjusted_points

data/lib/fontisan/variation/inspector.rb

@@ -107,7 +107,8 @@ module Fontisan
             index: index,
             name: instance_name(instance[:subfamily_name_id]),
             postscript_name: instance_name(instance[:postscript_name_id]),
-            coordinates: instance_coordinates(instance[:coordinates], @context.axes),
+            coordinates: instance_coordinates(instance[:coordinates],
+                                              @context.axes),
           }
         end
       end

data/lib/fontisan/variation/instance_generator.rb

@@ -248,7 +248,8 @@ module Fontisan
       # @param scalars [Array<Float>] Region scalars
       # @return [Hash] Interpolated point
       def interpolate_point(base_point, delta_points, scalars)
-        @context.interpolator.interpolate_point(base_point, delta_points, scalars)
+        @context.interpolator.interpolate_point(base_point, delta_points,
+                                                scalars)
       end
 
       private

data/lib/fontisan/variation/optimizer.rb

@@ -209,9 +209,12 @@ module Fontisan
           coords2 = r2.region_axes[i]
 
           # Compare start, peak, end coordinates
-          return false unless coords_similar?(coords1.start_coord, coords2.start_coord)
-          return false unless coords_similar?(coords1.peak_coord, coords2.peak_coord)
-          return false unless coords_similar?(coords1.end_coord, coords2.end_coord)
+          return false unless coords_similar?(coords1.start_coord,
+                                              coords2.start_coord)
+          return false unless coords_similar?(coords1.peak_coord,
+                                              coords2.peak_coord)
+          return false unless coords_similar?(coords1.end_coord,
+                                              coords2.end_coord)
         end
 
         true