fontisan 0.2.4 → 0.2.5

data/lib/fontisan/cli.rb

@@ -350,13 +350,62 @@ module Fontisan
       handle_error(e)
     end
 
-    desc "validate FONT_FILE", "Validate font file structure and checksums"
-    option :verbose, type: :boolean, default: false,
-                     desc: "Show detailed validation information"
+    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
+        usability        - Installation compatibility
+        production       - Comprehensive quality (default)
+        web              - Web font readiness
+        spec_compliance  - OpenType spec compliance
+        default          - Production profile (alias)
+
+      Return values (with -R/--return-value-results):
+        0  No results
+        1  Execution errors
+        2  Fatal errors found
+        3  Major errors found
+        4  Minor errors found
+        5  Spec violations found
+    DESC
+
+    option :exclude, aliases: "-e", type: :array, desc: "Tests to exclude"
+    option :list, aliases: "-l", type: :boolean, desc: "List available tests"
+    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 :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"
+
     def validate(font_file)
-      command = Commands::ValidateCommand.new(font_file,
-                                              verbose: options[:verbose])
-      exit command.run
+      if options[:list]
+        list_available_tests
+        return
+      end
+
+      cmd = Commands::ValidateCommand.new(
+        input: font_file,
+        profile: options[:test_list],
+        exclude: options[:exclude] || [],
+        output: options[:output],
+        format: options[:format].to_sym,
+        full_report: options[:full_report],
+        summary_report: options[:summary_report],
+        table_report: options[:table_report],
+        verbose: options[:verbose],
+        suppress_warnings: options[:suppress_warnings],
+        return_value_results: options[:return_value_results]
+      )
+
+      exit cmd.run
+    rescue => e
+      error "Validation failed: #{e.message}"
+      exit 1
     end
 
     desc "export FONT_FILE", "Export font to TTX/YAML/JSON format"
@@ -555,5 +604,17 @@ module Fontisan
       warn message unless options[:quiet]
       exit 1
     end
+
+    # List available validation tests/profiles
+    #
+    # @return [void]
+    def list_available_tests
+      require_relative "validators/profile_loader"
+      profiles = Validators::ProfileLoader.all_profiles
+      puts "Available validation profiles:"
+      profiles.each do |profile_name, config|
+        puts "  #{profile_name.to_s.ljust(20)} - #{config[:description]}"
+      end
+    end
   end
 end

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

data/lib/fontisan/converters/woff2_encoder.rb

@@ -6,7 +6,8 @@ require_relative "../woff2/directory"
 require_relative "../woff2/table_transformer"
 require_relative "../utilities/brotli_wrapper"
 require_relative "../utilities/checksum_calculator"
-require_relative "../validation/woff2_validator"
+# Validation temporarily disabled - will be reimplemented with new DSL framework in Week 3+
+# require_relative "../validation/woff2_validator"
 require "yaml"
 require "stringio"
 
@@ -111,10 +112,11 @@ module Fontisan
         result = { woff2_binary: woff2_binary }
 
         # Optional validation
-        if options[:validate]
-          validation_report = validate_encoding(woff2_binary, options)
-          result[:validation_report] = validation_report
-        end
+        # Temporarily disabled - will be reimplemented with new DSL framework
+        # if options[:validate]
+        #   validation_report = validate_encoding(woff2_binary, options)
+        #   result[:validation_report] = validation_report
+        # end
 
         result
       end
@@ -162,30 +164,6 @@ module Fontisan
 
       private
 
-      # Validate encoded WOFF2 binary
-      #
-      # @param woff2_binary [String] Encoded WOFF2 data
-      # @param options [Hash] Validation options
-      # @return [Models::ValidationReport] Validation report
-      def validate_encoding(woff2_binary, options)
-        # Load the encoded WOFF2 from memory
-        io = StringIO.new(woff2_binary)
-        woff2_font = Woff2Font.from_file_io(io, "encoded.woff2")
-
-        # Run validation
-        validation_level = options[:validation_level] || :standard
-        validator = Validation::Woff2Validator.new(level: validation_level)
-        validator.validate(woff2_font, "encoded.woff2")
-      rescue StandardError => e
-        # If validation fails, create a report with the error
-        report = Models::ValidationReport.new(
-          font_path: "encoded.woff2",
-          valid: false,
-        )
-        report.add_error("woff2_validation", "Validation failed: #{e.message}", nil)
-        report
-      end
-
       # Helper method to load WOFF2 from StringIO
       #
       # This is added to Woff2Font to support in-memory validation