fontisan 0.2.1 → 0.2.2

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

data/lib/fontisan/variation/subsetter.rb

@@ -112,7 +112,10 @@ module Fontisan
         validate_input if @options[:validate]
 
         fvar = variation_table("fvar")
-        return { tables: @font.table_data.dup, report: { error: "No fvar table" } } unless fvar
+        unless fvar
+          return { tables: @font.table_data.dup,
+                   report: { error: "No fvar table" } }
+        end
 
         # Find axes to keep
         all_axes = fvar.axes
@@ -175,7 +178,8 @@ module Fontisan
           optimizer = Optimizer.new(cff2, region_threshold: threshold)
           optimizer.optimize
 
-          @report[:regions_deduplicated] = optimizer.stats[:regions_deduplicated]
+          @report[:regions_deduplicated] =
+            optimizer.stats[:regions_deduplicated]
           @report[:cff2_optimized] = true
         end
 
@@ -316,8 +320,14 @@ module Fontisan
       # @param tables [Hash] Font tables
       # @param glyph_ids [Array<Integer>] Glyph IDs to keep
       def subset_metrics_variations(tables, glyph_ids)
-        subset_metrics_table(tables, "HVAR", glyph_ids) if has_variation_table?("HVAR")
-        subset_metrics_table(tables, "VVAR", glyph_ids) if has_variation_table?("VVAR")
+        if has_variation_table?("HVAR")
+          subset_metrics_table(tables, "HVAR",
+                               glyph_ids)
+        end
+        if has_variation_table?("VVAR")
+          subset_metrics_table(tables, "VVAR",
+                               glyph_ids)
+        end
         # MVAR is font-wide, no glyph subsetting needed
       end
 
@@ -333,7 +343,8 @@ module Fontisan
         # 3. Remove unused ItemVariationData
         # 4. Rebuild and serialize
 
-        @report[:"#{table_tag.downcase}_note"] = "#{table_tag} subsetting not yet implemented"
+        @report[:"#{table_tag.downcase}_note"] =
+          "#{table_tag} subsetting not yet implemented"
       end
 
       # Update non-variation glyph tables
@@ -396,9 +407,18 @@ module Fontisan
       # @param tables [Hash] Font tables
       # @param keep_indices [Array<Integer>] Axis indices to keep
       def subset_metrics_axes(tables, keep_indices)
-        subset_metrics_table_axes(tables, "HVAR", keep_indices) if has_variation_table?("HVAR")
-        subset_metrics_table_axes(tables, "VVAR", keep_indices) if has_variation_table?("VVAR")
-        subset_metrics_table_axes(tables, "MVAR", keep_indices) if has_variation_table?("MVAR")
+        if has_variation_table?("HVAR")
+          subset_metrics_table_axes(tables, "HVAR",
+                                    keep_indices)
+        end
+        if has_variation_table?("VVAR")
+          subset_metrics_table_axes(tables, "VVAR",
+                                    keep_indices)
+        end
+        if has_variation_table?("MVAR")
+          subset_metrics_table_axes(tables, "MVAR",
+                                    keep_indices)
+        end
       end
 
       # Subset a single metrics table's axes
@@ -412,7 +432,8 @@ module Fontisan
         # 2. Filter ItemVariationStore regions to keep axis indices
         # 3. Rebuild and serialize
 
-        @report[:"#{table_tag.downcase}_axes_note"] = "#{table_tag} axis subsetting not yet implemented"
+        @report[:"#{table_tag.downcase}_axes_note"] =
+          "#{table_tag} axis subsetting not yet implemented"
       end
 
       # Simplify metrics table regions
@@ -426,7 +447,8 @@ module Fontisan
         # 3. Update delta set indices
         # 4. Serialize back to binary
 
-        @report[:metrics_simplify_note] = "Metrics region simplification not yet implemented"
+        @report[:metrics_simplify_note] =
+          "Metrics region simplification not yet implemented"
       end
 
       # Create temporary font wrapper for validation

data/lib/fontisan/variation/variation_preserver.rb

@@ -157,7 +157,10 @@ module Fontisan
                 "Source font must respond to :has_table? and :table_data"
         end
 
-        raise ArgumentError, "Target tables cannot be nil" if @target_tables.nil?
+        if @target_tables.nil?
+          raise ArgumentError,
+                "Target tables cannot be nil"
+        end
 
         unless @target_tables.is_a?(Hash)
           raise ArgumentError,

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/glyf_transformer.rb

@@ -41,7 +41,7 @@ module Fontisan
       WE_HAVE_INSTRUCTIONS = 0x0100
       USE_MY_METRICS = 0x0200
       OVERLAP_COMPOUND = 0x0400
-      HAVE_VARIATIONS = 0x1000  # Variable font variation data follows
+      HAVE_VARIATIONS = 0x1000 # Variable font variation data follows
 
       # Reconstruct glyf and loca tables from transformed data
       #
@@ -55,7 +55,8 @@ module Fontisan
 
         # Check minimum size for header
         if io.size < 8
-          raise InvalidFontError, "Transformed glyf data too small: #{io.size} bytes"
+          raise InvalidFontError,
+                "Transformed glyf data too small: #{io.size} bytes"
         end
 
         # Read header
@@ -69,28 +70,34 @@ module Fontisan
         end
 
         # Read nContour stream
-        n_contour_data = read_stream_safely(io, "nContour", variable_font: variable_font)
+        n_contour_data = read_stream_safely(io, "nContour",
+                                            variable_font: variable_font)
 
         # Read nPoints stream
-        n_points_data = read_stream_safely(io, "nPoints", variable_font: variable_font)
+        n_points_data = read_stream_safely(io, "nPoints",
+                                           variable_font: variable_font)
 
         # Read flag stream
         flag_data = read_stream_safely(io, "flag", variable_font: variable_font)
 
         # Read glyph stream (coordinates, instructions, composite data)
-        glyph_data = read_stream_safely(io, "glyph", variable_font: variable_font)
+        glyph_data = read_stream_safely(io, "glyph",
+                                        variable_font: variable_font)
 
         # Read composite stream
-        composite_data = read_stream_safely(io, "composite", variable_font: variable_font)
+        composite_data = read_stream_safely(io, "composite",
+                                            variable_font: variable_font)
 
         # Read bbox stream
         bbox_data = read_stream_safely(io, "bbox", variable_font: variable_font)
 
         # Read instruction stream
-        instruction_data = read_stream_safely(io, "instruction", variable_font: variable_font)
+        instruction_data = read_stream_safely(io, "instruction",
+                                              variable_font: variable_font)
 
         # Parse streams
-        n_contours = parse_n_contour_stream(StringIO.new(n_contour_data), num_glyphs)
+        n_contours = parse_n_contour_stream(StringIO.new(n_contour_data),
+                                            num_glyphs)
 
         # Reconstruct glyphs
         glyphs = reconstruct_glyphs(
@@ -101,7 +108,7 @@ module Fontisan
           StringIO.new(composite_data),
           StringIO.new(bbox_data),
           StringIO.new(instruction_data),
-          variable_font: variable_font
+          variable_font: variable_font,
         )
 
         # Build glyf and loca tables
@@ -114,7 +121,7 @@ module Fontisan
       # @param stream_name [String] Name of stream for error messages
       # @param variable_font [Boolean] Whether this is a variable font (allows incomplete streams)
       # @return [String] Stream data (empty if not available)
-      def self.read_stream_safely(io, stream_name, variable_font: false)
+      def self.read_stream_safely(io, _stream_name, variable_font: false)
         remaining = io.size - io.pos
         if remaining < 4
           # Not enough data for stream size - return empty stream
@@ -131,9 +138,9 @@ module Fontisan
         if remaining < stream_size
           # Stream size extends beyond available data
           # Read what we can
-          available = io.read(remaining) || ""
+          io.read(remaining) || ""
           # For variable fonts, we may have incomplete streams - just return what we have
-          available
+
         else
           io.read(stream_size) || ""
         end
@@ -160,18 +167,24 @@ module Fontisan
         case code
         when 255
           return 0 if io.eof? || (io.size - io.pos) < 2
+
           value_bytes = io.read(2)
           return 0 unless value_bytes && value_bytes.bytesize == 2
+
           759 + value_bytes.unpack1("n")  # 253 * 3 + value
         when 254
           return 0 if io.eof? || (io.size - io.pos) < 2
+
           value_bytes = io.read(2)
           return 0 unless value_bytes && value_bytes.bytesize == 2
+
           506 + value_bytes.unpack1("n")  # 253 * 2 + value
         when 253
           return 0 if io.eof? || (io.size - io.pos) < 2
+
           value_bytes = io.read(2)
           return 0 unless value_bytes && value_bytes.bytesize == 2
+
           253 + value_bytes.unpack1("n")
         else
           code
@@ -279,15 +292,15 @@ module Fontisan
           x_min = y_min = x_max = y_max = 0
         else
           bbox_bytes = bbox_io.read(8)
-          unless bbox_bytes && bbox_bytes.bytesize == 8
-            x_min = y_min = x_max = y_max = 0
-          else
+          if bbox_bytes && bbox_bytes.bytesize == 8
             x_min, y_min, x_max, y_max = bbox_bytes.unpack("n4")
             # Convert to signed
             x_min = x_min > 0x7FFF ? x_min - 0x10000 : x_min
             y_min = y_min > 0x7FFF ? y_min - 0x10000 : y_min
             x_max = x_max > 0x7FFF ? x_max - 0x10000 : x_max
             y_max = y_max > 0x7FFF ? y_max - 0x10000 : y_max
+          else
+            x_min = y_min = x_max = y_max = 0
           end
         end
 
@@ -302,12 +315,12 @@ module Fontisan
             instruction_length = inst_length_data
             if instruction_length.positive?
               inst_remaining = instruction_io.size - instruction_io.pos
-              if inst_remaining >= instruction_length
-                instructions = instruction_io.read(instruction_length) || ""
-              else
-                # Read what we can
-                instructions = instruction_io.read(inst_remaining) || ""
-              end
+              instructions = if inst_remaining >= instruction_length
+                               instruction_io.read(instruction_length) || ""
+                             else
+                               # Read what we can
+                               instruction_io.read(inst_remaining) || ""
+                             end
             end
           end
         end
@@ -325,7 +338,8 @@ module Fontisan
       # @param instruction_io [StringIO] Instruction stream
       # @param variable_font [Boolean] Whether this is a variable font
       # @return [String] Glyph data in standard format
-      def self.reconstruct_composite_glyph(composite_io, bbox_io, instruction_io, variable_font: false)
+      def self.reconstruct_composite_glyph(composite_io, bbox_io,
+instruction_io, variable_font: false)
         # Track available bytes to prevent EOF errors
         composite_size = composite_io.size - composite_io.pos
 
@@ -364,6 +378,7 @@ module Fontisan
           # Read flags and glyph_index safely
           component_header = composite_io.read(4)
           break unless component_header && component_header.bytesize == 4
+
           flags, glyph_index = component_header.unpack("n2")
 
           # Write flags and index
@@ -371,18 +386,21 @@ module Fontisan
           composite_data << [glyph_index].pack("n")
 
           # Read arguments (depend on flags)
+          remaining = composite_io.size - composite_io.pos
           if (flags & ARG_1_AND_2_ARE_WORDS).zero?
-            remaining = composite_io.size - composite_io.pos
             break if composite_io.eof? || remaining < 2
+
             arg_bytes = composite_io.read(2)
             break unless arg_bytes && arg_bytes.bytesize == 2
+
             arg1, arg2 = arg_bytes.unpack("c2")
             composite_data << [arg1, arg2].pack("c2")
           else
-            remaining = composite_io.size - composite_io.pos
             break if composite_io.eof? || remaining < 4
+
             arg_bytes = composite_io.read(4)
             break unless arg_bytes && arg_bytes.bytesize == 4
+
             arg1, arg2 = arg_bytes.unpack("n2")
             # Convert to signed
             arg1 = arg1 > 0x7FFF ? arg1 - 0x10000 : arg1
@@ -394,22 +412,28 @@ module Fontisan
           if (flags & WE_HAVE_A_SCALE) != 0
             remaining = composite_io.size - composite_io.pos
             break if composite_io.eof? || remaining < 2
+
             scale_bytes = composite_io.read(2)
             break unless scale_bytes && scale_bytes.bytesize == 2
+
             scale = scale_bytes.unpack1("n")
             composite_data << [scale].pack("n")
           elsif (flags & WE_HAVE_AN_X_AND_Y_SCALE) != 0
             remaining = composite_io.size - composite_io.pos
             break if composite_io.eof? || remaining < 4
+
             scale_bytes = composite_io.read(4)
             break unless scale_bytes && scale_bytes.bytesize == 4
+
             x_scale, y_scale = scale_bytes.unpack("n2")
             composite_data << [x_scale, y_scale].pack("n2")
           elsif (flags & WE_HAVE_A_TWO_BY_TWO) != 0
             remaining = composite_io.size - composite_io.pos
             break if composite_io.eof? || remaining < 8
+
             matrix_bytes = composite_io.read(8)
             break unless matrix_bytes && matrix_bytes.bytesize == 8
+
             x_scale, scale01, scale10, y_scale = matrix_bytes.unpack("n4")
             composite_data << [x_scale, scale01, scale10, y_scale].pack("n4")
           end
@@ -462,12 +486,12 @@ module Fontisan
               instruction_length = length_bytes.unpack1("n")
               if instruction_length.positive?
                 remaining = instruction_io.size - instruction_io.pos
-                if remaining >= instruction_length
-                  instructions = instruction_io.read(instruction_length) || ""
-                else
-                  # Read what we can
-                  instructions = instruction_io.read(remaining) || ""
-                end
+                instructions = if remaining >= instruction_length
+                                 instruction_io.read(instruction_length) || ""
+                               else
+                                 # Read what we can
+                                 instruction_io.read(remaining) || ""
+                               end
               end
             end
           end
@@ -501,6 +525,7 @@ module Fontisan
 
           if (flag & REPEAT_FLAG) != 0
             break if io.eof? || (io.size - io.pos) < 1
+
             repeat_count = read_uint8(io)
             repeat_count.times { flags << flag }
           end
@@ -529,6 +554,7 @@ module Fontisan
           # EOF protection
           if (flag & short_flag) != 0
             break if io.eof? || (io.size - io.pos) < 1
+
             # Short vector (one byte)
             delta = read_uint8(io)
             delta = -delta if (flag & same_or_positive_flag).zero?
@@ -537,6 +563,7 @@ module Fontisan
             delta = 0
           else
             break if io.eof? || (io.size - io.pos) < 2
+
             # Long vector (two bytes, signed)
             delta = read_int16(io)
           end

data/lib/fontisan/woff2_font.rb

@@ -85,8 +85,7 @@ module Fontisan
     # Simple struct for storing file path
     IOSource = Struct.new(:path)
 
-    attr_accessor :header, :table_entries, :decompressed_tables, :parsed_tables, :io_source
-    attr_accessor :underlying_font  # Allow both reading and setting for table delegation
+    attr_accessor :header, :table_entries, :decompressed_tables, :parsed_tables, :io_source, :underlying_font # Allow both reading and setting for table delegation
 
     def initialize
       @header = nil
@@ -94,7 +93,7 @@ module Fontisan
       @decompressed_tables = {}
       @parsed_tables = {}
       @io_source = nil
-      @underlying_font = nil  # Store the actual TrueTypeFont/OpenTypeFont
+      @underlying_font = nil # Store the actual TrueTypeFont/OpenTypeFont
     end
 
     # Initialize storage hashes
@@ -159,7 +158,7 @@ module Fontisan
     # Get decompressed table data
     def table_data(tag)
       # First try underlying font's table data if available
-      if @underlying_font && @underlying_font.respond_to?(:table_data)
+      if @underlying_font.respond_to?(:table_data)
         underlying_data = @underlying_font.table_data[tag]
         return underlying_data if underlying_data
       end
@@ -183,11 +182,13 @@ module Fontisan
     # Convert to TTF
     def to_ttf(output_path)
       unless truetype?
-        raise InvalidFontError, "Cannot convert to TTF: font is not TrueType flavored"
+        raise InvalidFontError,
+              "Cannot convert to TTF: font is not TrueType flavored"
       end
 
       # Build SFNT and create TrueTypeFont
-      sfnt_data = self.class.build_sfnt_in_memory(@header, @table_entries, @decompressed_tables)
+      sfnt_data = self.class.build_sfnt_in_memory(@header, @table_entries,
+                                                  @decompressed_tables)
       sfnt_io = StringIO.new(sfnt_data)
 
       # Create actual TrueTypeFont and save for table delegation
@@ -201,11 +202,13 @@ module Fontisan
     # Convert to OTF
     def to_otf(output_path)
       unless cff?
-        raise InvalidFontError, "Cannot convert to OTF: font is not CFF flavored"
+        raise InvalidFontError,
+              "Cannot convert to OTF: font is not CFF flavored"
       end
 
       # Build SFNT and create OpenTypeFont
-      sfnt_data = self.class.build_sfnt_in_memory(@header, @table_entries, @decompressed_tables)
+      sfnt_data = self.class.build_sfnt_in_memory(@header, @table_entries,
+                                                  @decompressed_tables)
       sfnt_io = StringIO.new(sfnt_data)
 
       # Create actual OpenTypeFont and save for table delegation
@@ -310,13 +313,15 @@ module Fontisan
         woff2.table_entries = read_table_directory_from_io(io, woff2.header)
 
         # Decompress table data
-        woff2.decompressed_tables = decompress_tables(io, woff2.header, woff2.table_entries)
+        woff2.decompressed_tables = decompress_tables(io, woff2.header,
+                                                      woff2.table_entries)
 
         # Apply table transformations if present
         apply_transformations!(woff2.table_entries, woff2.decompressed_tables)
 
         # Build SFNT structure in memory
-        sfnt_data = build_sfnt_in_memory(woff2.header, woff2.table_entries, woff2.decompressed_tables)
+        sfnt_data = build_sfnt_in_memory(woff2.header, woff2.table_entries,
+                                         woff2.decompressed_tables)
 
         # Create StringIO for reading
         sfnt_io = StringIO.new(sfnt_data)
@@ -373,7 +378,10 @@ module Fontisan
 
         # Read flags byte with nil check
         flags_data = io.read(1)
-        raise EOFError, "Unexpected EOF while reading table directory flags" if flags_data.nil?
+        if flags_data.nil?
+          raise EOFError,
+                "Unexpected EOF while reading table directory flags"
+        end
 
         flags = flags_data.unpack1("C")
         entry.flags = flags
@@ -383,7 +391,11 @@ module Fontisan
         if tag_index == 0x3F
           # Custom tag (4 bytes)
           tag_data = io.read(4)
-          raise EOFError, "Unexpected EOF while reading custom tag" if tag_data.nil? || tag_data.bytesize < 4
+          if tag_data.nil? || tag_data.bytesize < 4
+            raise EOFError,
+                  "Unexpected EOF while reading custom tag"
+          end
+
           entry.tag = tag_data.force_encoding("UTF-8")
         else
           # Known tag from table
@@ -402,7 +414,8 @@ module Fontisan
         # - hmtx with non-zero version: TRANSFORMED (transformLength present)
         # - all other tables: transformation version is 0 (no transformLength)
         transform_version = (flags >> 6) & 0x03
-        has_transform_length = if ["glyf", "loca"].include?(entry.tag) && transform_version.zero?
+        has_transform_length = if ["glyf",
+                                   "loca"].include?(entry.tag) && transform_version.zero?
                                  true
                                elsif entry.tag == "hmtx" && transform_version != 0
                                  true
@@ -429,7 +442,10 @@ module Fontisan
       result = 0
       5.times do
         byte_data = io.read(1)
-        raise EOFError, "Unexpected EOF while reading UIntBase128" if byte_data.nil?
+        if byte_data.nil?
+          raise EOFError,
+                "Unexpected EOF while reading UIntBase128"
+        end
 
         byte = byte_data.unpack1("C")
 
@@ -512,7 +528,7 @@ module Fontisan
           result = Woff2::GlyfTransformer.reconstruct(
             transformed_glyf,
             num_glyphs,
-            variable_font: variable_font
+            variable_font: variable_font,
           )
           decompressed_tables["glyf"] = result[:glyf]
           decompressed_tables["loca"] = result[:loca]

data/lib/fontisan.rb

@@ -107,6 +107,7 @@ require_relative "fontisan/models/validation_report"
 require_relative "fontisan/models/font_export"
 require_relative "fontisan/models/collection_font_summary"
 require_relative "fontisan/models/collection_info"
+require_relative "fontisan/models/collection_brief_info"
 require_relative "fontisan/models/collection_list_info"
 require_relative "fontisan/models/font_summary"
 require_relative "fontisan/models/table_sharing_info"
@@ -149,8 +150,6 @@ require_relative "fontisan/variation/interpolator"
 require_relative "fontisan/variation/region_matcher"
 require_relative "fontisan/variation/data_extractor"
 require_relative "fontisan/variation/instance_generator"
-require_relative "fontisan/variation/interpolator"
-require_relative "fontisan/variation/region_matcher"
 require_relative "fontisan/variation/metrics_adjuster"
 require_relative "fontisan/variation/converter"
 require_relative "fontisan/variation/variation_preserver"
@@ -172,6 +171,17 @@ require_relative "fontisan/optimizers/charstring_rewriter"
 require_relative "fontisan/optimizers/subroutine_optimizer"
 require_relative "fontisan/optimizers/subroutine_generator"
 
+# Hints infrastructure
+require_relative "fontisan/models/hint"
+require_relative "fontisan/hints/truetype_instruction_analyzer"
+require_relative "fontisan/hints/truetype_instruction_generator"
+require_relative "fontisan/hints/truetype_hint_extractor"
+require_relative "fontisan/hints/truetype_hint_applier"
+require_relative "fontisan/hints/postscript_hint_extractor"
+require_relative "fontisan/hints/postscript_hint_applier"
+require_relative "fontisan/hints/hint_converter"
+require_relative "fontisan/hints/hint_validator"
+
 # Commands
 require_relative "fontisan/commands/base_command"
 require_relative "fontisan/commands/info_command"
@@ -209,4 +219,34 @@ module Fontisan
   self.logger = Logger.new($stdout).tap do |log|
     log.level = Logger::WARN
   end
+
+  # Get font information.
+  #
+  # Supports both full and brief modes. Brief mode uses metadata loading for
+  # 5x faster parsing by loading only essential tables (name, head, hhea,
+  # maxp, OS/2, post). Returns FontInfo with 13 essential fields in brief mode
+  # or all 38 fields in full mode.
+  #
+  # @param path [String] Path to font file
+  # @param brief [Boolean] Use brief mode for fast identification (default: false)
+  # @param font_index [Integer] Index for TTC/OTC files (default: 0)
+  # @return [Models::FontInfo, Models::CollectionInfo, Models::CollectionBriefInfo] Font information
+  #
+  # @example Get full info
+  #   info = Fontisan.info("font.ttf")
+  #   puts info.family_name
+  #   puts info.copyright  # populated in full mode
+  #
+  # @example Get brief info (5x faster)
+  #   info = Fontisan.info("font.ttf", brief: true)
+  #   puts info.family_name       # populated
+  #   puts info.postscript_name   # populated
+  #   puts info.copyright         # nil (not populated in brief mode)
+  #
+  # @example Serialize to JSON
+  #   info = Fontisan.info("font.ttf", brief: true)
+  #   puts info.to_json
+  def self.info(path, brief: false, font_index: 0)
+    Commands::InfoCommand.new(path, brief: brief, font_index: font_index).run
+  end
 end