fontisan 0.2.1 → 0.2.2

data/lib/fontisan/commands/info_command.rb

@@ -41,12 +41,70 @@ module Fontisan
 
       # Get collection information
       #
-      # @return [Models::CollectionInfo] Collection metadata
+      # @return [Models::CollectionInfo, Models::CollectionBriefInfo] Collection metadata
       def collection_info
         collection = FontLoader.load_collection(@font_path)
 
         File.open(@font_path, "rb") do |io|
-          collection.collection_info(io, @font_path)
+          if @options[:brief]
+            # Brief mode: load each font and populate brief info
+            brief_info = Models::CollectionBriefInfo.new
+            brief_info.collection_path = @font_path
+            brief_info.num_fonts = collection.num_fonts
+            brief_info.fonts = []
+
+            collection.num_fonts.times do |index|
+              # Load individual font from collection
+              font = FontLoader.load(@font_path, font_index: index, mode: LoadingModes::METADATA)
+
+              # Populate brief info for this font
+              info = Models::FontInfo.new
+
+              # Font format and variable status
+              info.font_format = case font
+                                 when TrueTypeFont
+                                   "truetype"
+                                 when OpenTypeFont
+                                   "cff"
+                                 else
+                                   "unknown"
+                                 end
+              info.is_variable = font.has_table?(Constants::FVAR_TAG)
+
+              # Collection offset (only populated for fonts in collections)
+              info.collection_offset = collection.font_offsets[index]
+
+              # Essential names
+              if font.has_table?(Constants::NAME_TAG)
+                name_table = font.table(Constants::NAME_TAG)
+                info.family_name = name_table.english_name(Tables::Name::FAMILY)
+                info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+                info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+                info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+                info.version = name_table.english_name(Tables::Name::VERSION)
+              end
+
+              # Essential metrics
+              if font.has_table?(Constants::HEAD_TAG)
+                head = font.table(Constants::HEAD_TAG)
+                info.font_revision = head.font_revision
+                info.units_per_em = head.units_per_em
+              end
+
+              # Vendor ID
+              if font.has_table?(Constants::OS2_TAG)
+                os2_table = font.table(Constants::OS2_TAG)
+                info.vendor_id = os2_table.vendor_id
+              end
+
+              brief_info.fonts << info
+            end
+
+            brief_info
+          else
+            # Full mode: show detailed sharing statistics
+            collection.collection_info(io, @font_path)
+          end
         end
       end
 
@@ -56,9 +114,14 @@ module Fontisan
       def font_info
         info = Models::FontInfo.new
         populate_font_format(info)
-        populate_from_name_table(info) if font.has_table?(Constants::NAME_TAG)
-        populate_from_os2_table(info) if font.has_table?(Constants::OS2_TAG)
-        populate_from_head_table(info) if font.has_table?(Constants::HEAD_TAG)
+
+        # In brief mode, only populate essential fields for fast identification
+        if @options[:brief]
+          populate_brief_fields(info)
+        else
+          populate_full_fields(info)
+        end
+
         info
       end
 
@@ -80,6 +143,49 @@ module Fontisan
         info.is_variable = font.has_table?(Constants::FVAR_TAG)
       end
 
+      # Populate essential fields for brief mode (metadata tables only).
+      #
+      # Brief mode provides fast font identification by loading only 13 essential
+      # attributes from metadata tables (name, head, OS/2). This is 5x faster than
+      # full mode and optimized for font indexing systems.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_brief_fields(info)
+        # Essential names from name table
+        if font.has_table?(Constants::NAME_TAG)
+          name_table = font.table(Constants::NAME_TAG)
+          info.family_name = name_table.english_name(Tables::Name::FAMILY)
+          info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+          info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+          info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+          info.version = name_table.english_name(Tables::Name::VERSION)
+        end
+
+        # Essential metrics from head table
+        if font.has_table?(Constants::HEAD_TAG)
+          head = font.table(Constants::HEAD_TAG)
+          info.font_revision = head.font_revision
+          info.units_per_em = head.units_per_em
+        end
+
+        # Vendor ID from OS/2 table
+        if font.has_table?(Constants::OS2_TAG)
+          os2_table = font.table(Constants::OS2_TAG)
+          info.vendor_id = os2_table.vendor_id
+        end
+      end
+
+      # Populate all fields for full mode.
+      #
+      # Full mode extracts comprehensive metadata from all available tables.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_full_fields(info)
+        populate_from_name_table(info) if font.has_table?(Constants::NAME_TAG)
+        populate_from_os2_table(info) if font.has_table?(Constants::OS2_TAG)
+        populate_from_head_table(info) if font.has_table?(Constants::HEAD_TAG)
+      end
+
       # Populate FontInfo from the name table.
       #
       # @param info [Models::FontInfo] FontInfo instance to populate

data/lib/fontisan/commands/instance_command.rb

@@ -67,11 +67,11 @@ module Fontisan
 
         puts "Static font instance written to: #{output_path}"
       rescue VariationError => e
-        $stderr.puts "Variation Error: #{e.detailed_message}"
+        warn "Variation Error: #{e.detailed_message}"
         exit 1
       rescue StandardError => e
-        $stderr.puts "Error: #{e.message}"
-        $stderr.puts e.backtrace.first(5).join("\n") if options[:verbose]
+        warn "Error: #{e.message}"
+        warn e.backtrace.first(5).join("\n") if options[:verbose]
         exit 1
       end
 
@@ -87,9 +87,9 @@ module Fontisan
         errors = validator.validate
 
         if errors.any?
-          $stderr.puts "Validation errors found:"
+          warn "Validation errors found:"
           errors.each do |error|
-            $stderr.puts "  - #{error}"
+            warn "  - #{error}"
           end
           exit 1
         end
@@ -102,7 +102,7 @@ module Fontisan
       # @param font [Object] Font object
       # @param input_path [String] Input file path
       # @param options [Hash] Command options
-      def preview_instance(font, input_path, options)
+      def preview_instance(_font, input_path, options)
         coords = extract_coordinates(options)
 
         if coords.empty?
@@ -117,7 +117,8 @@ module Fontisan
           puts "  #{axis}: #{value}"
         end
         puts
-        puts "Output would be written to: #{determine_output_path(input_path, options)}"
+        puts "Output would be written to: #{determine_output_path(input_path,
+                                                                  options)}"
         puts "Output format: #{options[:to] || 'same as input'}"
         puts
         puts "Use without --dry-run to actually generate the instance."

data/lib/fontisan/commands/validate_command.rb

@@ -84,7 +84,10 @@ quiet: false)
           errors.each do |error|
             puts "  ERROR: #{error}" if @verbose && !@quiet
             # Add to report if report supports adding errors
-            report.errors << { message: error, category: "variable_font" } if report.respond_to?(:errors)
+            if report.respond_to?(:errors)
+              report.errors << { message: error,
+                                 category: "variable_font" }
+            end
           end
         elsif @verbose && !@quiet
           puts "\n✓ Variable font structure valid"

data/lib/fontisan/constants.rb

@@ -117,30 +117,30 @@ module Fontisan
     # These strings are frozen and reused to reduce memory allocations
     # when parsing fonts with common subfamily names.
     STRING_POOL = {
-      "Regular" => "Regular".freeze,
-      "Bold" => "Bold".freeze,
-      "Italic" => "Italic".freeze,
-      "Bold Italic" => "Bold Italic".freeze,
-      "BoldItalic" => "BoldItalic".freeze,
-      "Light" => "Light".freeze,
-      "Medium" => "Medium".freeze,
-      "Semibold" => "Semibold".freeze,
-      "SemiBold" => "SemiBold".freeze,
-      "Black" => "Black".freeze,
-      "Thin" => "Thin".freeze,
-      "ExtraLight" => "ExtraLight".freeze,
-      "Extra Light" => "Extra Light".freeze,
-      "ExtraBold" => "ExtraBold".freeze,
-      "Extra Bold" => "Extra Bold".freeze,
-      "Heavy" => "Heavy".freeze,
-      "Book" => "Book".freeze,
-      "Roman" => "Roman".freeze,
-      "Normal" => "Normal".freeze,
-      "Oblique" => "Oblique".freeze,
-      "Light Italic" => "Light Italic".freeze,
-      "Medium Italic" => "Medium Italic".freeze,
-      "Semibold Italic" => "Semibold Italic".freeze,
-      "Bold Oblique" => "Bold Oblique".freeze,
+      "Regular" => "Regular",
+      "Bold" => "Bold",
+      "Italic" => "Italic",
+      "Bold Italic" => "Bold Italic",
+      "BoldItalic" => "BoldItalic",
+      "Light" => "Light",
+      "Medium" => "Medium",
+      "Semibold" => "Semibold",
+      "SemiBold" => "SemiBold",
+      "Black" => "Black",
+      "Thin" => "Thin",
+      "ExtraLight" => "ExtraLight",
+      "Extra Light" => "Extra Light",
+      "ExtraBold" => "ExtraBold",
+      "Extra Bold" => "Extra Bold",
+      "Heavy" => "Heavy",
+      "Book" => "Book",
+      "Roman" => "Roman",
+      "Normal" => "Normal",
+      "Oblique" => "Oblique",
+      "Light Italic" => "Light Italic",
+      "Medium Italic" => "Medium Italic",
+      "Semibold Italic" => "Semibold Italic",
+      "Bold Oblique" => "Bold Oblique",
     }.freeze
 
     # Intern a string using the string pool

data/lib/fontisan/converters/format_converter.rb

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

data/lib/fontisan/converters/outline_converter.rb

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

data/lib/fontisan/converters/woff_writer.rb

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

data/lib/fontisan/font_loader.rb

@@ -46,7 +46,11 @@ module Fontisan
 
       # Resolve mode and lazy parameters with environment variables
       resolved_mode = mode || env_mode || LoadingModes::FULL
-      resolved_lazy = lazy.nil? ? (env_lazy.nil? ? false : env_lazy) : lazy
+      resolved_lazy = if lazy.nil?
+                        env_lazy.nil? ? false : env_lazy
+                      else
+                        lazy
+                      end
 
       # Validate mode
       LoadingModes.validate_mode!(resolved_mode)
@@ -57,7 +61,8 @@ module Fontisan
 
         case signature
         when Constants::TTC_TAG
-          load_from_collection(io, path, font_index, mode: resolved_mode, lazy: resolved_lazy)
+          load_from_collection(io, path, font_index, mode: resolved_mode,
+                                                     lazy: resolved_lazy)
         when pack_uint32(Constants::SFNT_VERSION_TRUETYPE)
           TrueTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "OTTO"
@@ -169,7 +174,8 @@ module Fontisan
     # @param lazy [Boolean] If true, load tables on demand
     # @return [TrueTypeFont, OpenTypeFont] The loaded font object
     # @raise [InvalidFontError] if collection type cannot be determined
-    def self.load_from_collection(io, path, font_index, mode: LoadingModes::FULL, lazy: true)
+    def self.load_from_collection(io, path, font_index,
+mode: LoadingModes::FULL, lazy: true)
       # Read collection header to get font offsets
       io.seek(12) # Skip tag (4) + major_version (2) + minor_version (2) + num_fonts marker (4)
       num_fonts = io.read(4).unpack1("N")
@@ -211,6 +217,7 @@ module Fontisan
       [value].pack("N")
     end
 
-    private_class_method :load_from_collection, :pack_uint32, :env_mode, :env_lazy
+    private_class_method :load_from_collection, :pack_uint32, :env_mode,
+                         :env_lazy
   end
 end

data/lib/fontisan/font_writer.rb

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

data/lib/fontisan/formatters/text_formatter.rb

@@ -42,6 +42,8 @@ module Fontisan
           format_font_summary(model)
         when Models::CollectionInfo
           format_collection_info(model)
+        when Models::CollectionBriefInfo
+          format_collection_brief_info(model)
         else
           model.to_s
         end
@@ -312,7 +314,8 @@ module Fontisan
                  font_format
                end
 
-        type += " (Variable)" if is_variable
+        # Always show variable status explicitly
+        type += is_variable ? " (Variable)" : " (Not Variable)"
         type
       end
 
@@ -396,6 +399,47 @@ module Fontisan
         lines.join("\n")
       end
 
+      # Format CollectionBriefInfo as human-readable text.
+      #
+      # @param info [Models::CollectionBriefInfo] Collection brief information to format
+      # @return [String] Formatted text with collection header and each font's brief info
+      def format_collection_brief_info(info)
+        lines = []
+
+        # Collection header
+        lines << "Collection: #{info.collection_path}"
+        lines << "Fonts: #{info.num_fonts}"
+        lines << ""
+
+        # Each font's brief info
+        info.fonts.each_with_index do |font_info, index|
+          # Show font index with offset
+          if font_info.collection_offset
+            lines << "Font #{index} (offset: #{font_info.collection_offset}):"
+          else
+            lines << "Font #{index}:"
+          end
+          lines << ""
+
+          # Format each font using same structure as individual fonts
+          font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+          add_line(lines, "Font type", font_type_display)
+          add_line(lines, "Family", font_info.family_name)
+          add_line(lines, "Subfamily", font_info.subfamily_name)
+          add_line(lines, "Full name", font_info.full_name)
+          add_line(lines, "PostScript name", font_info.postscript_name)
+          add_line(lines, "Version", font_info.version)
+          add_line(lines, "Vendor ID", font_info.vendor_id)
+          add_line(lines, "Font revision", format_float(font_info.font_revision))
+          add_line(lines, "Units per em", font_info.units_per_em)
+
+          # Blank line between fonts (except after last)
+          lines << "" unless index == info.num_fonts - 1
+        end
+
+        lines.join("\n")
+      end
+
       # Format bytes for human-readable display.
       #
       # @param bytes [Integer] Number of bytes