fontisan 0.2.0 → 0.2.2

data/lib/fontisan/commands/instance_command.rb

@@ -2,10 +2,9 @@
 
 require "thor"
 require_relative "base_command"
-require_relative "../variable/instancer"
+require_relative "../variation/instance_generator"
+require_relative "../variation/instance_writer"
 require_relative "../variation/validator"
-require_relative "../variation/parallel_generator"
-require_relative "../converters/format_converter"
 require_relative "../error"
 
 module Fontisan
@@ -20,19 +19,18 @@ module Fontisan
     # - Validation before generation
     # - Dry-run mode for previewing
     # - Progress tracking
-    # - Parallel batch generation
     #
     # @example Instance at coordinates
     #   fontisan instance variable.ttf --wght=700 --output=bold.ttf
     #
+    # @example Instance with format conversion
+    #   fontisan instance variable.ttf --wght=700 --to=otf --output=bold.otf
+    #
     # @example Instance with validation
     #   fontisan instance variable.ttf --wght=700 --validate --output=bold.ttf
     #
     # @example Dry-run to preview
     #   fontisan instance variable.ttf --wght=700 --dry-run
-    #
-    # @example Instance with progress
-    #   fontisan instance variable.ttf --wght=700 --progress --output=bold.ttf
     class InstanceCommand < BaseCommand
       # Instance a variable font at specified coordinates
       #
@@ -44,18 +42,15 @@ module Fontisan
         # Validate font if requested
         validate_font(font) if options[:validate]
 
-        # Create instancer
-        instancer = Variable::Instancer.new(font)
-
         # Handle list-instances option
         if options[:list_instances]
-          list_instances(instancer)
+          list_instances(font)
           return
         end
 
         # Handle dry-run mode
         if options[:dry_run]
-          preview_instance(instancer, options)
+          preview_instance(font, input_path, options)
           return
         end
 
@@ -64,20 +59,19 @@ module Fontisan
 
         # Generate instance
         if options[:named_instance]
-          instance_named(instancer, options[:named_instance], output_path,
-                         options)
+          instance_named(font, options[:named_instance], output_path, options)
         else
-          instance_coords(instancer, extract_coordinates(options), output_path,
+          instance_coords(font, extract_coordinates(options), output_path,
                           options)
         end
 
         puts "Static font instance written to: #{output_path}"
       rescue VariationError => e
-        $stderr.puts "Variation Error: #{e.detailed_message}"
+        warn "Variation Error: #{e.detailed_message}"
         exit 1
       rescue StandardError => e
-        $stderr.puts "Error: #{e.message}"
-        $stderr.puts e.backtrace.first(5).join("\n") if options[:verbose]
+        warn "Error: #{e.message}"
+        warn e.backtrace.first(5).join("\n") if options[:verbose]
         exit 1
       end
 
@@ -93,9 +87,9 @@ module Fontisan
         errors = validator.validate
 
         if errors.any?
-          $stderr.puts "Validation errors found:"
+          warn "Validation errors found:"
           errors.each do |error|
-            $stderr.puts "  - #{error}"
+            warn "  - #{error}"
           end
           exit 1
         end
@@ -105,9 +99,10 @@ module Fontisan
 
       # Preview instance without generating
       #
-      # @param instancer [Variable::Instancer] Instancer object
+      # @param font [Object] Font object
+      # @param input_path [String] Input file path
       # @param options [Hash] Command options
-      def preview_instance(instancer, options)
+      def preview_instance(_font, input_path, options)
         coords = extract_coordinates(options)
 
         if coords.empty?
@@ -122,18 +117,20 @@ module Fontisan
           puts "  #{axis}: #{value}"
         end
         puts
-        puts "Output would be written to: #{determine_output_path(@input_path, options)}"
+        puts "Output would be written to: #{determine_output_path(input_path,
+                                                                  options)}"
+        puts "Output format: #{options[:to] || 'same as input'}"
         puts
         puts "Use without --dry-run to actually generate the instance."
       end
 
       # Instance at specific coordinates
       #
-      # @param instancer [Variable::Instancer] Instancer object
+      # @param font [Object] Font object
       # @param coords [Hash] User coordinates
       # @param output_path [String] Output file path
       # @param options [Hash] Command options
-      def instance_coords(instancer, coords, output_path, options)
+      def instance_coords(font, coords, output_path, options)
         if coords.empty?
           raise ArgumentError,
                 "No coordinates specified. Use --wght=700, --wdth=100, etc."
@@ -142,47 +139,64 @@ module Fontisan
         # Show progress if requested
         print "Generating instance..." if options[:progress]
 
-        # Generate instance
-        binary = instancer.instance(coords)
+        # Generate instance tables using InstanceGenerator
+        generator = Variation::InstanceGenerator.new(font, coords)
+        tables = generator.generate
 
         puts " done" if options[:progress]
 
-        # Convert format if requested
-        if options[:to]
-          print "Converting format..." if options[:progress]
-          binary = convert_format(binary, options)
-          puts " done" if options[:progress]
-        end
-
-        # Write to file
+        # Write instance using InstanceWriter
         print "Writing output..." if options[:progress]
-        File.binwrite(output_path, binary)
+
+        # Detect source format for conversion
+        source_format = detect_source_format(font)
+
+        Variation::InstanceWriter.write(
+          tables,
+          output_path,
+          format: options[:to]&.to_sym,
+          source_format: source_format,
+          optimize: options[:optimize] || false,
+        )
+
         puts " done" if options[:progress]
       end
 
       # Instance using named instance
       #
-      # @param instancer [Variable::Instancer] Instancer object
-      # @param instance_name [String] Named instance name
+      # @param font [Object] Font object
+      # @param instance_index [Integer] Named instance index
       # @param output_path [String] Output file path
       # @param options [Hash] Command options
-      def instance_named(instancer, instance_name, output_path, options)
-        # Generate instance
-        binary = instancer.instance_named(instance_name)
-
-        # Convert format if requested
-        binary = convert_format(binary, options) if options[:to]
-
-        # Write to file
-        File.binwrite(output_path, binary)
+      def instance_named(font, instance_index, output_path, options)
+        # Generate instance using named instance
+        generator = Variation::InstanceGenerator.new(font)
+        tables = generator.generate_named_instance(instance_index)
+
+        # Detect source format
+        source_format = detect_source_format(font)
+
+        # Write instance
+        Variation::InstanceWriter.write(
+          tables,
+          output_path,
+          format: options[:to]&.to_sym,
+          source_format: source_format,
+          optimize: options[:optimize] || false,
+        )
       end
 
       # List available named instances
       #
-      # @param instancer [Variable::Instancer] Instancer object
-      def list_instances(instancer)
-        instances = instancer.named_instances
+      # @param font [Object] Font object
+      def list_instances(font)
+        fvar = font.table("fvar")
+        unless fvar
+          puts "Not a variable font - no named instances available."
+          return
+        end
 
+        instances = fvar.instances
         if instances.empty?
           puts "No named instances defined in font."
           return
@@ -191,11 +205,15 @@ module Fontisan
         puts "Available named instances:"
         puts
 
-        instances.each do |instance|
-          puts "  #{instance[:name]}"
+        instances.each_with_index do |instance, index|
+          name_id = instance[:subfamily_name_id]
+          puts "  [#{index}] Instance #{name_id}"
           puts "    Coordinates:"
-          instance[:coordinates].each do |axis, value|
-            puts "      #{axis}: #{value}"
+          instance[:coordinates].each_with_index do |value, axis_index|
+            next if axis_index >= fvar.axes.length
+
+            axis = fvar.axes[axis_index]
+            puts "      #{axis.axis_tag}: #{value}"
           end
           puts
         end
@@ -243,38 +261,12 @@ module Fontisan
         "#{dir}/#{base}-instance.#{ext}"
       end
 
-      # Convert format using FormatConverter
+      # Detect source format from font
       #
-      # @param binary [String] Font binary
-      # @param options [Hash] Command options
-      # @return [String] Converted binary
-      def convert_format(binary, options)
-        target_format = options[:to].to_sym
-
-        # Load font from binary
-        require "tempfile"
-        Tempfile.create(["instance", ".ttf"]) do |temp_file|
-          temp_file.binmode
-          temp_file.write(binary)
-          temp_file.flush
-
-          font = FontLoader.load(temp_file.path)
-          converter = Converters::FormatConverter.new
-
-          result = converter.convert(font, target_format)
-
-          case target_format
-          when :woff, :woff2
-            result[:font_data]
-          when :svg
-            result[:svg_xml]
-          else
-            binary
-          end
-        end
-      rescue StandardError => e
-        warn "Format conversion failed: #{e.message}"
-        binary
+      # @param font [Object] Font object
+      # @return [Symbol] Source format (:ttf or :otf)
+      def detect_source_format(font)
+        font.has_table?("CFF ") || font.has_table?("CFF2") ? :otf : :ttf
       end
 
       # Load font from file

data/lib/fontisan/commands/validate_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "base_command"
 require_relative "../validation/validator"
+require_relative "../validation/variable_font_validator"
 require_relative "../font_loader"
 
 module Fontisan
@@ -53,6 +54,9 @@ quiet: false)
         # Run validation
         report = validator.validate(font, @input)
 
+        # Add variable font validation if applicable
+        validate_variable_font(font, report) if font.has_table?("fvar")
+
         # Output results unless quiet mode
         output_report(report) unless @quiet
 
@@ -66,6 +70,30 @@ quiet: false)
 
       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
+
+        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"
+        end
+      end
+
       # Validate command parameters
       #
       # @raise [ArgumentError] if parameters are invalid

data/lib/fontisan/config/validation_rules.yml

@@ -23,7 +23,7 @@ required_tables:
 
   # Additional tables required for OpenType/CFF fonts (.otf)
   opentype_cff:
-    - CFF   # or CFF2 for CFF2 format
+    - "CFF "  # or CFF2 for CFF2 format (note: CFF has trailing space per OpenType spec)
 
   # Additional tables required for variable fonts
   variable:

data/lib/fontisan/constants.rb

@@ -87,6 +87,16 @@ module Fontisan
     # CFF2 table tag identifier (CFF version 2 with variations)
     CFF2_TAG = "CFF2"
 
+    # TrueType hinting tables
+    # Font Program table (TrueType bytecode executed once at font load)
+    FPGM_TAG = "fpgm"
+
+    # Control Value Program table (TrueType bytecode for initialization)
+    PREP_TAG = "prep"
+
+    # Control Value Table (metrics used by TrueType hinting)
+    CVT_TAG = "cvt "
+
     # Magic number used for font file checksum adjustment calculation.
     # This constant is used in conjunction with the file checksum to compute
     # the checksumAdjustment value stored in the 'head' table.
@@ -107,30 +117,30 @@ module Fontisan
     # These strings are frozen and reused to reduce memory allocations
     # when parsing fonts with common subfamily names.
     STRING_POOL = {
-      "Regular" => "Regular".freeze,
-      "Bold" => "Bold".freeze,
-      "Italic" => "Italic".freeze,
-      "Bold Italic" => "Bold Italic".freeze,
-      "BoldItalic" => "BoldItalic".freeze,
-      "Light" => "Light".freeze,
-      "Medium" => "Medium".freeze,
-      "Semibold" => "Semibold".freeze,
-      "SemiBold" => "SemiBold".freeze,
-      "Black" => "Black".freeze,
-      "Thin" => "Thin".freeze,
-      "ExtraLight" => "ExtraLight".freeze,
-      "Extra Light" => "Extra Light".freeze,
-      "ExtraBold" => "ExtraBold".freeze,
-      "Extra Bold" => "Extra Bold".freeze,
-      "Heavy" => "Heavy".freeze,
-      "Book" => "Book".freeze,
-      "Roman" => "Roman".freeze,
-      "Normal" => "Normal".freeze,
-      "Oblique" => "Oblique".freeze,
-      "Light Italic" => "Light Italic".freeze,
-      "Medium Italic" => "Medium Italic".freeze,
-      "Semibold Italic" => "Semibold Italic".freeze,
-      "Bold Oblique" => "Bold Oblique".freeze,
+      "Regular" => "Regular",
+      "Bold" => "Bold",
+      "Italic" => "Italic",
+      "Bold Italic" => "Bold Italic",
+      "BoldItalic" => "BoldItalic",
+      "Light" => "Light",
+      "Medium" => "Medium",
+      "Semibold" => "Semibold",
+      "SemiBold" => "SemiBold",
+      "Black" => "Black",
+      "Thin" => "Thin",
+      "ExtraLight" => "ExtraLight",
+      "Extra Light" => "Extra Light",
+      "ExtraBold" => "ExtraBold",
+      "Extra Bold" => "Extra Bold",
+      "Heavy" => "Heavy",
+      "Book" => "Book",
+      "Roman" => "Roman",
+      "Normal" => "Normal",
+      "Oblique" => "Oblique",
+      "Light Italic" => "Light Italic",
+      "Medium Italic" => "Medium Italic",
+      "Semibold Italic" => "Semibold Italic",
+      "Bold Oblique" => "Bold Oblique",
     }.freeze
 
     # Intern a string using the string pool

data/lib/fontisan/converters/format_converter.rb

@@ -73,20 +73,51 @@ module Fontisan
       # @param font [TrueTypeFont, OpenTypeFont] Source font
       # @param target_format [Symbol] Target format (:ttf, :otf, :woff2, :svg)
       # @param options [Hash] Additional conversion options
+      # @option options [Boolean] :preserve_variation Preserve variation data
+      #   (default: true)
+      # @option options [Boolean] :preserve_hints Preserve rendering hints
+      #   (default: false)
+      # @option options [Hash] :instance_coordinates Coordinates for variable→SVG
+      # @option options [Integer] :instance_index Named instance index for variable→SVG
       # @return [Hash<String, String>] Map of table tags to binary data
       # @raise [ArgumentError] If parameters are invalid
       # @raise [Error] If conversion is not supported
       #
       # @example
       #   tables = converter.convert(font, :otf)
+      #
+      # @example Variable font to SVG at specific weight
+      #   result = converter.convert(variable_font, :svg, instance_coordinates: { "wght" => 700.0 })
+      #
+      # @example Convert with hint preservation
+      #   tables = converter.convert(font, :otf, preserve_hints: true)
       def convert(font, target_format, options = {})
         validate_parameters!(font, target_format)
 
         source_format = detect_format(font)
         validate_conversion_supported!(source_format, target_format)
 
+        # Special case: Variable font to SVG
+        if variable_font?(font) && target_format == :svg
+          return convert_variable_to_svg(font, options)
+        end
+
         strategy = select_strategy(source_format, target_format)
-        strategy.convert(font, options.merge(target_format: target_format))
+        tables = strategy.convert(font,
+                                  options.merge(target_format: target_format))
+
+        # Preserve variation data if requested and font is variable
+        if options.fetch(:preserve_variation, true) && variable_font?(font)
+          tables = preserve_variation_data(
+            font,
+            tables,
+            source_format,
+            target_format,
+            options,
+          )
+        end
+
+        tables
       end
 
       # Check if a conversion is supported
@@ -137,6 +168,128 @@ module Fontisan
 
       private
 
+      # Convert variable font to SVG at specific coordinates
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Variable font
+      # @param options [Hash] Conversion options
+      # @option options [Hash] :instance_coordinates Design space coordinates
+      # @option options [Integer] :instance_index Named instance index
+      # @return [Hash] Hash with :svg_xml key
+      def convert_variable_to_svg(font, options = {})
+        require_relative "../variation/variable_svg_generator"
+
+        coordinates = options[:instance_coordinates] || {}
+        generator = Variation::VariableSvgGenerator.new(font, coordinates)
+
+        # Use named instance if specified
+        if options[:instance_index]
+          generator.generate_named_instance(options[:instance_index], options)
+        else
+          generator.generate(options)
+        end
+      end
+
+      # Check if font is a variable font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Font to check
+      # @return [Boolean] True if font has fvar table
+      def variable_font?(font)
+        font.has_table?("fvar")
+      end
+
+      # Preserve variation data from source to target
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Source font
+      # @param tables [Hash<String, String>] Target tables
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @param options [Hash] Preservation options
+      # @return [Hash<String, String>] Tables with variation preserved
+      def preserve_variation_data(font, tables, source_format, target_format,
+options)
+        # Case 1: Compatible formats (same outline format) - just copy tables
+        if compatible_variation_formats?(source_format, target_format)
+          require_relative "../variation/variation_preserver"
+          Variation::VariationPreserver.preserve(font, tables, options)
+
+        # Case 2: Different outline formats - convert variation data
+        elsif convertible_variation_formats?(source_format, target_format)
+          convert_variation_data(font, tables, source_format, target_format,
+                                 options)
+
+        # Case 3: Unsupported conversion
+        else
+          if options[:preserve_variation]
+            raise Fontisan::Error,
+                  "Cannot preserve variation data for " \
+                  "#{source_format} → #{target_format}"
+          end
+          tables
+        end
+      end
+
+      # Check if formats have compatible variation (same outline format)
+      #
+      # @param source [Symbol] Source format
+      # @param target [Symbol] Target format
+      # @return [Boolean] True if compatible
+      def compatible_variation_formats?(source, target)
+        # Same format (copy operation)
+        return true if source == target
+
+        # Same outline format (just packaging change)
+        (source == :ttf && target == :woff) ||
+          (source == :otf && target == :woff) ||
+          (source == :woff && target == :ttf) ||
+          (source == :woff && target == :otf) ||
+          (source == :ttf && target == :woff2) ||
+          (source == :otf && target == :woff2)
+      end
+
+      # Check if formats allow variation conversion (different outline formats)
+      #
+      # @param source [Symbol] Source format
+      # @param target [Symbol] Target format
+      # @return [Boolean] True if convertible
+      def convertible_variation_formats?(source, target)
+        # Different outline formats (need variation conversion)
+        (source == :ttf && target == :otf) ||
+          (source == :otf && target == :ttf)
+      end
+
+      # Convert variation data between outline formats
+      #
+      # This is a placeholder for full TTF↔OTF variation conversion.
+      # Full implementation would:
+      # 1. Use Variation::Converter to convert gvar ↔ CFF2 blend
+      # 2. Build appropriate variation tables for target format
+      # 3. Preserve common tables (fvar, avar, STAT, metrics)
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Source font
+      # @param tables [Hash<String, String>] Target tables
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @param options [Hash] Conversion options
+      # @return [Hash<String, String>] Tables with converted variation
+      def convert_variation_data(font, tables, source_format, target_format,
+_options)
+        require_relative "../variation/variation_preserver"
+        require_relative "../variation/converter"
+
+        # For now, just preserve common tables and warn about conversion
+        warn "WARNING: Full variation conversion (#{source_format} → " \
+             "#{target_format}) not yet implemented. " \
+             "Preserving common variation tables only."
+
+        # Preserve common tables (fvar, avar, STAT) but not format-specific
+        Variation::VariationPreserver.preserve(
+          font,
+          tables,
+          preserve_format_specific: false,
+          preserve_metrics: true,
+        )
+      end
+
       # Load conversion matrix from YAML config
       #
       # @param path [String, nil] Path to config file