fontisan 0.2.0 → 0.2.1

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,10 +59,9 @@ 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
 
@@ -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,19 @@ 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 +138,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 +204,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 +260,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,27 @@ 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
+            report.errors << { message: error, category: "variable_font" } if report.respond_to?(:errors)
+          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.

data/lib/fontisan/converters/format_converter.rb

@@ -73,20 +73,50 @@ 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 +167,125 @@ 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

data/lib/fontisan/converters/outline_converter.rb

@@ -153,6 +153,22 @@ module Fontisan
         # Update head table for CFF
         tables["head"] = update_head_for_cff(font)
 
+        # Convert and apply hints if preservation is enabled
+        if @preserve_hints && hints_per_glyph.any?
+          # Extract font-level hints separately
+          hint_set = extract_ttf_hint_set(font)
+
+          unless hint_set.empty?
+            # Convert TrueType hints to PostScript format
+            converter = Hints::HintConverter.new
+            ps_hint_set = converter.convert_hint_set(hint_set, :postscript)
+
+            # Apply PostScript hints (validation mode - CFF modification pending)
+            applier = Hints::PostScriptHintApplier.new
+            tables = applier.apply(ps_hint_set, tables)
+          end
+        end
+
         tables
       end
 
@@ -183,6 +199,22 @@ module Fontisan
         # Update head table for TrueType
         tables["head"] = update_head_for_truetype(font, loca_format)
 
+        # Convert and apply hints if preservation is enabled
+        if @preserve_hints && hints_per_glyph.any?
+          # Extract font-level hints separately
+          hint_set = extract_cff_hint_set(font)
+
+          unless hint_set.empty?
+            # Convert PostScript hints to TrueType format
+            converter = Hints::HintConverter.new
+            tt_hint_set = converter.convert_hint_set(hint_set, :truetype)
+
+            # Apply TrueType hints (writes fpgm/prep/cvt tables)
+            applier = Hints::TrueTypeHintApplier.new
+            tables = applier.apply(tt_hint_set, tables)
+          end
+        end
+
         tables
       end
 
@@ -493,19 +525,8 @@ module Fontisan
             next
           end
 
-          # Convert outline to TrueType contours
-          contours = outline.to_truetype_contours
-
-          # Build glyph data
-          builder = Tables::Glyf::GlyphBuilder.new(
-            contours: contours,
-            x_min: outline.bbox[:x_min],
-            y_min: outline.bbox[:y_min],
-            x_max: outline.bbox[:x_max],
-            y_max: outline.bbox[:y_max],
-          )
-
-          glyph_data = builder.build
+          # Build glyph data using GlyphBuilder class method
+          glyph_data = Fontisan::Tables::GlyphBuilder.build_simple_glyph(outline)
           glyf_data << glyph_data
 
           # Add padding to 4-byte boundary
@@ -835,19 +856,31 @@ module Fontisan
       def validate_source_tables(font, format)
         case format
         when :ttf
-          unless font.has_table?("glyf") && font.has_table?("loca") &&
-              font.table("glyf") && font.table("loca")
+          unless font.has_table?("glyf") && font.has_table?("loca")
+            raise Fontisan::MissingTableError,
+                  "TrueType font missing required glyf or loca table"
+          end
+          # Also verify tables can actually be loaded
+          unless font.table("glyf") && font.table("loca")
             raise Fontisan::MissingTableError,
                   "TrueType font missing required glyf or loca table"
           end
         when :cff2
-          unless font.has_table?("CFF2") && font.table("CFF2")
+          unless font.has_table?("CFF2")
+            raise Fontisan::MissingTableError,
+                  "CFF2 font missing required CFF2 table"
+          end
+          unless font.table("CFF2")
             raise Fontisan::MissingTableError,
                   "CFF2 font missing required CFF2 table"
           end
         when :otf
-          unless (font.has_table?("CFF ") && font.table("CFF ")) ||
-              (font.has_table?("CFF2") && font.table("CFF2"))
+          unless font.has_table?("CFF ") || font.has_table?("CFF2")
+            raise Fontisan::MissingTableError,
+                  "OpenType font missing required CFF or CFF2 table"
+          end
+          # Verify at least one can be loaded
+          unless font.table("CFF ") || font.table("CFF2")
             raise Fontisan::MissingTableError,
                   "OpenType font missing required CFF or CFF2 table"
           end
@@ -855,6 +888,11 @@ module Fontisan
 
         # Common required tables
         %w[head hhea maxp].each do |tag|
+          unless font.has_table?(tag)
+            raise Fontisan::MissingTableError,
+                  "Font missing required #{tag} table"
+          end
+          # Verify table can actually be loaded
           unless font.table(tag)
             raise Fontisan::MissingTableError,
                   "Font missing required #{tag} table"
@@ -924,6 +962,30 @@ module Fontisan
         {}
       end
 
+      # Extract complete TrueType hint set from font
+      #
+      # @param font [TrueTypeFont] Source font
+      # @return [HintSet] Complete hint set
+      def extract_ttf_hint_set(font)
+        extractor = Hints::TrueTypeHintExtractor.new
+        extractor.extract_from_font(font)
+      rescue StandardError => e
+        warn "Failed to extract TrueType hint set: #{e.message}"
+        Models::HintSet.new(format: :truetype)
+      end
+
+      # Extract complete PostScript hint set from font
+      #
+      # @param font [OpenTypeFont] Source font
+      # @return [HintSet] Complete hint set
+      def extract_cff_hint_set(font)
+        extractor = Hints::PostScriptHintExtractor.new
+        extractor.extract_from_font(font)
+      rescue StandardError => e
+        warn "Failed to extract PostScript hint set: #{e.message}"
+        Models::HintSet.new(format: :postscript)
+      end
+
       # Check if font is a variable font
       #
       # @param font [TrueTypeFont, OpenTypeFont] Font to check

data/lib/fontisan/converters/woff_writer.rb

@@ -364,7 +364,7 @@ module Fontisan
         # Sort tables by tag for consistent output (same order as directory)
         sorted_tables = compressed_tables.sort_by { |tag, _| tag }
 
-        sorted_tables.each_value do |table_info|
+        sorted_tables.each do |_tag, table_info|
           io.write(table_info[:compressed_data])
         end
       end

data/lib/fontisan/font_loader.rb

@@ -63,14 +63,12 @@ module Fontisan
         when "OTTO"
           OpenTypeFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "wOFF"
-          raise UnsupportedFormatError,
-                "Unsupported font format: WOFF. Please convert to TTF/OTF first."
+          WoffFont.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         when "wOF2"
-          raise UnsupportedFormatError,
-                "Unsupported font format: WOFF2. Please convert to TTF/OTF first."
+          Woff2Font.from_file(path, mode: resolved_mode, lazy: resolved_lazy)
         else
           raise InvalidFontError,
-                "Unknown font format. Expected TTF, OTF, TTC, or OTC file."
+                "Unknown font format. Expected TTF, OTF, TTC, OTC, WOFF, or WOFF2 file."
         end
       end
     end