fontisan 0.2.0 → 0.2.1

data/lib/fontisan/variation/converter.rb

@@ -24,13 +24,13 @@ module Fontisan
     # 4. Build gvar table structure
     #
     # @example Converting gvar to CFF2 blend
-    #   converter = VariationConverter.new(font, axes)
+    #   converter = Converter.new(font, axes)
     #   blend_data = converter.gvar_to_blend(glyph_id)
     #
     # @example Converting CFF2 blend to gvar
-    #   converter = VariationConverter.new(font, axes)
+    #   converter = Converter.new(font, axes)
     #   tuple_data = converter.blend_to_gvar(glyph_id)
-    class VariationConverter
+    class Converter
       include TableAccessor
 
       # @return [TrueTypeFont, OpenTypeFont] Font instance
@@ -72,19 +72,49 @@ module Fontisan
       #
       # @param glyph_id [Integer] Glyph ID
       # @return [Hash, nil] Tuple data or nil
-      def blend_to_gvar(_glyph_id)
+      def blend_to_gvar(glyph_id)
         return nil unless has_variation_table?("CFF2")
 
         cff2 = variation_table("CFF2")
         return nil unless cff2
 
         # Get CharString with blend operators
-        # This is a placeholder - full implementation would parse CharString
-        # and extract blend operator data
+        charstring = cff2.charstring_for_glyph(glyph_id)
+        return nil unless charstring
 
-        # Convert blend data to tuples
-        # Placeholder for full implementation
-        nil
+        # Parse CharString to extract blend data
+        charstring.parse unless charstring.instance_variable_get(:@parsed)
+        blend_data = charstring.blend_data
+        return nil if blend_data.nil? || blend_data.empty?
+
+        # Convert blend data to tuple format
+        convert_blend_to_tuples_for_glyph(blend_data)
+      end
+
+      # Convert all glyphs from gvar to blend format
+      #
+      # @param glyph_count [Integer] Number of glyphs
+      # @return [Hash<Integer, Hash>] Map of glyph_id to blend data
+      def convert_all_gvar_to_blend(glyph_count)
+        return {} unless can_convert?
+
+        (0...glyph_count).each_with_object({}) do |glyph_id, result|
+          blend_data = gvar_to_blend(glyph_id)
+          result[glyph_id] = blend_data if blend_data
+        end
+      end
+
+      # Convert all glyphs from blend to gvar format
+      #
+      # @param glyph_count [Integer] Number of glyphs
+      # @return [Hash<Integer, Hash>] Map of glyph_id to tuple data
+      def convert_all_blend_to_gvar(glyph_count)
+        return {} unless can_convert?
+
+        (0...glyph_count).each_with_object({}) do |glyph_id, result|
+          tuple_data = blend_to_gvar(glyph_id)
+          result[glyph_id] = tuple_data if tuple_data
+        end
       end
 
       # Check if variation data can be converted
@@ -99,6 +129,76 @@ module Fontisan
 
       private
 
+      # Convert blend data from a glyph to tuple format
+      #
+      # @param blend_data [Array<Hash>] Array of blend operations
+      # @return [Hash] Tuple variation data
+      def convert_blend_to_tuples_for_glyph(blend_data)
+        # Each blend operation represents variation at different points
+        # We need to aggregate these into region-based tuples
+
+        # Extract all regions from blend operations
+        regions_map = {}
+        point_count = 0
+
+        blend_data.each_with_index do |blend_op, idx|
+          blend_op[:blends].each do |blend|
+            # Track the maximum point index we've seen
+            point_count = [point_count, idx + 1].max
+
+            # For each delta axis, we need to create or update a region
+            blend[:deltas].each_with_index do |delta, axis_index|
+              next if delta.zero? # Skip zero deltas
+
+              # Create region key based on unique delta pattern
+              region_key = "region_#{axis_index}"
+
+              regions_map[region_key] ||= {
+                axis_index: axis_index,
+                deltas_per_point: Array.new(point_count) { { x: 0, y: 0 } },
+              }
+
+              # Store this delta for this point
+              # Note: CFF2 blend deltas are per-coordinate, we need to map to x/y
+              # This is a simplified mapping - full implementation would track
+              # which coordinates are being varied
+              regions_map[region_key][:deltas_per_point][idx / 2] ||= { x: 0, y: 0 }
+              if idx.even?
+                regions_map[region_key][:deltas_per_point][idx / 2][:x] = delta
+              else
+                regions_map[region_key][:deltas_per_point][idx / 2][:y] = delta
+              end
+            end
+          end
+        end
+
+        # Convert regions to tuples
+        tuples = []
+        regions_map.each_value do |region_data|
+          axis_index = region_data[:axis_index]
+
+          # Build peak coordinates (one per axis)
+          peak = Array.new(@axes.length, 0.0)
+          peak[axis_index] = 1.0 if axis_index < @axes.length
+
+          # Build start/end (default full range)
+          start_vals = Array.new(@axes.length, -1.0)
+          end_vals = Array.new(@axes.length, 1.0)
+
+          tuples << {
+            peak: peak,
+            start: start_vals,
+            end: end_vals,
+            deltas: region_data[:deltas_per_point],
+          }
+        end
+
+        {
+          tuples: tuples,
+          point_count: point_count,
+        }
+      end
+
       # Convert tuple variations to blend format
       #
       # @param tuple_data [Hash] Tuple variation data from gvar
@@ -172,12 +272,19 @@ module Fontisan
       # @param tuple [Hash] Tuple data
       # @param point_count [Integer] Number of points
       # @return [Array<Hash>] Deltas with :x and :y
-      def parse_tuple_deltas(_tuple, point_count)
-        # This is a placeholder - full implementation would:
-        # 1. Parse delta data from tuple
+      def parse_tuple_deltas(tuple, point_count)
+        # If tuple has deltas array, use it
+        if tuple[:deltas].is_a?(Array)
+          return tuple[:deltas].map do |delta|
+            { x: delta[:x] || 0, y: delta[:y] || 0 }
+          end
+        end
+
+        # Otherwise return zeros (placeholder for parsing raw delta data)
+        # Full implementation would:
+        # 1. Parse delta data from tuple[:data]
         # 2. Decompress if needed
         # 3. Return array of { x: dx, y: dy } for each point
-
         Array.new(point_count) { { x: 0, y: 0 } }
       end
 

data/lib/fontisan/variation/instance_writer.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require_relative "../font_writer"
+require_relative "../converters/outline_converter"
+require_relative "../converters/woff_writer"
+require_relative "../error"
+
+module Fontisan
+  module Variation
+    # Writes generated static font instances to files in various formats
+    #
+    # [`InstanceWriter`](lib/fontisan/variation/instance_writer.rb) takes
+    # instance tables generated by
+    # [`InstanceGenerator`](lib/fontisan/variation/instance_generator.rb) and
+    # writes them to files in the desired output format. It handles:
+    # - Format detection from file extension
+    # - Format conversion when needed (e.g., glyf → CFF for OTF)
+    # - SFNT version selection based on output format
+    # - Integration with FontWriter for binary output
+    # - Integration with OutlineConverter for format conversion
+    # - Integration with WoffWriter for WOFF packaging
+    #
+    # **Supported Output Formats:**
+    # - TTF (TrueType with glyf outlines)
+    # - OTF (OpenType with CFF outlines)
+    # - WOFF (Web Open Font Format)
+    # - WOFF2 (Web Open Font Format 2.0, future)
+    #
+    # @example Write instance to TTF
+    #   tables = generator.generate
+    #   InstanceWriter.write(tables, 'bold.ttf')
+    #
+    # @example Write instance to OTF with format conversion
+    #   tables = generator.generate  # from variable TTF
+    #   InstanceWriter.write(tables, 'bold.otf', source_format: :ttf)
+    #
+    # @example Write instance to WOFF
+    #   tables = generator.generate
+    #   InstanceWriter.write(tables, 'bold.woff')
+    class InstanceWriter
+      # Supported output formats
+      SUPPORTED_FORMATS = %i[ttf otf woff woff2].freeze
+
+      # SFNT version constants
+      SFNT_VERSION_TRUETYPE = 0x00010000  # TrueType with glyf
+      SFNT_VERSION_CFF = 0x4F54544F       # 'OTTO' for CFF
+
+      # Write instance tables to file
+      #
+      # @param tables [Hash<String, String>] Instance tables from
+      #   InstanceGenerator
+      # @param output_path [String] Output file path
+      # @param options [Hash] Options
+      # @option options [Symbol] :format Output format (:ttf, :otf, :woff,
+      #   :woff2)
+      # @option options [Symbol] :source_format Source format before instancing
+      #   (:ttf or :otf)
+      # @option options [Boolean] :optimize Enable CFF optimization for OTF
+      #   (default: false)
+      # @option options [Integer] :sfnt_version Override SFNT version
+      # @return [Integer] Number of bytes written
+      # @raise [ArgumentError] If parameters are invalid
+      # @raise [Error] If format conversion fails
+      def self.write(tables, output_path, options = {})
+        new(tables, options).write(output_path)
+      end
+
+      # @return [Hash<String, String>] Instance tables
+      attr_reader :tables
+
+      # @return [Hash] Writer options
+      attr_reader :options
+
+      # Initialize writer with instance tables
+      #
+      # @param tables [Hash<String, String>] Instance tables from
+      #   InstanceGenerator
+      # @param options [Hash] Writer options
+      # @option options [Symbol] :source_format Source format before instancing
+      # @option options [Boolean] :optimize Enable CFF optimization
+      def initialize(tables, options = {})
+        @tables = tables
+        @options = options
+        validate_tables!
+      end
+
+      # Write instance to file
+      #
+      # @param output_path [String] Output file path
+      # @return [Integer] Number of bytes written
+      def write(output_path)
+        # Detect output format
+        format = detect_output_format(output_path)
+        validate_format!(format)
+
+        # Detect source format from tables
+        source_format = detect_source_format(@tables)
+
+        # Convert format if needed
+        output_tables = if format_conversion_needed?(source_format, format)
+                          convert_format(source_format, format)
+                        else
+                          @tables
+                        end
+
+        # Write to file based on format
+        case format
+        when :ttf, :otf
+          write_sfnt(output_tables, output_path, format)
+        when :woff
+          write_woff(output_tables, output_path, source_format)
+        when :woff2
+          raise Fontisan::Error,
+                "WOFF2 output not yet implemented (planned for Phase 6)"
+        end
+      end
+
+      private
+
+      # Validate instance tables
+      #
+      # @raise [ArgumentError] If tables are invalid
+      def validate_tables!
+        raise ArgumentError, "Tables cannot be nil" if @tables.nil?
+
+        unless @tables.is_a?(Hash)
+          raise ArgumentError,
+                "Tables must be a Hash, got: #{@tables.class}"
+        end
+
+        if @tables.empty?
+          raise ArgumentError, "Tables cannot be empty"
+        end
+
+        # Check for required tables
+        required_tables = %w[head hhea maxp]
+        required_tables.each do |tag|
+          unless @tables.key?(tag)
+            raise ArgumentError, "Missing required table: #{tag}"
+          end
+        end
+      end
+
+      # Detect output format from file path
+      #
+      # @param path [String] Output file path
+      # @return [Symbol] Format (:ttf, :otf, :woff, :woff2)
+      def detect_output_format(path)
+        return @options[:format] if @options[:format]
+
+        ext = File.extname(path).downcase
+        case ext
+        when ".ttf" then :ttf
+        when ".otf" then :otf
+        when ".woff" then :woff
+        when ".woff2" then :woff2
+        else
+          raise ArgumentError,
+                "Cannot determine format from extension: #{ext}. " \
+                "Supported: .ttf, .otf, .woff, .woff2"
+        end
+      end
+
+      # Validate output format
+      #
+      # @param format [Symbol] Format to validate
+      # @raise [ArgumentError] If format is not supported
+      def validate_format!(format)
+        unless SUPPORTED_FORMATS.include?(format)
+          raise ArgumentError,
+                "Unsupported format: #{format}. " \
+                "Supported: #{SUPPORTED_FORMATS.join(', ')}"
+        end
+      end
+
+      # Detect source format from instance tables
+      #
+      # @param tables [Hash<String, String>] Instance tables
+      # @return [Symbol] Source format (:ttf or :otf)
+      def detect_source_format(tables)
+        # Check for outline tables
+        if tables.key?("CFF ") || tables.key?("CFF2")
+          :otf
+        elsif tables.key?("glyf")
+          :ttf
+        else
+          # If no outline tables, use option or default to TTF
+          @options[:source_format] || :ttf
+        end
+      end
+
+      # Check if format conversion is needed
+      #
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Boolean] True if conversion needed
+      def format_conversion_needed?(source_format, target_format)
+        # WOFF doesn't need outline conversion
+        return false if %i[woff woff2].include?(target_format)
+
+        # Check if outline formats differ
+        source_format != target_format
+      end
+
+      # Convert instance tables from source format to target format
+      #
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Hash<String, String>] Converted tables
+      # @raise [Error] If conversion fails
+      def convert_format(source_format, target_format)
+        # Create temporary font object for conversion
+        temp_font = create_temp_font(@tables, source_format)
+
+        # Use OutlineConverter for format conversion
+        converter = Converters::OutlineConverter.new
+        converter.convert(
+          temp_font,
+          target_format: target_format,
+          optimize_cff: @options[:optimize] || false,
+        )
+      rescue StandardError => e
+        raise Fontisan::Error,
+              "Failed to convert instance from #{source_format} to " \
+              "#{target_format}: #{e.message}"
+      end
+
+      # Create temporary font object from tables
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @param format [Symbol] Font format
+      # @return [Object] Font object
+      def create_temp_font(tables, format)
+        # Create minimal font object that responds to required methods
+        font_class = format == :otf ? OpenTypeFont : TrueTypeFont
+        font = font_class.new
+
+        # Set table data
+        font.instance_variable_set(:@table_data, tables)
+
+        # Define required methods
+        font.define_singleton_method(:table_data) { tables }
+        font.define_singleton_method(:table_names) { tables.keys }
+        font.define_singleton_method(:has_table?) { |tag| tables.key?(tag) }
+        font.define_singleton_method(:table) do |tag|
+          # Return nil if table doesn't exist
+          return nil unless tables.key?(tag)
+
+          # Parse and return table object
+          # For conversion, we need to lazy-load tables
+          parse_table(tag, tables[tag])
+        end
+
+        font
+      end
+
+      # Parse table data into table object
+      #
+      # @param tag [String] Table tag
+      # @param data [String] Table binary data
+      # @return [Object] Parsed table object
+      def parse_table(tag, data)
+        # For OutlineConverter, we need head, maxp, loca, glyf for TTF
+        # and CFF for OTF
+        case tag
+        when "head"
+          Tables::Head.new.tap { |t| t.parse(data) }
+        when "maxp"
+          Tables::Maxp.new.tap { |t| t.parse(data) }
+        when "loca"
+          Tables::Loca.new.tap { |t| t.data = data }
+        when "glyf"
+          Tables::Glyf.new.tap { |t| t.data = data }
+        when "CFF "
+          Tables::Cff.new.tap { |t| t.parse(data) }
+        when "CFF2"
+          Tables::Cff2.new.tap { |t| t.parse(data) }
+        else
+          # For other tables, return a simple object that just holds data
+          Object.new.tap do |obj|
+            obj.define_singleton_method(:data) { data }
+          end
+        end
+      rescue StandardError => e
+        warn "Warning: Failed to parse #{tag} table: #{e.message}"
+        nil
+      end
+
+      # Write SFNT format (TTF or OTF)
+      #
+      # @param tables [Hash<String, String>] Output tables
+      # @param output_path [String] Output file path
+      # @param format [Symbol] Output format
+      # @return [Integer] Number of bytes written
+      def write_sfnt(tables, output_path, format)
+        # Determine SFNT version
+        sfnt_version = @options[:sfnt_version] || sfnt_version_for_format(
+          format,
+        )
+
+        # Write using FontWriter
+        FontWriter.write_to_file(tables, output_path,
+                                 sfnt_version: sfnt_version)
+      end
+
+      # Write WOFF format
+      #
+      # @param tables [Hash<String, String>] Output tables
+      # @param output_path [String] Output file path
+      # @param source_format [Symbol] Source format (for flavor detection)
+      # @return [Integer] Number of bytes written
+      def write_woff(tables, output_path, source_format)
+        # Create temporary font for WOFF writer
+        temp_font = create_temp_font(tables, source_format)
+
+        # Add cff? method for WoffWriter flavor detection
+        temp_font.define_singleton_method(:cff?) do
+          tables.key?("CFF ") || tables.key?("CFF2")
+        end
+
+        # Use WoffWriter to create WOFF
+        writer = Converters::WoffWriter.new
+        woff_data = writer.convert(temp_font)
+
+        # Write to file
+        File.binwrite(output_path, woff_data)
+      rescue StandardError => e
+        raise Fontisan::Error,
+              "Failed to write WOFF output: #{e.message}"
+      end
+
+      # Get SFNT version for output format
+      #
+      # @param format [Symbol] Output format
+      # @return [Integer] SFNT version constant
+      def sfnt_version_for_format(format)
+        format == :otf ? SFNT_VERSION_CFF : SFNT_VERSION_TRUETYPE
+      end
+    end
+  end
+end

data/lib/fontisan/variation/tuple_variation_header.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../binary/base_record"
+
+module Fontisan
+  module Variation
+    # Tuple variation header structure
+    #
+    # Used by both gvar and cvar tables to describe variation tuples.
+    # Each tuple header contains metadata about peak coordinates,
+    # intermediate regions, and point number handling.
+    class TupleVariationHeader < Binary::BaseRecord
+      uint16 :variation_data_size
+      uint16 :tuple_index
+
+      # Tuple index flags
+      EMBEDDED_PEAK_TUPLE = 0x8000
+      INTERMEDIATE_REGION = 0x4000
+      PRIVATE_POINT_NUMBERS = 0x2000
+      TUPLE_INDEX_MASK = 0x0FFF
+
+      # Check if tuple has embedded peak coordinates
+      #
+      # @return [Boolean] True if embedded
+      def embedded_peak_tuple?
+        (tuple_index & EMBEDDED_PEAK_TUPLE) != 0
+      end
+
+      # Check if tuple has intermediate region
+      #
+      # @return [Boolean] True if intermediate region
+      def intermediate_region?
+        (tuple_index & INTERMEDIATE_REGION) != 0
+      end
+
+      # Check if tuple has private point numbers
+      #
+      # @return [Boolean] True if private points
+      def private_point_numbers?
+        (tuple_index & PRIVATE_POINT_NUMBERS) != 0
+      end
+
+      # Get shared tuple index
+      #
+      # @return [Integer] Tuple index
+      def shared_tuple_index
+        tuple_index & TUPLE_INDEX_MASK
+      end
+    end
+  end
+end