fontisan 0.2.6 → 0.2.8

data/lib/fontisan/commands/validate_command.rb

@@ -3,6 +3,7 @@
 require_relative "base_command"
 require_relative "../validators/profile_loader"
 require_relative "../font_loader"
+require_relative "../tables/name"
 
 module Fontisan
   module Commands
@@ -70,12 +71,40 @@ module Fontisan
         # Load font with appropriate mode
         profile_config = Validators::ProfileLoader.profile_info(@profile)
         unless profile_config
-          puts "Error: Unknown profile '#{@profile}'" unless @suppress_warnings
+          unless @suppress_warnings
+            puts "Error: Unknown profile '#{@profile}'"
+            puts ""
+            puts "Available profiles:"
+            Validators::ProfileLoader.all_profiles.each do |name, config|
+              puts "  #{name.to_s.ljust(20)} - #{config[:description]}"
+            end
+            puts ""
+            puts "Use --list to see all available profiles"
+          end
           return 1
         end
 
         mode = profile_config[:loading_mode].to_sym
 
+        # Check if input is a collection
+        if FontLoader.collection?(@input)
+          validate_collection(mode)
+        else
+          validate_single_font(mode)
+        end
+      rescue StandardError => e
+        puts "Error: #{e.message}" unless @suppress_warnings
+        puts e.backtrace.join("\n") if @verbose && !@suppress_warnings
+        1
+      end
+
+      private
+
+      # Validate a single font file
+      #
+      # @param mode [Symbol] Loading mode
+      # @return [Integer] Exit code
+      def validate_single_font(mode)
         font = FontLoader.load(@input, mode: mode)
 
         # Select validator
@@ -102,13 +131,134 @@ module Fontisan
 
         # Return exit code
         exit_code(report)
-      rescue => e
-        puts "Error: #{e.message}" unless @suppress_warnings
-        puts e.backtrace.join("\n") if @verbose && !@suppress_warnings
-        1
       end
 
-      private
+      # Validate all fonts in a collection
+      #
+      # @param mode [Symbol] Loading mode
+      # @return [Integer] Exit code
+      def validate_collection(mode)
+        require_relative "../models/collection_validation_report"
+        require_relative "../models/font_report"
+
+        # Load collection metadata
+        collection = FontLoader.load_collection(@input)
+
+        # Create collection report
+        collection_report = Models::CollectionValidationReport.new(
+          collection_path: @input,
+          collection_type: collection.class.collection_format,
+          num_fonts: collection.num_fonts,
+        )
+
+        # Get validator
+        validator = Validators::ProfileLoader.load(@profile)
+
+        # Validate each font
+        collection.num_fonts.times do |index|
+          font = FontLoader.load(@input, font_index: index, mode: mode)
+          font_report = validator.validate(font)
+
+          # Set font_path to indicate collection file with index
+          # Fonts in collections don't have individual file paths
+          font_report.font_path = "#{@input}:#{index}"
+
+          # Extract font name
+          font_name = extract_font_name(font, index)
+
+          # Create and add font report
+          collection_report.add_font_report(
+            Models::FontReport.new(
+              font_index: index,
+              font_name: font_name,
+              report: font_report,
+            ),
+          )
+        rescue StandardError => e
+          # Create error report for failed font loading
+          # Use collection file path with index for fonts in collections
+          error_report = Models::ValidationReport.new(
+            font_path: "#{@input}:#{index}",
+            valid: false,
+          )
+          error_report.add_error("font_loading",
+                                 "Failed to load font #{index}: #{e.message}", nil)
+
+          collection_report.add_font_report(
+            Models::FontReport.new(
+              font_index: index,
+              font_name: "Font #{index}",
+              report: error_report,
+            ),
+          )
+        end
+
+        # Generate output based on format
+        output = case @format
+                 when :yaml
+                   collection_report.to_yaml
+                 when :json
+                   collection_report.to_json
+                 else
+                   collection_report.text_summary
+                 end
+
+        # Write to file or stdout
+        if @output
+          File.write(@output, output)
+          puts "Validation report written to #{@output}" if @verbose && !@suppress_warnings
+        else
+          puts output unless @suppress_warnings
+        end
+
+        # Return exit code based on worst status
+        collection_exit_code(collection_report)
+      end
+
+      # Extract font name from font object
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font object
+      # @param index [Integer] Font index (fallback)
+      # @return [String] Font name
+      def extract_font_name(font, index)
+        return "Font #{index}" unless font.respond_to?(:table)
+
+        name_table = font.table("name")
+        return "Font #{index}" unless name_table
+
+        full_name = name_table.english_name(Tables::Name::FULL_NAME)
+        return full_name if full_name && !full_name.empty?
+
+        postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+        return postscript_name if postscript_name && !postscript_name.empty?
+
+        "Font #{index}"
+      end
+
+      # Calculate exit code for collection validation
+      #
+      # Uses worst status across all fonts
+      #
+      # @param report [CollectionValidationReport] Collection report
+      # @return [Integer] Exit code
+      def collection_exit_code(report)
+        return 0 unless @return_value_results
+
+        # Check for fatal errors first
+        return 2 if report.font_reports.any? do |fr|
+          fr.report.fatal_errors.any?
+        end
+        # Then check for errors
+        return 3 if report.font_reports.any? { |fr| fr.report.errors_only.any? }
+        # Then check for warnings
+        return 4 if report.font_reports.any? do |fr|
+          fr.report.warnings_only.any?
+        end
+        # Then check for info
+        return 5 if report.font_reports.any? { |fr| fr.report.info_only.any? }
+
+        0
+      end
 
       # Generate output based on requested format
       #
@@ -155,6 +305,7 @@ module Fontisan
         return 3 if report.errors_only.any?
         return 4 if report.warnings_only.any?
         return 5 if report.info_only.any?
+
         0
       end
     end

data/lib/fontisan/converters/collection_converter.rb

@@ -59,11 +59,12 @@ module Fontisan
 
         verbose = options.fetch(:verbose, false)
         output_path = options[:output]
-        target_format = options.fetch(:target_format, 'preserve').to_s
+        target_format = options.fetch(:target_format, "preserve").to_s
 
         # Validate target_format
         unless %w[preserve ttf otf].include?(target_format)
-          raise ArgumentError, "Invalid target_format: #{target_format}. Must be 'preserve', 'ttf', or 'otf'"
+          raise ArgumentError,
+                "Invalid target_format: #{target_format}. Must be 'preserve', 'ttf', or 'otf'"
         end
 
         puts "Converting collection to #{target_type.to_s.upcase}..." if verbose
@@ -76,19 +77,22 @@ module Fontisan
         if source_type == target_type
           puts "  Source and target formats are the same, copying collection..." if verbose
           FileUtils.cp(collection_path, output_path)
-          return build_result(collection_path, output_path, source_type, target_type, fonts.size, [])
+          return build_result(collection_path, output_path, source_type,
+                              target_type, fonts.size, [])
         end
 
         # Step 2: Convert - transform fonts if requested
         puts "  Converting #{fonts.size} font(s)..." if verbose
-        converted_fonts, conversions = convert_fonts(fonts, source_type, target_type, options.merge(target_format: target_format))
+        converted_fonts, conversions = convert_fonts(fonts, source_type,
+                                                     target_type, options.merge(target_format: target_format))
 
         # Step 3: Repack - build target collection
         puts "  Repacking into #{target_type.to_s.upcase} format..." if verbose
         repack_fonts(converted_fonts, target_type, output_path, options)
 
         # Build result
-        result = build_result(collection_path, output_path, source_type, target_type, fonts.size, conversions)
+        result = build_result(collection_path, output_path, source_type,
+                              target_type, fonts.size, conversions)
 
         if verbose
           display_result(result)
@@ -111,7 +115,8 @@ module Fontisan
         end
 
         unless %i[ttc otc dfont].include?(target_type)
-          raise ArgumentError, "Invalid target type: #{target_type}. Must be :ttc, :otc, or :dfont"
+          raise ArgumentError,
+                "Invalid target type: #{target_type}. Must be :ttc, :otc, or :dfont"
         end
 
         unless options[:output]
@@ -202,20 +207,21 @@ module Fontisan
       # @param target_type [Symbol] Target collection type
       # @param options [Hash] Conversion options
       # @return [Array<(Array<Font>, Array<Hash>)>] [converted_fonts, conversions]
-      def convert_fonts(fonts, source_type, target_type, options)
+      def convert_fonts(fonts, _source_type, target_type, options)
         converted_fonts = []
         conversions = []
 
         # Determine if outline conversion is needed
-        target_format = options.fetch(:target_format, 'preserve').to_s
+        target_format = options.fetch(:target_format, "preserve").to_s
 
         fonts.each_with_index do |font, index|
           source_format = detect_font_format(font)
-          needs_conversion = outline_conversion_needed?(source_format, target_format)
+          needs_conversion = outline_conversion_needed?(source_format,
+                                                        target_format)
 
           if needs_conversion
             # Convert outline format
-            desired_format = target_format == 'preserve' ? source_format : target_format.to_sym
+            desired_format = target_format == "preserve" ? source_format : target_format.to_sym
             converter = FormatConverter.new
 
             begin
@@ -266,7 +272,7 @@ module Fontisan
       # @return [Boolean] true if conversion needed
       def outline_conversion_needed?(source_format, target_format)
         # 'preserve' means keep original format
-        return false if target_format == 'preserve'
+        return false if target_format == "preserve"
 
         # Convert if target format differs from source
         target_format.to_sym != source_format
@@ -401,7 +407,8 @@ module Fontisan
       # @param num_fonts [Integer] Number of fonts
       # @param conversions [Array<Hash>] Conversion details
       # @return [Hash] Result
-      def build_result(input, output, source_type, target_type, num_fonts, conversions)
+      def build_result(input, output, source_type, target_type, num_fonts,
+conversions)
         {
           input: input,
           output: output,
@@ -425,7 +432,9 @@ module Fontisan
         puts "Fonts: #{result[:num_fonts]}"
 
         if result[:conversions].any?
-          converted_count = result[:conversions].count { |c| c[:status] == :converted }
+          converted_count = result[:conversions].count do |c|
+            c[:status] == :converted
+          end
           if converted_count.positive?
             puts "Outline conversions: #{converted_count}"
           end

data/lib/fontisan/converters/svg_generator.rb

@@ -107,7 +107,8 @@ module Fontisan
       # @param extractor [OutlineExtractor] Outline extractor for layer glyphs
       # @param palette_index [Integer] Palette index to use (default: 0)
       # @return [String, nil] SVG path data with color layers, or nil if not color glyph
-      def generate_color_glyph(glyph_id, colr_table, cpal_table, extractor, palette_index: 0)
+      def generate_color_glyph(glyph_id, colr_table, cpal_table, extractor,
+palette_index: 0)
         # Get layers for this glyph
         layers = colr_table.layers_for_glyph(glyph_id)
         return nil if layers.empty?

data/lib/fontisan/converters/woff2_encoder.rb

@@ -109,7 +109,7 @@ module Fontisan
         woff2_binary = assemble_woff2(header, entries, compressed_data)
 
         # Prepare result
-        result = { woff2_binary: woff2_binary }
+        { woff2_binary: woff2_binary }
 
         # Optional validation
         # Temporarily disabled - will be reimplemented with new DSL framework
@@ -117,8 +117,6 @@ module Fontisan
         #   validation_report = validate_encoding(woff2_binary, options)
         #   result[:validation_report] = validation_report
         # end
-
-        result
       end
 
       # Get list of supported conversions
@@ -185,14 +183,16 @@ module Fontisan
           end
 
           # Read table directory
-          woff2.table_entries = Woff2Font.read_table_directory_from_io(io, woff2.header)
+          woff2.table_entries = Woff2Font.read_table_directory_from_io(io,
+                                                                       woff2.header)
 
           # Decompress tables
           woff2.decompressed_tables = Woff2Font.decompress_tables(io, woff2.header,
-                                                                   woff2.table_entries)
+                                                                  woff2.table_entries)
 
           # Apply transformations
-          Woff2Font.apply_transformations!(woff2.table_entries, woff2.decompressed_tables)
+          Woff2Font.apply_transformations!(woff2.table_entries,
+                                           woff2.decompressed_tables)
 
           woff2
         end

data/lib/fontisan/converters/woff_writer.rb

@@ -369,9 +369,11 @@ module Fontisan
         # Sort tables by tag for consistent output (same order as directory)
         sorted_tables = compressed_tables.sort_by { |tag, _| tag }
 
-        sorted_tables.each do |_tag, table_info|
+        # rubocop:disable Style/HashEachMethods - sorted_tables is an Array, not a Hash
+        sorted_tables.each do |_, table_info|
           io.write(table_info[:compressed_data])
         end
+        # rubocop:enable Style/HashEachMethods
       end
 
       # Write metadata to output

data/lib/fontisan/dfont_collection.rb

@@ -2,6 +2,7 @@
 
 require_relative "parsers/dfont_parser"
 require_relative "error"
+require_relative "collection/shared_logic"
 
 module Fontisan
   # DfontCollection represents an Apple dfont suitcase containing multiple fonts
@@ -23,6 +24,8 @@ module Fontisan
   #     fonts.each { |font| puts font.class.name }
   #   end
   class DfontCollection
+    include Collection::SharedLogic
+
     # Path to dfont file
     # @return [String]
     attr_reader :path
@@ -32,6 +35,22 @@ module Fontisan
     attr_reader :num_fonts
     alias font_count num_fonts
 
+    # Get font offsets (indices for dfont)
+    #
+    # dfont doesn't use byte offsets like TTC/OTC, so we return indices
+    #
+    # @return [Array<Integer>] Array of font indices
+    def font_offsets
+      (0...@num_fonts).to_a
+    end
+
+    # Get the collection format identifier
+    #
+    # @return [String] "dfont" for dfont collection
+    def self.collection_format
+      "dfont"
+    end
+
     # Load dfont collection from file
     #
     # @param path [String] Path to dfont file
@@ -65,6 +84,15 @@ module Fontisan
       File.exist?(@path) && @num_fonts.positive?
     end
 
+    # Get the collection version as a string
+    #
+    # dfont files don't have version numbers like TTC/OTC
+    #
+    # @return [String] Version string (always "N/A" for dfont)
+    def version_string
+      "N/A"
+    end
+
     # Extract all fonts from dfont
     #
     # @param io [IO] Open file handle
@@ -181,5 +209,61 @@ module Fontisan
 
       font
     end
+
+    # Get comprehensive collection metadata
+    #
+    # Returns a CollectionInfo model with header information and
+    # table sharing statistics for the dfont collection.
+    # 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 [Models::CollectionInfo] Collection metadata
+    #
+    # @example Get collection info
+    #   File.open("family.dfont", "rb") do |io|
+    #     collection = DfontCollection.from_file("family.dfont")
+    #     info = collection.collection_info(io, "family.dfont")
+    #     puts "Format: #{info.collection_format}"
+    #   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: self.class.collection_format,
+        ttc_tag: "dfnt", # dfont doesn't use ttcf tag
+        major_version: 0, # dfont doesn't have version
+        minor_version: 0,
+        num_fonts: @num_fonts,
+        font_offsets: font_offsets,
+        file_size_bytes: file_size,
+        table_sharing: table_sharing,
+      )
+    end
+
+    private
+
+    # Calculate table sharing statistics
+    #
+    # Analyzes which tables are shared between fonts and calculates
+    # space savings from deduplication.
+    #
+    # @param io [IO] Open file handle
+    # @return [Models::TableSharingInfo] Sharing statistics
+    def calculate_table_sharing(io)
+      # Extract all fonts
+      fonts = extract_fonts(io)
+
+      # Use shared logic for calculation
+      calculate_table_sharing_for_fonts(fonts)
+    end
   end
 end

data/lib/fontisan/font_loader.rb

@@ -72,7 +72,8 @@ module Fontisan
         when "wOF2"
           Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when Constants::DFONT_RESOURCE_HEADER
-          extract_and_load_dfont(io, path, font_index, resolved_mode, resolved_lazy)
+          extract_and_load_dfont(io, path, font_index, resolved_mode,
+                                 resolved_lazy)
         else
           raise InvalidFontError,
                 "Unknown font format. Expected TTF, OTF, TTC, OTC, WOFF, or WOFF2 file."
@@ -99,11 +100,10 @@ module Fontisan
         # Check for TTC/OTC signature
         return true if signature == Constants::TTC_TAG
 
-        # Check for multi-font dfont (suitcase) - only if it's actually a dfont
+        # Check for dfont - dfont is a collection format even if it contains only one font
         if signature == Constants::DFONT_RESOURCE_HEADER
           require_relative "parsers/dfont_parser"
-          # Verify it's a valid dfont and has multiple fonts
-          return Parsers::DfontParser.dfont?(io) && Parsers::DfontParser.sfnt_count(io) > 1
+          return Parsers::DfontParser.dfont?(io)
         end
 
         false
@@ -186,7 +186,7 @@ module Fontisan
         num_fonts = io.read(4).unpack1("N")
 
         # Read all font offsets
-        font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+        font_offsets = Array.new(num_fonts) { io.read(4).unpack1("N") }
 
         # Scan all fonts to determine collection type (not just first)
         truetype_count = 0
@@ -213,7 +213,7 @@ module Fontisan
         # Determine collection type based on what fonts are inside
         # If ANY font is OpenType, use OpenTypeCollection (more general format)
         # Only use TrueTypeCollection if ALL fonts are TrueType
-        if opentype_count > 0
+        if opentype_count.positive?
           OpenTypeCollection.from_file(path)
         else
           # All fonts are TrueType
@@ -283,7 +283,7 @@ mode: LoadingModes::FULL, lazy: true)
       end
 
       # Read all font offsets
-      font_offsets = num_fonts.times.map { io.read(4).unpack1("N") }
+      font_offsets = Array.new(num_fonts) { io.read(4).unpack1("N") }
 
       # Scan all fonts to determine collection type (not just first)
       truetype_count = 0
@@ -309,7 +309,7 @@ mode: LoadingModes::FULL, lazy: true)
 
       # If ANY font is OpenType, use OpenTypeCollection (more general format)
       # Only use TrueTypeCollection if ALL fonts are TrueType
-      if opentype_count > 0
+      if opentype_count.positive?
         # OpenType Collection
         otc = OpenTypeCollection.from_file(path)
         File.open(path, "rb") { |f| otc.font(font_index, f, mode: mode) }
@@ -329,7 +329,7 @@ mode: LoadingModes::FULL, lazy: true)
     # @param lazy [Boolean] Lazy loading flag
     # @return [TrueTypeFont, OpenTypeFont] Loaded font
     # @api private
-    def self.extract_and_load_dfont(io, path, font_index, mode, lazy)
+    def self.extract_and_load_dfont(io, _path, font_index, mode, lazy)
       require_relative "parsers/dfont_parser"
 
       # Extract SFNT data from resource fork

data/lib/fontisan/formatters/text_formatter.rb

@@ -410,15 +410,16 @@ module Fontisan
 
           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 << if font_info.collection_offset
+                       "Font #{index} (offset: #{font_info.collection_offset}):"
+                     else
+                       "Font #{index}:"
+                     end
             lines << ""
 
             # Format each font using same structure as brief mode
-            font_type_display = format_font_type_display(font_info.font_format, font_info.is_variable)
+            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)
@@ -426,7 +427,8 @@ module Fontisan
             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, "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)
@@ -467,15 +469,16 @@ module Fontisan
         # 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 << if font_info.collection_offset
+                     "Font #{index} (offset: #{font_info.collection_offset}):"
+                   else
+                     "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)
+          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)
@@ -483,7 +486,8 @@ module Fontisan
           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, "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)

data/lib/fontisan/hints/hint_converter.rb

@@ -244,7 +244,7 @@ module Fontisan
         # CVT values typically contain standard widths at the beginning
         if cvt && !cvt.empty?
           # First CVT value often represents standard horizontal stem
-          hints[:std_hw] = cvt[0].abs if cvt.length > 0
+          hints[:std_hw] = cvt[0].abs if cvt.length.positive?
           # Second CVT value often represents standard vertical stem
           hints[:std_vw] = cvt[1].abs if cvt.length > 1
         end