fontisan 0.2.0 → 0.2.1

data/lib/fontisan/collection/table_deduplicator.rb

@@ -15,6 +15,12 @@ module Fontisan
     #   sharing_map = deduplicator.build_sharing_map
     #   canonical_tables = deduplicator.canonical_tables
     class TableDeduplicator
+      # Tables that can be shared in variable font collections if identical
+      VARIATION_SHAREABLE_TABLES = %w[fvar avar STAT HVAR VVAR MVAR].freeze
+
+      # Tables that must remain font-specific in variable fonts
+      VARIATION_FONT_SPECIFIC_TABLES = %w[gvar CFF2].freeze
+
       # Canonical tables (unique table data)
       # @return [Hash<String, Hash>] Map of table tag to canonical versions
       attr_reader :canonical_tables
@@ -62,6 +68,9 @@ module Fontisan
         # First pass: collect all unique tables
         collect_canonical_tables
 
+        # Handle variable font table deduplication
+        deduplicate_variation_tables if has_variable_fonts?
+
         # Second pass: build sharing map for each font
         build_font_sharing_references
 
@@ -115,6 +124,73 @@ module Fontisan
 
       private
 
+      # Check if any font is a variable font
+      #
+      # @return [Boolean] true if any font has fvar table
+      def has_variable_fonts?
+        @fonts.any? { |font| font.has_table?("fvar") }
+      end
+
+      # Deduplicate variable font tables
+      #
+      # Handles special logic for variable font tables:
+      # - Share tables that are identical across fonts (fvar, avar, etc.)
+      # - Keep font-specific tables separate (gvar, CFF2)
+      #
+      # @return [void]
+      def deduplicate_variation_tables
+        # Share tables that are identical across fonts
+        VARIATION_SHAREABLE_TABLES.each do |tag|
+          share_if_identical(tag)
+        end
+
+        # Never share font-specific variation tables
+        VARIATION_FONT_SPECIFIC_TABLES.each do |tag|
+          keep_separate(tag)
+        end
+      end
+
+      # Share table if identical across all fonts that have it
+      #
+      # @param tag [String] Table tag
+      # @return [void]
+      def share_if_identical(tag)
+        # Get all instances of this table
+        tables = @fonts.map { |f| f.table_data[tag] }.compact
+        return if tables.empty?
+
+        # Check if all instances are identical
+        nil if tables.uniq.length > 1
+
+        # All instances are identical, mark as shareable
+        # The normal deduplication logic will handle this
+      end
+
+      # Ensure table stays separate for each font
+      #
+      # @param tag [String] Table tag
+      # @return [void]
+      def keep_separate(tag)
+        # Mark each font's instance as non-shareable
+        @fonts.each_with_index do |font, _font_index|
+          next unless font.has_table?(tag)
+
+          # Find this font's canonical table for this tag
+          table_data = font.table_data[tag]
+          checksum = calculate_checksum(table_data)
+
+          # Ensure canonical table exists
+          @canonical_tables[tag] ||= {}
+          canonical_id = @checksum_to_canonical.dig(tag, checksum)
+
+          next unless canonical_id && @canonical_tables[tag][canonical_id]
+
+          # Mark as non-shareable
+          @canonical_tables[tag][canonical_id][:shared] = false
+          @canonical_tables[tag][canonical_id][:font_specific] = true
+        end
+      end
+
       # Collect all unique (canonical) tables across all fonts
       #
       # Identifies unique table content based on checksum and stores one

data/lib/fontisan/commands/base_command.rb

@@ -66,6 +66,22 @@ module Fontisan
       # @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
+
         # ConvertCommand and similar commands need all tables loaded upfront
         # Use mode and lazy from options, or sensible defaults
         FontLoader.load(

data/lib/fontisan/commands/convert_command.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
 require_relative "base_command"
-require_relative "../converters/format_converter"
-require_relative "../font_writer"
+require_relative "../pipeline/transformation_pipeline"
 
 module Fontisan
   module Commands
     # Command for converting fonts between formats
     #
     # [`ConvertCommand`](lib/fontisan/commands/convert_command.rb) provides
-    # CLI interface for font format conversion operations. It supports:
+    # CLI interface for font format conversion operations using the universal
+    # transformation pipeline. It supports:
     # - Same-format operations (copy/optimize)
-    # - TTF ↔ OTF outline format conversion (foundation)
-    # - Future: WOFF/WOFF2 compression, SVG export
+    # - TTF ↔ OTF outline format conversion
+    # - Variable font operations (preserve/instance generation)
+    # - WOFF/WOFF2 compression
     #
-    # The command uses [`FormatConverter`](lib/fontisan/converters/format_converter.rb)
+    # The command uses [`TransformationPipeline`](lib/fontisan/pipeline/transformation_pipeline.rb)
     # to orchestrate conversions with appropriate strategies.
     #
     # @example Convert TTF to OTF
@@ -25,11 +26,12 @@ module Fontisan
     #   )
     #   command.run
     #
-    # @example Copy/optimize same format
+    # @example Generate instance at coordinates
     #   command = ConvertCommand.new(
-    #     'input.ttf',
+    #     'variable.ttf',
     #     to: 'ttf',
-    #     output: 'optimized.ttf'
+    #     output: 'bold.ttf',
+    #     coordinates: 'wght=700,wdth=100'
     #   )
     #   command.run
     class ConvertCommand < BaseCommand
@@ -37,24 +39,34 @@ module Fontisan
       #
       # @param font_path [String] Path to input font file
       # @param options [Hash] Conversion options
-      # @option options [String] :to Target format (ttf, otf, woff2, svg)
+      # @option options [String] :to Target format (ttf, otf, woff, woff2)
       # @option options [String] :output Output file path (required)
       # @option options [Integer] :font_index Index for TTC/OTC (default: 0)
-      # @option options [Boolean] :optimize Enable subroutine optimization (TTF→OTF only)
-      # @option options [Integer] :min_pattern_length Minimum pattern length for subroutines
-      # @option options [Integer] :max_subroutines Maximum number of subroutines
-      # @option options [Boolean] :optimize_ordering Optimize subroutine ordering
+      # @option options [String] :coordinates Coordinate string (e.g., "wght=700,wdth=100")
+      # @option options [Hash] :instance_coordinates Axis coordinates hash (e.g., {"wght" => 700.0})
+      # @option options [Integer] :instance_index Named instance index
+      # @option options [Boolean] :preserve_variation Preserve variation data (default: auto)
+      # @option options [Boolean] :preserve_hints Preserve rendering hints (default: false)
+      # @option options [Boolean] :no_validate Skip output validation
+      # @option options [Boolean] :verbose Verbose output
       def initialize(font_path, options = {})
         super(font_path, options)
-        @target_format = parse_target_format(options[:to])
         @output_path = options[:output]
-        @converter = Converters::FormatConverter.new
 
-        # Optimization options
-        @optimize = options[:optimize] || false
-        @min_pattern_length = options[:min_pattern_length] || 10
-        @max_subroutines = options[:max_subroutines] || 65_535
-        @optimize_ordering = options[:optimize_ordering] != false
+        # Parse target format
+        @target_format = parse_target_format(options[:to])
+
+        # Parse coordinates if string provided
+        @coordinates = if options[:coordinates]
+                         parse_coordinates(options[:coordinates])
+                       elsif options[:instance_coordinates]
+                         options[:instance_coordinates]
+                       end
+
+        @instance_index = options[:instance_index]
+        @preserve_variation = options[:preserve_variation]
+        @preserve_hints = options.fetch(:preserve_hints, false)
+        @validate = !options[:no_validate]
       end
 
       # Execute the conversion
@@ -65,65 +77,59 @@ module Fontisan
       def run
         validate_options!
 
-        puts "Converting #{File.basename(font_path)} to #{@target_format}..."
+        puts "Converting #{File.basename(font_path)} to #{@target_format}..." unless @options[:quiet]
 
-        # Build converter options
-        converter_options = {
+        # Build pipeline options
+        pipeline_options = {
           target_format: @target_format,
-          optimize_subroutines: @optimize,
-          min_pattern_length: @min_pattern_length,
-          max_subroutines: @max_subroutines,
-          optimize_ordering: @optimize_ordering,
-          verbose: options[:verbose],
+          validate: @validate,
+          verbose: @options[:verbose],
         }
 
-        # Perform conversion with options
-        result = @converter.convert(font, @target_format, converter_options)
-
-        # Handle special formats that return complete binary/text
-        if @target_format == :woff && result.is_a?(String)
-          # WOFF returns complete binary
-          File.binwrite(@output_path, result)
-        elsif @target_format == :woff2 && result.is_a?(Hash) && result[:woff2_binary]
-          File.binwrite(@output_path, result[:woff2_binary])
-        elsif @target_format == :svg && result.is_a?(Hash) && result[:svg_xml]
-          File.write(@output_path, result[:svg_xml])
-        else
-          # Standard table-based conversion
-          tables = result
-
-          # Determine sfnt version for output
-          sfnt_version = determine_sfnt_version(@target_format)
-
-          # Write output font
-          FontWriter.write_to_file(tables, @output_path,
-                                   sfnt_version: sfnt_version)
-
-          # Display optimization results if available
-          display_optimization_results(tables) if @optimize && options[:verbose]
+        # Add variation options if specified
+        pipeline_options[:coordinates] = @coordinates if @coordinates
+        pipeline_options[:instance_index] = @instance_index if @instance_index
+        pipeline_options[:preserve_variation] = @preserve_variation unless @preserve_variation.nil?
+
+        # Add hint preservation option
+        pipeline_options[:preserve_hints] = @preserve_hints if @preserve_hints
+
+        # Use TransformationPipeline for universal conversion
+        pipeline = Pipeline::TransformationPipeline.new(
+          font_path,
+          @output_path,
+          pipeline_options,
+        )
+
+        result = pipeline.transform
+
+        # Display results
+        unless @options[:quiet]
+          output_size = File.size(@output_path)
+          input_size = File.size(font_path)
+
+          puts "Conversion complete!"
+          puts "  Input:  #{font_path} (#{format_size(input_size)})"
+          puts "  Output: #{@output_path} (#{format_size(output_size)})"
+          puts "  Format: #{result[:details][:source_format]} → #{result[:details][:target_format]}"
+
+          if result[:details][:variation_preserved]
+            puts "  Variation: Preserved (#{result[:details][:variation_strategy]})"
+          elsif result[:details][:variation_strategy] != :preserve
+            puts "  Variation: Instance generated (#{result[:details][:variation_strategy]})"
+          end
         end
 
-        output_size = File.size(@output_path)
-        input_size = File.size(font_path)
-
-        puts "Conversion complete!"
-        puts "  Input:  #{font_path} (#{format_size(input_size)})"
-        puts "  Output: #{@output_path} (#{format_size(output_size)})"
-
         {
           success: true,
           input_path: font_path,
           output_path: @output_path,
-          source_format: detect_source_format,
-          target_format: @target_format,
-          input_size: input_size,
-          output_size: output_size,
+          source_format: result[:details][:source_format],
+          target_format: result[:details][:target_format],
+          input_size: File.size(font_path),
+          output_size: File.size(@output_path),
+          variation_strategy: result[:details][:variation_strategy],
         }
-      rescue NotImplementedError
-        # Let NotImplementedError propagate for tests that expect it
-        raise
-      rescue Converters::ConversionStrategy => e
-        handle_conversion_error(e)
       rescue ArgumentError
         # Let ArgumentError propagate for validation errors
         raise
@@ -131,26 +137,27 @@ module Fontisan
         raise Error, "Conversion failed: #{e.message}"
       end
 
-      # Get list of supported conversions
-      #
-      # @return [Array<Hash>] List of supported conversions
-      def self.supported_conversions
-        converter = Converters::FormatConverter.new
-        converter.all_conversions
-      end
+      private
 
-      # Check if a conversion is supported
+      # Parse coordinates string to hash
+      #
+      # Parses strings like "wght=700,wdth=100" into {"wght" => 700.0, "wdth" => 100.0}
       #
-      # @param source [Symbol] Source format
-      # @param target [Symbol] Target format
-      # @return [Boolean] True if supported
-      def self.supported?(source, target)
-        converter = Converters::FormatConverter.new
-        converter.supported?(source, target)
+      # @param coord_string [String] Coordinate string
+      # @return [Hash] Parsed coordinates
+      def parse_coordinates(coord_string)
+        coords = {}
+        coord_string.split(",").each do |pair|
+          key, value = pair.split("=")
+          next unless key && value
+
+          coords[key.strip] = value.to_f
+        end
+        coords
+      rescue StandardError => e
+        raise ArgumentError, "Invalid coordinates format '#{coord_string}': #{e.message}"
       end
 
-      private
-
       # Validate command options
       #
       # @raise [ArgumentError] If required options are missing
@@ -164,18 +171,6 @@ module Fontisan
           raise ArgumentError,
                 "Target format is required. Use --to option."
         end
-
-        # Check if conversion is supported
-        source_format = detect_source_format
-        unless @converter.supported?(source_format, @target_format)
-          available = @converter.supported_targets(source_format)
-          message = "Conversion from #{source_format} to #{@target_format} " \
-                    "is not supported."
-          if available.any?
-            message += " Available targets: #{available.join(', ')}"
-          end
-          raise ArgumentError, message
-        end
       end
 
       # Parse target format from string/symbol
@@ -191,46 +186,17 @@ module Fontisan
           :ttf
         when "otf", "opentype", "cff"
           :otf
+        when "svg"
+          :svg
         when "woff"
-          :woff
+          raise ArgumentError,
+                "WOFF format conversion is not supported yet. Use woff2 instead."
         when "woff2"
           :woff2
-        when "svg"
-          :svg
         else
           raise ArgumentError,
                 "Unknown target format: #{format}. " \
-                "Supported: ttf, otf, woff2, svg"
-        end
-      end
-
-      # Detect source font format
-      #
-      # @return [Symbol] Source format
-      def detect_source_format
-        # Check for CFF/CFF2 tables (OpenType/CFF)
-        if font.has_table?("CFF ") || font.has_table?("CFF2")
-          :otf
-        # Check for glyf table (TrueType)
-        elsif font.has_table?("glyf")
-          :ttf
-        else
-          :unknown
-        end
-      end
-
-      # Determine sfnt version for target format
-      #
-      # @param format [Symbol] Target format
-      # @return [Integer] sfnt version
-      def determine_sfnt_version(format)
-        case format
-        when :otf
-          0x4F54544F # 'OTTO' for OpenType/CFF
-        when :ttf
-          0x00010000 # 1.0 for TrueType
-        else
-          0x00010000 # Default to TrueType
+                "Supported: ttf, otf, svg, woff2"
         end
       end
 
@@ -247,45 +213,6 @@ module Fontisan
           "#{(bytes / (1024.0 * 1024)).round(1)} MB"
         end
       end
-
-      # Handle conversion errors with helpful messages
-      #
-      # @param error [StandardError] The error that occurred
-      # @raise [Error] Wrapped error with helpful message
-      def handle_conversion_error(error)
-        message = "Conversion failed: #{error.message}"
-
-        # Add helpful hints based on error type
-        if error.is_a?(NotImplementedError)
-          message += "\n\nNote: Some conversions are not yet fully " \
-                     "implemented. Check the conversion matrix configuration " \
-                     "for implementation status."
-        end
-
-        raise Error, message
-      end
-
-      # Display optimization results from subroutine generation
-      #
-      # @param tables [Hash] Table data with optimization metadata
-      def display_optimization_results(tables)
-        optimization = tables.instance_variable_get(:@subroutine_optimization)
-        return unless optimization
-
-        puts "\n=== Subroutine Optimization Results ==="
-        puts "  Patterns found: #{optimization[:pattern_count]}"
-        puts "  Patterns selected: #{optimization[:selected_count]}"
-        puts "  Subroutines generated: #{optimization[:local_subrs].length}"
-        puts "  Estimated bytes saved: #{optimization[:savings]}"
-        puts "  CFF bias: #{optimization[:bias]}"
-
-        if optimization[:selected_count].zero?
-          puts "  Note: No beneficial patterns found for optimization"
-        elsif optimization[:savings].positive?
-          savings_kb = (optimization[:savings] / 1024.0).round(1)
-          puts "  Estimated space savings: #{savings_kb} KB"
-        end
-      end
     end
   end
 end