fontisan 0.2.4 → 0.2.6

data/lib/fontisan/commands/pack_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "base_command"
 require_relative "../collection/builder"
+require_relative "../collection/dfont_builder"
 require_relative "../font_loader"
 
 module Fontisan
@@ -11,6 +12,7 @@ module Fontisan
     # This command provides CLI access to font collection creation functionality.
     # It loads multiple font files and combines them into a single TTC (TrueType Collection)
     # or OTC (OpenType Collection) file with shared table deduplication to save space.
+    # It also supports creating dfont (Apple Data Fork Font) suitcases.
     #
     # @example Pack fonts into TTC
     #   command = PackCommand.new(
@@ -30,13 +32,21 @@ module Fontisan
     #     analyze: true
     #   )
     #   result = command.run
+    #
+    # @example Pack into dfont
+    #   command = PackCommand.new(
+    #     ['font1.ttf', 'font2.otf'],
+    #     output: 'family.dfont',
+    #     format: :dfont
+    #   )
+    #   result = command.run
     class PackCommand
       # Initialize pack command
       #
       # @param font_paths [Array<String>] Paths to input font files
       # @param options [Hash] Command options
       # @option options [String] :output Output file path (required)
-      # @option options [Symbol, String] :format Format type (:ttc or :otc, default: :ttc)
+      # @option options [Symbol, String] :format Format type (:ttc, :otc, or :dfont, default: auto-detect)
       # @option options [Boolean] :optimize Enable table sharing optimization (default: true)
       # @option options [Boolean] :analyze Show analysis report before building (default: false)
       # @option options [Boolean] :verbose Enable verbose output (default: false)
@@ -45,7 +55,7 @@ module Fontisan
         @font_paths = font_paths
         @options = options
         @output_path = options[:output]
-        @format = parse_format(options[:format] || :ttc)
+        @format = options[:format] ? parse_format(options[:format]) : nil
         @optimize = options.fetch(:optimize, true)
         @analyze = options.fetch(:analyze, false)
         @verbose = options.fetch(:verbose, false)
@@ -55,16 +65,16 @@ module Fontisan
 
       # Execute the pack command
       #
-      # Loads all fonts, analyzes tables, and creates a TTC/OTC collection.
+      # Loads all fonts, analyzes tables, and creates a TTC/OTC/dfont collection.
       # Optionally displays analysis before building.
       #
       # @return [Hash] Result information with:
       #   - :output [String] - Output file path
       #   - :output_size [Integer] - Output file size in bytes
       #   - :num_fonts [Integer] - Number of fonts packed
-      #   - :format [Symbol] - Collection format (:ttc or :otc)
-      #   - :space_savings [Integer] - Bytes saved through sharing
-      #   - :sharing_percentage [Float] - Percentage of tables shared
+      #   - :format [Symbol] - Collection format (:ttc, :otc, or :dfont)
+      #   - :space_savings [Integer] - Bytes saved through sharing (TTC/OTC only)
+      #   - :sharing_percentage [Float] - Percentage of tables shared (TTC/OTC only)
       #   - :analysis [Hash] - Analysis report (if analyze option enabled)
       # @raise [ArgumentError] if options are invalid
       # @raise [Fontisan::Error] if packing fails
@@ -74,6 +84,46 @@ module Fontisan
         # Load all fonts
         fonts = load_fonts
 
+        # Auto-detect format if not specified
+        @format ||= auto_detect_format(fonts)
+        puts "Auto-detected format: #{@format}" if @verbose && !@options[:format]
+
+        # Build collection based on format
+        if @format == :dfont
+          build_dfont(fonts)
+        else
+          build_ttc_otc(fonts)
+        end
+      rescue Fontisan::Error => e
+        raise Fontisan::Error, "Collection packing failed: #{e.message}"
+      rescue StandardError => e
+        raise Fontisan::Error, "Unexpected error during packing: #{e.message}"
+      end
+
+      private
+
+      # Build dfont collection
+      #
+      # @param fonts [Array] Loaded fonts
+      # @return [Hash] Build result
+      def build_dfont(fonts)
+        puts "Building dfont suitcase..." if @verbose
+
+        builder = Collection::DfontBuilder.new(fonts)
+        result = builder.build_to_file(@output_path)
+
+        if @verbose
+          display_dfont_results(result)
+        end
+
+        result
+      end
+
+      # Build TTC/OTC collection
+      #
+      # @param fonts [Array] Loaded fonts
+      # @return [Hash] Build result
+      def build_ttc_otc(fonts)
         # Create builder
         builder = Collection::Builder.new(fonts, {
                                             format: @format,
@@ -98,13 +148,53 @@ module Fontisan
         end
 
         result
-      rescue Fontisan::Error => e
-        raise Fontisan::Error, "Collection packing failed: #{e.message}"
-      rescue StandardError => e
-        raise Fontisan::Error, "Unexpected error during packing: #{e.message}"
       end
 
-      private
+      # Auto-detect collection format based on fonts
+      #
+      # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Loaded fonts
+      # @return [Symbol] Detected format (:ttc, :otc, or :dfont)
+      def auto_detect_format(fonts)
+        # Check output extension first
+        ext = File.extname(@output_path).downcase
+        return :ttc if ext == ".ttc"
+        return :otc if ext == ".otc"
+        return :dfont if ext == ".dfont"
+
+        # Detect based on font types
+        has_truetype = fonts.any? { |f| truetype_font?(f) }
+        has_opentype = fonts.any? { |f| opentype_font?(f) }
+
+        if has_truetype && !has_opentype
+          :ttc  # All TrueType
+        elsif has_opentype
+          :otc  # Has OpenType/CFF fonts
+        else
+          :ttc  # Default to TTC
+        end
+      end
+
+      # Check if font is TrueType
+      #
+      # @param font [Object] Font object
+      # @return [Boolean]
+      def truetype_font?(font)
+        return false unless font.respond_to?(:header)
+
+        sfnt = font.header.sfnt_version
+        [0x00010000, 0x74727565].include?(sfnt) # 0x74727565 = 'true'
+      end
+
+      # Check if font is OpenType/CFF
+      #
+      # @param font [Object] Font object
+      # @return [Boolean]
+      def opentype_font?(font)
+        return false unless font.respond_to?(:header)
+
+        sfnt = font.header.sfnt_version
+        sfnt == 0x4F54544F # 'OTTO'
+      end
 
       # Validate command options
       #
@@ -125,17 +215,19 @@ module Fontisan
                 "Collection requires at least 2 fonts, got #{@font_paths.size}"
         end
 
-        # Validate format
-        unless %i[ttc otc].include?(@format)
+        # Validate format if specified
+        if @format && !%i[ttc otc dfont].include?(@format)
           raise ArgumentError,
-                "Invalid format: #{@format}. Must be :ttc or :otc"
+                "Invalid format: #{@format}. Must be :ttc, :otc, or :dfont"
         end
 
-        # Check output extension matches format
-        ext = File.extname(@output_path).downcase
-        expected_ext = @format == :ttc ? ".ttc" : ".otc"
-        if ext != expected_ext
-          warn "Warning: Output extension '#{ext}' doesn't match format '#{@format}' (expected '#{expected_ext}')"
+        # Warn if output extension doesn't match format (if format specified)
+        if @format
+          ext = File.extname(@output_path).downcase
+          expected_ext = ".#{@format}"
+          if ext != expected_ext
+            warn "Warning: Output extension '#{ext}' doesn't match format '#{@format}' (expected '#{expected_ext}')"
+          end
         end
       end
 
@@ -165,19 +257,21 @@ module Fontisan
       # Parse format option
       #
       # @param format [Symbol, String] Format option
-      # @return [Symbol] Parsed format (:ttc or :otc)
+      # @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].include?(format)
+        return format if format.is_a?(Symbol) && %i[ttc otc dfont].include?(format)
 
         case format.to_s.downcase
         when "ttc"
           :ttc
         when "otc"
           :otc
+        when "dfont"
+          :dfont
         else
           raise ArgumentError,
-                "Invalid format: #{format}. Must be 'ttc' or 'otc'"
+                "Invalid format: #{format}. Must be 'ttc', 'otc', or 'dfont'"
         end
       end
 
@@ -223,6 +317,19 @@ module Fontisan
         puts ""
       end
 
+      # Display dfont build results
+      #
+      # @param result [Hash] Build result
+      # @return [void]
+      def display_dfont_results(result)
+        puts "\n=== dfont Suitcase Created ==="
+        puts "Output: #{result[:output_path]}"
+        puts "Format: #{result[:format].upcase}"
+        puts "Fonts: #{result[:num_fonts]}"
+        puts "Size: #{format_bytes(result[:total_size])}"
+        puts ""
+      end
+
       # Format bytes for display
       #
       # @param bytes [Integer] Byte count

data/lib/fontisan/commands/validate_command.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_command"
-require_relative "../validation/validator"
-require_relative "../validation/variable_font_validator"
+require_relative "../validators/profile_loader"
 require_relative "../font_loader"
 
 module Fontisan
@@ -11,195 +10,152 @@ module Fontisan
     #
     # This command validates fonts against quality checks, structural integrity,
     # and OpenType specification compliance. It supports different validation
-    # levels and output formats.
+    # profiles and output formats, with ftxvalidator-compatible options.
     #
-    # @example Validating a font
+    # @example Validating a font with default profile
+    #   command = ValidateCommand.new(input: "font.ttf")
+    #   exit_code = command.run
+    #
+    # @example Validating with specific profile
     #   command = ValidateCommand.new(
     #     input: "font.ttf",
-    #     level: :standard,
-    #     format: :text
+    #     profile: :web,
+    #     format: :json
     #   )
     #   exit_code = command.run
     class ValidateCommand < BaseCommand
       # Initialize validate command
       #
       # @param input [String] Path to font file
-      # @param level [Symbol] Validation level (:strict, :standard, :lenient)
+      # @param profile [Symbol, String, nil] Validation profile (default: :default)
+      # @param exclude [Array<String>] Tests to exclude
+      # @param output [String, nil] Output file path
       # @param format [Symbol] Output format (:text, :yaml, :json)
-      # @param verbose [Boolean] Show all issues (default: true)
-      # @param quiet [Boolean] Only return exit code, no output (default: false)
-      def initialize(input:, level: :standard, format: :text, verbose: true,
-quiet: false)
-        super()
+      # @param full_report [Boolean] Generate full detailed report
+      # @param summary_report [Boolean] Generate brief summary report
+      # @param table_report [Boolean] Generate tabular format report
+      # @param verbose [Boolean] Show verbose output
+      # @param suppress_warnings [Boolean] Suppress warning output
+      # @param return_value_results [Boolean] Use return values to indicate results
+      def initialize(
+        input:,
+        profile: nil,
+        exclude: [],
+        output: nil,
+        format: :text,
+        full_report: false,
+        summary_report: false,
+        table_report: false,
+        verbose: false,
+        suppress_warnings: false,
+        return_value_results: false
+      )
         @input = input
-        @level = level.to_sym
-        @format = format.to_sym
+        @profile = profile || :default
+        @exclude = exclude
+        @output = output
+        @format = format
+        @full_report = full_report
+        @summary_report = summary_report
+        @table_report = table_report
         @verbose = verbose
-        @quiet = quiet
+        @suppress_warnings = suppress_warnings
+        @return_value_results = return_value_results
       end
 
       # Run the validation command
       #
-      # @return [Integer] Exit code (0 = valid, 1 = errors, 2 = warnings only)
+      # @return [Integer] Exit code (0 = valid, 2 = fatal, 3 = errors, 4 = warnings, 5 = info)
       def run
-        validate_params!
-
-        # Load font
-        font = load_font
-        return 1 unless font
-
-        # Create validator
-        validator = Validation::Validator.new(level: @level)
-
-        # Run validation
-        report = validator.validate(font, @input)
+        # Load font with appropriate mode
+        profile_config = Validators::ProfileLoader.profile_info(@profile)
+        unless profile_config
+          puts "Error: Unknown profile '#{@profile}'" unless @suppress_warnings
+          return 1
+        end
 
-        # Add variable font validation if applicable
-        validate_variable_font(font, report) if font.has_table?("fvar")
+        mode = profile_config[:loading_mode].to_sym
 
-        # Output results unless quiet mode
-        output_report(report) unless @quiet
+        font = FontLoader.load(@input, mode: mode)
 
-        # Return appropriate exit code
-        determine_exit_code(report)
-      rescue StandardError => e
-        puts "Error: #{e.message}" unless @quiet
-        puts e.backtrace.join("\n") if @verbose && !@quiet
-        1
-      end
+        # Select validator
+        validator = Validators::ProfileLoader.load(@profile)
 
-      private
-
-      # Validate variable font structure
-      #
-      # @param font [TrueTypeFont, OpenTypeFont] The font to validate
-      # @param report [Models::ValidationReport] The validation report to update
-      # @return [void]
-      def validate_variable_font(font, report)
-        var_validator = Validation::VariableFontValidator.new(font)
-        errors = var_validator.validate
+        # Run validation
+        report = validator.validate(font)
 
-        if errors.any?
-          puts "\nVariable font validation:" if @verbose && !@quiet
-          errors.each do |error|
-            puts "  ERROR: #{error}" if @verbose && !@quiet
-            # Add to report if report supports adding errors
-            if report.respond_to?(:errors)
-              report.errors << { message: error,
-                                 category: "variable_font" }
-            end
-          end
-        elsif @verbose && !@quiet
-          puts "\n✓ Variable font structure valid"
+        # Filter excluded checks if specified
+        if @exclude.any?
+          report.check_results.reject! { |cr| @exclude.include?(cr.check_id) }
         end
-      end
 
-      # Validate command parameters
-      #
-      # @raise [ArgumentError] if parameters are invalid
-      # @return [void]
-      def validate_params!
-        if @input.nil? || @input.empty?
-          raise ArgumentError,
-                "Input file is required"
-        end
-        unless File.exist?(@input)
-          raise ArgumentError,
-                "Input file does not exist: #{@input}"
-        end
+        # Generate output
+        output = generate_output(report)
 
-        valid_levels = %i[strict standard lenient]
-        unless valid_levels.include?(@level)
-          raise ArgumentError,
-                "Invalid level: #{@level}. Must be one of: #{valid_levels.join(', ')}"
-        end
-
-        valid_formats = %i[text yaml json]
-        unless valid_formats.include?(@format)
-          raise ArgumentError,
-                "Invalid format: #{@format}. Must be one of: #{valid_formats.join(', ')}"
+        # 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
-      end
 
-      # Load the font file
-      #
-      # @return [TrueTypeFont, OpenTypeFont, nil] The loaded font or nil on error
-      def load_font
-        FontLoader.load(@input)
-      rescue StandardError => e
-        puts "Error loading font: #{e.message}" unless @quiet
-        nil
+        # 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
 
-      # Output validation report in requested format
-      #
-      # @param report [Models::ValidationReport] The validation report
-      # @return [void]
-      def output_report(report)
-        case @format
-        when :text
-          output_text(report)
-        when :yaml
-          output_yaml(report)
-        when :json
-          output_json(report)
-        end
-      end
+      private
 
-      # Output report in text format
+      # Generate output based on requested format
       #
-      # @param report [Models::ValidationReport] The validation report
-      # @return [void]
-      def output_text(report)
-        if @verbose
-          puts report.text_summary
+      # @param report [ValidationReport] The validation report
+      # @return [String] Formatted output
+      def generate_output(report)
+        if @table_report
+          report.to_table_format
+        elsif @summary_report
+          report.to_summary
+        elsif @full_report
+          report.to_text_report
         else
-          # Compact output: just status and error/warning counts
-          status = report.valid ? "VALID" : "INVALID"
-          puts "#{status}: #{report.summary.errors} errors, #{report.summary.warnings} warnings"
-
-          # Show errors only in non-verbose mode
-          report.errors.each do |error|
-            puts "  [ERROR] #{error.message}"
+          # Default: format-specific output
+          case @format
+          when :yaml
+            require "yaml"
+            report.to_yaml
+          when :json
+            require "json"
+            report.to_json
+          else
+            report.text_summary
           end
         end
       end
 
-      # Output report in YAML format
-      #
-      # @param report [Models::ValidationReport] The validation report
-      # @return [void]
-      def output_yaml(report)
-        require "yaml"
-        puts report.to_yaml
-      end
-
-      # Output report in JSON format
-      #
-      # @param report [Models::ValidationReport] The validation report
-      # @return [void]
-      def output_json(report)
-        require "json"
-        puts report.to_json
-      end
-
       # Determine exit code based on validation results
       #
-      # Exit codes:
-      # - 0: Valid (no errors, or only warnings in lenient mode)
-      # - 1: Has errors
-      # - 2: Has warnings only (no errors)
+      # Exit codes (ftxvalidator compatible):
+      #   0 = No issues found
+      #   1 = Execution errors
+      #   2 = Fatal errors found
+      #   3 = Major errors found
+      #   4 = Minor errors (warnings) found
+      #   5 = Spec violations (info) found
       #
-      # @param report [Models::ValidationReport] The validation report
+      # @param report [ValidationReport] The validation report
       # @return [Integer] Exit code
-      def determine_exit_code(report)
-        if report.has_errors?
-          1
-        elsif report.has_warnings?
-          2
-        else
-          0
-        end
+      def exit_code(report)
+        return 0 unless @return_value_results
+
+        return 2 if report.fatal_errors.any?
+        return 3 if report.errors_only.any?
+        return 4 if report.warnings_only.any?
+        return 5 if report.info_only.any?
+        0
       end
     end
   end