fontisan 0.2.7 → 0.2.8

data/README.adoc

@@ -1034,26 +1034,19 @@ structures, usability, instructions, and glyphs.
 
 === Predefined profiles
 
-Fontisan includes several predefined validation profiles for common use cases:
+Fontisan includes validation profiles for different use cases:
 
-`indexability`:: Fast validation for font discovery and indexing (< 50ms). Uses
-BasicValidator with 8 essential checks. Loading mode: metadata.
+`indexability`:: Fast font discovery and indexing (~5x faster, 8 checks, metadata-only)
 
-`usability`:: Basic usability for font installation. Uses FontBookValidator with
-26 checks including macOS Font Book compatibility. Loading mode: full.
+`usability`:: Font installation compatibility (26 checks, macOS Font Book focused)
 
-`production`:: Comprehensive quality checks for production fonts (default
-profile). Uses OpenTypeValidator with 36 checks for OpenType spec compliance.
-Loading mode: full.
+`production`:: Comprehensive production quality (36 checks, OpenType spec compliance - default)
 
-`web`:: Web font embedding and optimization validation. Uses WebFontValidator
-with 18 checks for web deployment. Loading mode: full.
+`web`:: Web font embedding readiness (18 checks for web deployment)
 
-`spec_compliance`:: Full OpenType specification compliance with detailed checks.
-Uses OpenTypeValidator with info-level severity for comprehensive analysis.
-Loading mode: full.
+`spec_compliance`:: Full OpenType specification compliance (detailed analysis mode)
 
-`default`:: Alias for the production profile.
+`default`:: Alias for the production profile
 
 
 === Command-line usage
@@ -1154,6 +1147,80 @@ production, web, spec_compliance, default)
 
 -e, --exclude CHECKS:: Exclude specific checks (comma-separated list)
 
+=== Collection validation
+
+The `validate` command automatically detects and validates font collections (TTC, OTC, dfont).
+When validating a collection, fontisan validates all fonts in the collection and displays
+per-font results with an overall summary.
+
+.Validation profiles with collections
+[example]
+====
+All validation profiles work with font collections. The selected profile determines:
+
+* **Which tables are loaded** - metadata vs full mode
+* **Which checks are performed** - number and type of validations
+* **Performance characteristics** - indexability is ~5x faster than production
+
+For large collections (CJK fonts with 30+ fonts), use the `indexability` profile for fast
+validation when scanning for font discovery, or `production` for comprehensive quality
+checks.
+
+[source,shell]
+----
+# Quick validation for indexing (metadata mode, 8 checks, ~5x faster)
+$ fontisan validate /path/to/font.ttc -t indexability
+
+# Comprehensive validation (full mode, 37 checks)
+$ fontisan validate /path/to/font.ttc -t production
+
+# Web font readiness validation
+$ fontisan validate /path/to/font.ttc -t web
+----
+
+The collection validation output includes:
+
+* *Collection header* - Path, type, and number of fonts
+* *Summary* - Total errors, warnings, and info across all fonts
+* *Per-font sections* - Individual validation results for each font with:
+** Font index and name
+** Font path in `collection.ttc:index` format
+** Individual font status (VALID/INVALID/VALID_WITH_WARNINGS)
+** Font-specific errors and warnings
+** Exit codes* - For collections, uses the "worst" status across all fonts:
+** 0 = All fonts valid
+** 2 = Any font has fatal errors
+** 3 = Any font has errors (and no fatal)
+** 4 = Any font has warnings (and no errors)
+** 5 = Any font has info issues (and no errors or warnings)
+====
+
+.Validate a font collection
+[example]
+====
+[source,shell]
+----
+$ fontisan validate /path/to/font.ttc
+Collection: /path/to/font.ttc
+Type: TTC
+Fonts: 4
+
+Summary:
+  Total Errors: 14
+  Total Warnings: 8
+  Total Info: 0
+
+=== Font 0: Lucida Grande ===
+Font: /path/to/font.ttc:0
+Status: INVALID
+...
+
+=== Font 1: Lucida Grande Bold ===
+Font: /path/to/font.ttc:1
+Status: INVALID
+...
+----
+====
 
 === Ruby API usage
 

data/Rakefile

@@ -8,6 +8,7 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
+# rubocop:disable Metrics/BlockLength
 namespace :fixtures do
   # Load centralized fixture configuration
   require_relative "spec/support/fixture_fonts"
@@ -99,8 +100,13 @@ namespace :fixtures do
     end
   end
 
+  # Compute download task prerequisites (marker files for non-skipped fonts)
+  download_prerequisites = fonts.values.reject do |config|
+    config[:skip_download]
+  end.map { |config| config[:marker] }
+
   desc "Download all test fixture fonts"
-  task download: fonts.values.reject { |config| config[:skip_download] }.map { |config| config[:marker] }
+  task download: download_prerequisites
 
   desc "Clean downloaded fixtures"
   task :clean do
@@ -112,17 +118,16 @@ namespace :fixtures do
           FileUtils.rm_f(config[:marker])
           puts "[fixtures:clean] Removed #{config[:marker]}"
         end
-      else
+      elsif File.exist?(config[:target_dir])
         # For archives, delete the entire target directory
-        if File.exist?(config[:target_dir])
-          puts "[fixtures:clean] Removing #{config[:target_dir]}..."
-          FileUtils.rm_rf(config[:target_dir])
-          puts "[fixtures:clean] Removed #{config[:target_dir]}"
-        end
+        puts "[fixtures:clean] Removing #{config[:target_dir]}..."
+        FileUtils.rm_rf(config[:target_dir])
+        puts "[fixtures:clean] Removed #{config[:target_dir]}"
       end
     end
   end
 end
+# rubocop:enable Metrics/BlockLength
 
 # RSpec task depends on fixtures
 RSpec::Core::RakeTask.new(spec: "fixtures:download")

data/benchmark/variation_quick_bench.rb

@@ -18,7 +18,7 @@ puts "Font: #{FONT_PATH}"
 puts
 
 # Test coordinates
-coords = Array.new(4) { |i| { "wght" => 300 + i * 200 } }
+coords = Array.new(4) { |i| { "wght" => 300 + (i * 200) } }
 puts "Generating #{coords.size} instances"
 puts
 

data/lib/fontisan/cli.rb

@@ -367,18 +367,27 @@ module Fontisan
       handle_error(e)
     end
 
-    desc "validate FONT_FILE", "Validate font file"
+    desc "validate [FONT_FILE]", "Validate font file"
     long_desc <<-DESC
       Validate font file against quality checks and standards.
 
-      Test lists (-t/--test-list):
-        indexability     - Fast indexing validation
+      Supports individual fonts (TTF/OTF) and font collections (TTC/OTC/dfont).
+      For collections, validates each font and provides a summary report.
+
+      Profiles (-p/--profile):
+        indexability     - Fast indexing validation (metadata only, 8 checks)
         usability        - Installation compatibility
         production       - Comprehensive quality (default)
         web              - Web font readiness
         spec_compliance  - OpenType spec compliance
         default          - Production profile (alias)
 
+      Collection validation with profiles:
+        When validating TTC/OTC/dfont collections, the selected profile
+        determines which tables are loaded and which checks are performed
+        for each font in the collection. Use 'indexability' for quick
+        validation or 'production' for comprehensive quality checks.
+
       Return values (with -R/--return-value-results):
         0  No results
         1  Execution errors
@@ -389,25 +398,41 @@ module Fontisan
     DESC
 
     option :exclude, aliases: "-e", type: :array, desc: "Tests to exclude"
-    option :list, aliases: "-l", type: :boolean, desc: "List available tests"
+    option :list, aliases: "-l", type: :boolean, desc: "List available profiles"
     option :output, aliases: "-o", type: :string, desc: "Output file"
     option :full_report, aliases: "-r", type: :boolean, desc: "Full report"
-    option :return_value_results, aliases: "-R", type: :boolean, desc: "Use return value for results"
-    option :summary_report, aliases: "-S", type: :boolean, desc: "Summary report"
-    option :test_list, aliases: "-t", type: :string, default: "default", desc: "Tests to execute"
+    option :return_value_results, aliases: "-R", type: :boolean,
+                                  desc: "Use return value for results"
+    option :summary_report, aliases: "-S", type: :boolean,
+                            desc: "Summary report"
+    option :profile, aliases: "-p", type: :string, default: "default",
+                     desc: "Validation profile"
     option :table_report, aliases: "-T", type: :boolean, desc: "Tabular report"
     option :verbose, aliases: "-v", type: :boolean, desc: "Verbose output"
-    option :suppress_warnings, aliases: "-W", type: :boolean, desc: "Suppress warnings"
+    option :suppress_warnings, aliases: "-W", type: :boolean,
+                               desc: "Suppress warnings"
 
-    def validate(font_file)
+    def validate(*font_files)
       if options[:list]
         list_available_tests
         return
       end
 
+      # Validate argument count
+      if font_files.empty?
+        raise(Thor::Error, "FONT_FILE is required unless using --list")
+      elsif font_files.size > 1
+        raise(Thor::Error,
+              "Too many arguments. validate accepts only one font file.\n" \
+              "To validate multiple files, run validate separately for each.\n" \
+              "To validate all fonts in a collection, use: fontisan validate collection.ttc")
+      end
+
+      font_file = font_files.first
+
       cmd = Commands::ValidateCommand.new(
         input: font_file,
-        profile: options[:test_list],
+        profile: options[:profile],
         exclude: options[:exclude] || [],
         output: options[:output],
         format: options[:format].to_sym,
@@ -416,11 +441,18 @@ module Fontisan
         table_report: options[:table_report],
         verbose: options[:verbose],
         suppress_warnings: options[:suppress_warnings],
-        return_value_results: options[:return_value_results]
+        return_value_results: options[:return_value_results],
       )
 
       exit cmd.run
-    rescue => e
+    rescue Thor::Error => e
+      unless options[:quiet]
+        warn "ERROR: #{e.message}"
+        warn
+        help("validate")
+      end
+      exit 1
+    rescue StandardError => e
       error "Validation failed: #{e.message}"
       exit 1
     end
@@ -546,7 +578,7 @@ module Fontisan
         puts "  Format: #{result[:format].upcase}"
         puts "  Fonts: #{result[:num_fonts]}"
         puts "  Size: #{format_size(result[:output_size] || result[:total_size])}"
-        if result[:space_savings] && result[:space_savings].positive?
+        if result[:space_savings]&.positive?
           puts "  Space saved: #{format_size(result[:space_savings])}"
           puts "  Sharing: #{result[:statistics][:sharing_percentage]}%"
         end

data/lib/fontisan/collection/dfont_builder.rb

@@ -86,7 +86,8 @@ module Fontisan
         map_size = 28 + 2 + 8 + (sfnt_binaries.size * 12)
 
         # Step 4: Build resource map
-        resource_map = build_resource_map(sfnt_binaries, resource_data.bytesize, map_size)
+        resource_map = build_resource_map(sfnt_binaries,
+                                          resource_data.bytesize, map_size)
 
         # Step 5: Build header
         header = build_header(resource_data.bytesize, resource_map.bytesize)

data/lib/fontisan/commands/convert_command.rb

@@ -73,7 +73,7 @@ module Fontisan
         @instance_index = opts[:instance_index]
         @preserve_variation = opts[:preserve_variation]
         @preserve_hints = opts.fetch(:preserve_hints, false)
-        @collection_target_format = opts.fetch(:target_format, 'preserve').to_s
+        @collection_target_format = opts.fetch(:target_format, "preserve").to_s
         @validate = !opts[:no_validate]
       end
 
@@ -196,7 +196,7 @@ module Fontisan
             output: @output_path,
             target_format: @collection_target_format,
             verbose: @options[:verbose],
-          }
+          },
         )
 
         # Display results
@@ -245,8 +245,6 @@ module Fontisan
             :otc
           when ".dfont"
             :dfont
-          else
-            nil
           end
         end
       end

data/lib/fontisan/commands/info_command.rb

@@ -311,7 +311,7 @@ module Fontisan
               start_glyph_id: strike_rec.start_glyph_index,
               end_glyph_id: strike_rec.end_glyph_index,
               bit_depth: strike_rec.bit_depth,
-              num_glyphs: strike_rec.glyph_range.size
+              num_glyphs: strike_rec.glyph_range.size,
             )
           end
           formats << "PNG" # CBDT typically contains PNG data
@@ -329,8 +329,8 @@ module Fontisan
               ppem: strike[:ppem],
               start_glyph_id: 0,
               end_glyph_id: strike[:num_glyphs] - 1,
-              bit_depth: 32,  # sbix is typically 32-bit
-              num_glyphs: strike[:num_glyphs]
+              bit_depth: 32, # sbix is typically 32-bit
+              num_glyphs: strike[:num_glyphs],
             )
           end
         end

data/lib/fontisan/commands/pack_command.rb

@@ -260,7 +260,8 @@ module Fontisan
       # @return [Symbol] Parsed format (:ttc, :otc, or :dfont)
       # @raise [ArgumentError] if format is invalid
       def parse_format(format)
-        return format if format.is_a?(Symbol) && %i[ttc otc dfont].include?(format)
+        return format if format.is_a?(Symbol) && %i[ttc otc
+                                                    dfont].include?(format)
 
         case format.to_s.downcase
         when "ttc"

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?