fontisan 0.2.3 → 0.2.5

data/lib/fontisan/commands/base_command.rb

@@ -58,30 +58,13 @@ module Fontisan
       # Load the font using FontLoader.
       #
       # Uses FontLoader for automatic format detection and loading.
-      # Returns either TrueTypeFont or OpenTypeFont depending on file format.
+      # Returns TrueTypeFont, OpenTypeFont, WoffFont, or Woff2Font depending on file format.
       #
-      # @return [TrueTypeFont, OpenTypeFont] The loaded font
+      # @return [TrueTypeFont, OpenTypeFont, WoffFont, Woff2Font] The loaded font
       # @raise [Errno::ENOENT] if file does not exist
-      # @raise [UnsupportedFormatError] for WOFF/WOFF2 or other unsupported formats
       # @raise [InvalidFontError] for corrupted or unknown formats
       # @raise [Error] for other loading failures
       def load_font
-        # BaseCommand is for inspection - reject compressed formats first
-        # Check file signature before attempting to load
-        File.open(@font_path, "rb") do |io|
-          signature = io.read(4)
-
-          if signature == "wOFF"
-            raise UnsupportedFormatError,
-                  "Unsupported font format: WOFF files must be decompressed first. " \
-                  "Use ConvertCommand to convert WOFF to TTF/OTF."
-          elsif signature == "wOF2"
-            raise UnsupportedFormatError,
-                  "Unsupported font format: WOFF2 files must be decompressed first. " \
-                  "Use ConvertCommand to convert WOFF2 to TTF/OTF."
-          end
-        end
-
         # Brief mode uses metadata loading for 5x faster parsing
         mode = @options[:brief] ? LoadingModes::METADATA : (@options[:mode] || LoadingModes::FULL)
 

data/lib/fontisan/commands/convert_command.rb

@@ -51,22 +51,26 @@ module Fontisan
       # @option options [Boolean] :verbose Verbose output
       def initialize(font_path, options = {})
         super(font_path, options)
-        @output_path = options[:output]
+
+        # Convert string keys to symbols for Thor compatibility
+        opts = options.transform_keys(&:to_sym)
+
+        @output_path = opts[:output]
 
         # Parse target format
-        @target_format = parse_target_format(options[:to])
+        @target_format = parse_target_format(opts[:to])
 
         # Parse coordinates if string provided
-        @coordinates = if options[:coordinates]
-                         parse_coordinates(options[:coordinates])
-                       elsif options[:instance_coordinates]
-                         options[:instance_coordinates]
+        @coordinates = if opts[:coordinates]
+                         parse_coordinates(opts[:coordinates])
+                       elsif opts[:instance_coordinates]
+                         opts[:instance_coordinates]
                        end
 
-        @instance_index = options[:instance_index]
-        @preserve_variation = options[:preserve_variation]
-        @preserve_hints = options.fetch(:preserve_hints, false)
-        @validate = !options[:no_validate]
+        @instance_index = opts[:instance_index]
+        @preserve_variation = opts[:preserve_variation]
+        @preserve_hints = opts.fetch(:preserve_hints, false)
+        @validate = !opts[:no_validate]
       end
 
       # Execute the conversion
@@ -193,14 +197,13 @@ module Fontisan
         when "svg"
           :svg
         when "woff"
-          raise ArgumentError,
-                "WOFF format conversion is not supported yet. Use woff2 instead."
+          :woff
         when "woff2"
           :woff2
         else
           raise ArgumentError,
                 "Unknown target format: #{format}. " \
-                "Supported: ttf, otf, svg, woff2"
+                "Supported: ttf, otf, svg, woff, woff2"
         end
       end
 

data/lib/fontisan/commands/info_command.rb

@@ -202,6 +202,9 @@ module Fontisan
         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)
+        populate_color_info(info) if font.has_table?("COLR") && font.has_table?("CPAL")
+        populate_svg_info(info) if font.has_table?("SVG ")
+        populate_bitmap_info(info) if font.has_table?("CBLC") || font.has_table?("sbix")
       end
 
       # Populate FontInfo from the name table.
@@ -255,6 +258,91 @@ module Fontisan
         info.units_per_em = head_table.units_per_em
       end
 
+      # Populate FontInfo with color font information from COLR/CPAL tables
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_color_info(info)
+        colr_table = font.table("COLR")
+        cpal_table = font.table("CPAL")
+
+        return unless colr_table && cpal_table
+
+        info.is_color_font = true
+        info.color_glyphs = colr_table.num_color_glyphs
+        info.color_palettes = cpal_table.num_palettes
+        info.colors_per_palette = cpal_table.num_palette_entries
+      rescue StandardError => e
+        warn "Failed to populate color font info: #{e.message}"
+        info.is_color_font = false
+      end
+
+      # Populate FontInfo with SVG table information
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_svg_info(info)
+        svg_table = font.table("SVG ")
+
+        return unless svg_table
+
+        info.has_svg_table = true
+        info.svg_glyph_count = svg_table.glyph_ids_with_svg.length
+      rescue StandardError => e
+        warn "Failed to populate SVG info: #{e.message}"
+        info.has_svg_table = false
+      end
+
+      # Populate FontInfo with bitmap table information (CBDT/CBLC, sbix)
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_bitmap_info(info)
+        bitmap_strikes = []
+        ppem_sizes = []
+        formats = []
+
+        # Check for CBDT/CBLC (Google format)
+        if font.has_table?("CBLC") && font.has_table?("CBDT")
+          cblc = font.table("CBLC")
+          info.has_bitmap_glyphs = true
+          ppem_sizes.concat(cblc.ppem_sizes)
+
+          cblc.strikes.each do |strike_rec|
+            bitmap_strikes << Models::BitmapStrike.new(
+              ppem: strike_rec.ppem,
+              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
+            )
+          end
+          formats << "PNG" # CBDT typically contains PNG data
+        end
+
+        # Check for sbix (Apple format)
+        if font.has_table?("sbix")
+          sbix = font.table("sbix")
+          info.has_bitmap_glyphs = true
+          ppem_sizes.concat(sbix.ppem_sizes)
+          formats.concat(sbix.supported_formats)
+
+          sbix.strikes.each do |strike|
+            bitmap_strikes << Models::BitmapStrike.new(
+              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]
+            )
+          end
+        end
+
+        info.bitmap_strikes = bitmap_strikes unless bitmap_strikes.empty?
+        info.bitmap_ppem_sizes = ppem_sizes.uniq.sort
+        info.bitmap_formats = formats.uniq
+      rescue StandardError => e
+        warn "Failed to populate bitmap info: #{e.message}"
+        info.has_bitmap_glyphs = false
+      end
+
       # Format OS/2 embedding permission flags into a human-readable string.
       #
       # @param flags [Integer] OS/2 fsType flags

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/config/conversion_matrix.yml

@@ -78,26 +78,34 @@ conversions:
       are architectural placeholders for future optimization.
 
   # Phase 2 conversions (Milestone 2.3) - WOFF
-  # NOTE: Temporarily disabled until WOFF writer bugs are fixed
-  # - from: ttf
-  #   to: woff
-  #   strategy: woff_writer
-  #   description: "Compress TrueType to WOFF format with zlib"
-  #   status: implemented
-  #   notes: >
-  #     WOFF 1.0 encoding with zlib compression. Supports optional metadata
-  #     and private data blocks. Individual table compression for optimal
-  #     file size reduction.
-
-  # - from: otf
-  #   to: woff
-  #   strategy: woff_writer
-  #   description: "Compress OpenType/CFF to WOFF format with zlib"
-  #   status: implemented
-  #   notes: >
-  #     WOFF 1.0 encoding with zlib compression. Supports optional metadata
-  #     and private data blocks. Individual table compression for optimal
-  #     file size reduction.
+  - from: ttf
+    to: woff
+    strategy: woff_writer
+    description: "Compress TrueType to WOFF format with zlib"
+    status: implemented
+    notes: >
+      WOFF 1.0 encoding with zlib compression. Supports optional metadata
+      and private data blocks. Individual table compression for optimal
+      file size reduction.
+
+  - from: otf
+    to: woff
+    strategy: woff_writer
+    description: "Compress OpenType/CFF to WOFF format with zlib"
+    status: implemented
+    notes: >
+      WOFF 1.0 encoding with zlib compression. Supports optional metadata
+      and private data blocks. Individual table compression for optimal
+      file size reduction.
+
+  - from: woff
+    to: woff
+    strategy: woff_recompress
+    description: "Copy WOFF font with re-compression"
+    status: implemented
+    notes: >
+      Same-format copy operation. Decompresses and re-compresses WOFF data,
+      useful for normalizing compression or updating metadata.
 
   # Reverse WOFF conversions (WOFF → TTF/OTF)
   - from: woff
@@ -139,6 +147,36 @@ conversions:
       transformation. Note: SVG fonts are deprecated in favor of WOFF2, but
       useful for fallback, conversion, and inspection purposes.
 
+  # WOFF2 decompression (reverse conversions)
+  - from: woff2
+    to: ttf
+    strategy: woff2_decoder
+    description: "Decompress WOFF2 to TrueType format"
+    status: implemented
+    notes: >
+      WOFF2 decompression with Brotli. Reverses table transformations
+      (glyf/loca, hmtx) if present. Preserves all font data and metadata.
+      Automatically detects font flavor from WOFF2 header.
+
+  - from: woff2
+    to: otf
+    strategy: woff2_decoder
+    description: "Decompress WOFF2 to OpenType/CFF format"
+    status: implemented
+    notes: >
+      WOFF2 decompression with Brotli. Reverses table transformations
+      if present. Preserves all font data and metadata. Automatically
+      detects font flavor from WOFF2 header.
+
+  - from: woff2
+    to: woff2
+    strategy: woff2_recompress
+    description: "Copy WOFF2 font with re-compression"
+    status: implemented
+    notes: >
+      Same-format copy operation. Decompresses and re-compresses WOFF2 data
+      with Brotli, useful for normalizing compression or updating metadata.
+
 # Conversion compatibility matrix
 #
 # This section documents which source features are preserved in conversions.

data/lib/fontisan/converters/outline_converter.rb

@@ -415,11 +415,14 @@ module Fontisan
           # If we have local subroutines, add Subrs offset
           # Subrs offset is relative to Private DICT start
           if local_subrs.any?
-            # Calculate size of Private DICT itself to know where Subrs starts
+            # Add a placeholder Subrs offset first to get accurate size
+            private_dict_hash[:subrs] = 0
+
+            # Calculate size of Private DICT with Subrs entry
             temp_private_dict_data = Tables::Cff::DictBuilder.build(private_dict_hash)
             subrs_offset = temp_private_dict_data.bytesize
 
-            # Add Subrs offset to DICT
+            # Update with actual Subrs offset
             private_dict_hash[:subrs] = subrs_offset
           end
 
@@ -729,7 +732,7 @@ module Fontisan
           if glyph_patterns.empty?
             charstring
           else
-            rewriter.rewrite(charstring, glyph_patterns)
+            rewriter.rewrite(charstring, glyph_patterns, glyph_id)
           end
         end
 

data/lib/fontisan/converters/svg_generator.rb

@@ -99,6 +99,51 @@ module Fontisan
 
       private
 
+      # Generate SVG for a color glyph from COLR/CPAL tables
+      #
+      # @param glyph_id [Integer] Glyph ID
+      # @param colr_table [Tables::Colr] COLR table
+      # @param cpal_table [Tables::Cpal] CPAL table
+      # @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)
+        # Get layers for this glyph
+        layers = colr_table.layers_for_glyph(glyph_id)
+        return nil if layers.empty?
+
+        # Get palette colors
+        palette = cpal_table.palette(palette_index)
+        return nil unless palette
+
+        # Generate SVG for each layer
+        svg_paths = []
+        layers.each do |layer|
+          # Get outline for layer glyph
+          outline = extractor.extract(layer.glyph_id)
+          next unless outline
+
+          # Get color for this layer
+          color = if layer.uses_foreground_color?
+                    "currentColor" # Use CSS currentColor for foreground
+                  else
+                    palette[layer.palette_index] || "#000000FF"
+                  end
+
+          # Convert outline to SVG path
+          path_data = outline.to_svg_path
+          next if path_data.empty?
+
+          # Create colored path element
+          svg_paths << %(<path d="#{path_data}" fill="#{color}" />)
+        end
+
+        svg_paths.empty? ? nil : svg_paths.join("\n")
+      rescue StandardError => e
+        warn "Failed to generate color glyph #{glyph_id}: #{e.message}"
+        nil
+      end
+
       # Extract glyph data from font
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font