fontisan 0.2.0 → 0.2.2

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,62 @@ 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)
+        # Add variation options if specified
+        pipeline_options[:coordinates] = @coordinates if @coordinates
+        pipeline_options[:instance_index] = @instance_index if @instance_index
+        unless @preserve_variation.nil?
+          pipeline_options[:preserve_variation] =
+            @preserve_variation
+        end
 
-        # 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
+        # Add hint preservation option
+        pipeline_options[:preserve_hints] = @preserve_hints if @preserve_hints
 
-          # Determine sfnt version for output
-          sfnt_version = determine_sfnt_version(@target_format)
+        # Use TransformationPipeline for universal conversion
+        pipeline = Pipeline::TransformationPipeline.new(
+          font_path,
+          @output_path,
+          pipeline_options,
+        )
 
-          # Write output font
-          FontWriter.write_to_file(tables, @output_path,
-                                   sfnt_version: sfnt_version)
+        result = pipeline.transform
 
-          # Display optimization results if available
-          display_optimization_results(tables) if @optimize && options[:verbose]
-        end
+        # Display results
+        unless @options[:quiet]
+          output_size = File.size(@output_path)
+          input_size = File.size(font_path)
 
-        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]}"
 
-        puts "Conversion complete!"
-        puts "  Input:  #{font_path} (#{format_size(input_size)})"
-        puts "  Output: #{@output_path} (#{format_size(output_size)})"
+          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
 
         {
           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 +140,28 @@ 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 +175,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 +190,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 +217,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

data/lib/fontisan/commands/info_command.rb

@@ -41,12 +41,70 @@ module Fontisan
 
       # Get collection information
       #
-      # @return [Models::CollectionInfo] Collection metadata
+      # @return [Models::CollectionInfo, Models::CollectionBriefInfo] Collection metadata
       def collection_info
         collection = FontLoader.load_collection(@font_path)
 
         File.open(@font_path, "rb") do |io|
-          collection.collection_info(io, @font_path)
+          if @options[:brief]
+            # Brief mode: load each font and populate brief info
+            brief_info = Models::CollectionBriefInfo.new
+            brief_info.collection_path = @font_path
+            brief_info.num_fonts = collection.num_fonts
+            brief_info.fonts = []
+
+            collection.num_fonts.times do |index|
+              # Load individual font from collection
+              font = FontLoader.load(@font_path, font_index: index, mode: LoadingModes::METADATA)
+
+              # Populate brief info for this font
+              info = Models::FontInfo.new
+
+              # Font format and variable status
+              info.font_format = case font
+                                 when TrueTypeFont
+                                   "truetype"
+                                 when OpenTypeFont
+                                   "cff"
+                                 else
+                                   "unknown"
+                                 end
+              info.is_variable = font.has_table?(Constants::FVAR_TAG)
+
+              # Collection offset (only populated for fonts in collections)
+              info.collection_offset = collection.font_offsets[index]
+
+              # Essential names
+              if font.has_table?(Constants::NAME_TAG)
+                name_table = font.table(Constants::NAME_TAG)
+                info.family_name = name_table.english_name(Tables::Name::FAMILY)
+                info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+                info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+                info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+                info.version = name_table.english_name(Tables::Name::VERSION)
+              end
+
+              # Essential metrics
+              if font.has_table?(Constants::HEAD_TAG)
+                head = font.table(Constants::HEAD_TAG)
+                info.font_revision = head.font_revision
+                info.units_per_em = head.units_per_em
+              end
+
+              # Vendor ID
+              if font.has_table?(Constants::OS2_TAG)
+                os2_table = font.table(Constants::OS2_TAG)
+                info.vendor_id = os2_table.vendor_id
+              end
+
+              brief_info.fonts << info
+            end
+
+            brief_info
+          else
+            # Full mode: show detailed sharing statistics
+            collection.collection_info(io, @font_path)
+          end
         end
       end
 
@@ -56,9 +114,14 @@ module Fontisan
       def font_info
         info = Models::FontInfo.new
         populate_font_format(info)
-        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)
+
+        # In brief mode, only populate essential fields for fast identification
+        if @options[:brief]
+          populate_brief_fields(info)
+        else
+          populate_full_fields(info)
+        end
+
         info
       end
 
@@ -80,6 +143,49 @@ module Fontisan
         info.is_variable = font.has_table?(Constants::FVAR_TAG)
       end
 
+      # Populate essential fields for brief mode (metadata tables only).
+      #
+      # Brief mode provides fast font identification by loading only 13 essential
+      # attributes from metadata tables (name, head, OS/2). This is 5x faster than
+      # full mode and optimized for font indexing systems.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_brief_fields(info)
+        # Essential names from name table
+        if font.has_table?(Constants::NAME_TAG)
+          name_table = font.table(Constants::NAME_TAG)
+          info.family_name = name_table.english_name(Tables::Name::FAMILY)
+          info.subfamily_name = name_table.english_name(Tables::Name::SUBFAMILY)
+          info.full_name = name_table.english_name(Tables::Name::FULL_NAME)
+          info.postscript_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME)
+          info.version = name_table.english_name(Tables::Name::VERSION)
+        end
+
+        # Essential metrics from head table
+        if font.has_table?(Constants::HEAD_TAG)
+          head = font.table(Constants::HEAD_TAG)
+          info.font_revision = head.font_revision
+          info.units_per_em = head.units_per_em
+        end
+
+        # Vendor ID from OS/2 table
+        if font.has_table?(Constants::OS2_TAG)
+          os2_table = font.table(Constants::OS2_TAG)
+          info.vendor_id = os2_table.vendor_id
+        end
+      end
+
+      # Populate all fields for full mode.
+      #
+      # Full mode extracts comprehensive metadata from all available tables.
+      #
+      # @param info [Models::FontInfo] FontInfo instance to populate
+      def populate_full_fields(info)
+        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)
+      end
+
       # Populate FontInfo from the name table.
       #
       # @param info [Models::FontInfo] FontInfo instance to populate