fontisan 0.2.0 → 0.2.2

data/lib/fontisan/variation/variable_svg_generator.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "instance_generator"
+require_relative "../converters/svg_generator"
+
+module Fontisan
+  module Variation
+    # Generates SVG fonts from variable fonts at specific coordinates
+    #
+    # [`VariableSvgGenerator`](lib/fontisan/variation/variable_svg_generator.rb)
+    # combines instance generation with SVG conversion to create static SVG
+    # fonts from variable fonts at any point in the design space.
+    #
+    # Process:
+    # 1. Accept variable font + axis coordinates
+    # 2. Generate static instance using InstanceGenerator
+    # 3. Build temporary font from instance tables
+    # 4. Delegate to SvgGenerator for SVG creation
+    # 5. Return SVG with variation metadata
+    #
+    # This enables generating SVG fonts at specific weights, widths, or other
+    # variation axes without creating intermediate font files.
+    #
+    # @example Generate SVG at Bold weight
+    #   generator = VariableSvgGenerator.new(variable_font, { "wght" => 700.0 })
+    #   svg_result = generator.generate
+    #   File.write("bold.svg", svg_result[:svg_xml])
+    #
+    # @example Generate SVG at specific width and weight
+    #   coords = { "wght" => 700.0, "wdth" => 75.0 }
+    #   generator = VariableSvgGenerator.new(variable_font, coords)
+    #   svg_result = generator.generate(pretty_print: true)
+    class VariableSvgGenerator
+      # @return [TrueTypeFont, OpenTypeFont] Variable font
+      attr_reader :font
+
+      # @return [Hash<String, Float>] Design space coordinates
+      attr_reader :coordinates
+
+      # Initialize generator
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Variable font
+      # @param coordinates [Hash<String, Float>] Design space coordinates
+      # @raise [Error] If font is not a variable font
+      def initialize(font, coordinates = {})
+        @font = font
+        @coordinates = coordinates || {}
+
+        validate_variable_font!
+      end
+
+      # Generate SVG font at specified coordinates
+      #
+      # Creates a static instance at the given coordinates and converts
+      # it to SVG format. Returns the same format as SvgGenerator for
+      # consistency.
+      #
+      # @param options [Hash] SVG generation options
+      # @option options [Boolean] :pretty_print Pretty print XML (default: true)
+      # @option options [Array<Integer>] :glyph_ids Specific glyphs (default: all)
+      # @option options [Integer] :max_glyphs Maximum glyphs (default: all)
+      # @option options [String] :font_id Font ID for SVG
+      # @option options [Integer] :default_advance Default advance width
+      # @return [Hash] Hash with :svg_xml key containing SVG XML string
+      # @raise [Error] If generation fails
+      def generate(options = {})
+        # Generate static instance tables
+        instance_tables = generate_static_instance
+
+        # Build temporary font from instance tables
+        static_font = build_font_from_tables(instance_tables)
+
+        # Generate SVG using standard generator
+        svg_generator = Converters::SvgGenerator.new
+        result = svg_generator.convert(static_font, options)
+
+        # Add variation metadata to result
+        result[:variation_metadata] = {
+          coordinates: @coordinates,
+          source_font: extract_font_name,
+        }
+
+        result
+      end
+
+      # Generate SVG for a named instance
+      #
+      # @param instance_index [Integer] Index of named instance in fvar
+      # @param options [Hash] SVG generation options
+      # @return [Hash] Hash with :svg_xml key
+      def generate_named_instance(instance_index, options = {})
+        instance_generator = InstanceGenerator.new(@font)
+        instance_tables = instance_generator.generate_named_instance(instance_index)
+
+        static_font = build_font_from_tables(instance_tables)
+        svg_generator = Converters::SvgGenerator.new
+        result = svg_generator.convert(static_font, options)
+
+        # Add instance metadata
+        result[:variation_metadata] = {
+          instance_index: instance_index,
+          source_font: extract_font_name,
+        }
+
+        result
+      end
+
+      # Get default coordinates for font
+      #
+      # Returns all axes at their default values.
+      #
+      # @return [Hash<String, Float>] Default coordinates
+      def default_coordinates
+        return {} unless @font.has_table?("fvar")
+
+        fvar = @font.table("fvar")
+        return {} unless fvar
+
+        coords = {}
+        fvar.axes.each do |axis|
+          coords[axis.axis_tag] = axis.default_value
+        end
+        coords
+      end
+
+      # Get list of named instances
+      #
+      # @return [Array<Hash>] Array of instance info
+      def named_instances
+        return [] unless @font.has_table?("fvar")
+
+        fvar = @font.table("fvar")
+        return [] unless fvar
+
+        fvar.instances.map.with_index do |instance, index|
+          {
+            index: index,
+            name: instance[:subfamily_name_id],
+            coordinates: build_instance_coordinates(instance, fvar.axes),
+          }
+        end
+      end
+
+      private
+
+      # Validate that font is a variable font
+      #
+      # @raise [Error] If not a variable font
+      def validate_variable_font!
+        unless @font.has_table?("fvar")
+          raise Fontisan::Error,
+                "Font must be a variable font (missing fvar table)"
+        end
+
+        # Check for variation data
+        has_gvar = @font.has_table?("gvar")
+        has_cff2 = @font.has_table?("CFF2")
+
+        unless has_gvar || has_cff2
+          raise Fontisan::Error,
+                "Variable font must have gvar (TrueType) or CFF2 (PostScript) table"
+        end
+      end
+
+      # Generate static instance at current coordinates
+      #
+      # @return [Hash<String, String>] Instance tables
+      def generate_static_instance
+        # Use coordinates or defaults if none specified
+        coords = @coordinates.empty? ? default_coordinates : @coordinates
+
+        instance_generator = InstanceGenerator.new(@font, coords)
+        instance_generator.generate
+      end
+
+      # Build a font object from instance tables
+      #
+      # Creates a minimal font object that can be used by SvgGenerator.
+      # This is a lightweight wrapper around the table data.
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @return [Object] Font-like object
+      def build_font_from_tables(tables)
+        # Create a simple font wrapper that implements the minimal
+        # interface needed by SvgGenerator
+        InstanceFontWrapper.new(@font, tables)
+      end
+
+      # Extract font name for metadata
+      #
+      # @return [String] Font name
+      def extract_font_name
+        name_table = @font.table("name")
+        return "Unknown" unless name_table
+
+        # Try font family name
+        family = name_table.font_family.first
+        return family if family && !family.empty?
+
+        "Unknown"
+      rescue StandardError
+        "Unknown"
+      end
+
+      # Build coordinates from instance
+      #
+      # @param instance [Hash] Instance data
+      # @param axes [Array] Variation axes
+      # @return [Hash<String, Float>] Coordinates
+      def build_instance_coordinates(instance, axes)
+        coords = {}
+        instance[:coordinates].each_with_index do |value, index|
+          next if index >= axes.length
+
+          axis = axes[index]
+          coords[axis.axis_tag] = value
+        end
+        coords
+      end
+
+      # Wrapper class for instance font tables
+      #
+      # Provides minimal interface needed by SvgGenerator while using
+      # instance tables instead of original font tables.
+      class InstanceFontWrapper
+        # @return [Hash<String, String>] Font tables
+        attr_reader :table_data
+
+        # Initialize wrapper
+        #
+        # @param original_font [Object] Original variable font
+        # @param instance_tables [Hash<String, String>] Instance tables
+        def initialize(original_font, instance_tables)
+          @original_font = original_font
+          @table_data = instance_tables
+        end
+
+        # Get table by tag
+        #
+        # @param tag [String] Table tag
+        # @return [Object, nil] Table or nil
+        def table(tag)
+          # Use instance table if available, otherwise fall back to original
+          if @table_data.key?(tag)
+          end
+          @original_font.table(tag)
+        end
+
+        # Check if table exists
+        #
+        # @param tag [String] Table tag
+        # @return [Boolean] True if table exists
+        def has_table?(tag)
+          @table_data.key?(tag) || @original_font.has_table?(tag)
+        end
+
+        # Forward other methods to original font
+        def method_missing(method, ...)
+          @original_font.send(method, ...)
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          @original_font.respond_to?(method, include_private) || super
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/variation_preserver.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require_relative "variation_context"
+require_relative "../error"
+
+module Fontisan
+  module Variation
+    # Preserves variation data when converting between compatible font formats
+    #
+    # [`VariationPreserver`](lib/fontisan/variation/variation_preserver.rb)
+    # copies variation tables from source to target font during format
+    # conversion. It handles:
+    # - Common variation tables (fvar, avar, STAT) - shared by all variable fonts
+    # - Format-specific tables (gvar for TTF, CFF2 for OTF)
+    # - Metrics variation tables (HVAR, VVAR, MVAR)
+    # - Table checksum updates
+    # - Validation of table consistency
+    #
+    # **Use Cases:**
+    #
+    # 1. **Variable TTF → Variable WOFF**: Preserve all gvar-based variation
+    # 2. **Variable OTF → Variable WOFF**: Preserve all CFF2-based variation
+    # 3. **Variable TTF → Variable OTF**: Copy common tables (fvar, avar, STAT)
+    #    but variation data conversion handled by Converter
+    # 4. **Variable OTF → Variable TTF**: Copy common tables (fvar, avar, STAT)
+    #    but variation data conversion handled by Converter
+    #
+    # **Preserved Tables:**
+    #
+    # Common (all variable fonts):
+    # - fvar (Font Variations)
+    # - avar (Axis Variations, optional)
+    # - STAT (Style Attributes)
+    #
+    # TrueType-specific:
+    # - gvar (Glyph Variations)
+    # - cvar (CVT Variations, optional)
+    #
+    # CFF2-specific:
+    # - CFF2 (with blend operators)
+    #
+    # Metrics (optional):
+    # - HVAR (Horizontal Metrics Variations)
+    # - VVAR (Vertical Metrics Variations)
+    # - MVAR (Metrics Variations)
+    #
+    # @example Preserve variation when converting TTF to WOFF
+    #   preserver = VariationPreserver.new(ttf_font, woff_tables)
+    #   preserved_tables = preserver.preserve
+    #
+    # @example Preserve only common tables for outline conversion
+    #   preserver = VariationPreserver.new(ttf_font, otf_tables,
+    #                                      preserve_format_specific: false)
+    #   preserved_tables = preserver.preserve
+    class VariationPreserver
+      # Common variation tables present in all variable fonts
+      COMMON_TABLES = %w[fvar avar STAT].freeze
+
+      # TrueType-specific variation tables
+      TRUETYPE_TABLES = %w[gvar cvar].freeze
+
+      # CFF2-specific variation tables
+      CFF2_TABLES = %w[CFF2].freeze
+
+      # Metrics variation tables
+      METRICS_TABLES = %w[HVAR VVAR MVAR].freeze
+
+      # All variation-related tables
+      ALL_VARIATION_TABLES = (COMMON_TABLES + TRUETYPE_TABLES +
+                              CFF2_TABLES + METRICS_TABLES).freeze
+
+      # Preserve variation data from source to target
+      #
+      # @param source_font [TrueTypeFont, OpenTypeFont] Variable font
+      # @param target_tables [Hash<String, String>] Target font tables
+      # @param options [Hash] Preservation options
+      # @return [Hash<String, String>] Tables with variation data preserved
+      def self.preserve(source_font, target_tables, options = {})
+        new(source_font, target_tables, options).preserve
+      end
+
+      # @return [Object] Source font
+      attr_reader :source_font
+
+      # @return [Hash<String, String>] Target tables
+      attr_reader :target_tables
+
+      # @return [Hash] Preservation options
+      attr_reader :options
+
+      # Initialize preserver
+      #
+      # @param source_font [TrueTypeFont, OpenTypeFont] Variable font
+      # @param target_tables [Hash<String, String>] Target font tables
+      # @param options [Hash] Preservation options
+      # @option options [Boolean] :preserve_format_specific Preserve format-
+      #   specific variation tables (default: true)
+      # @option options [Boolean] :preserve_metrics Preserve metrics variation
+      #   tables (default: true)
+      # @option options [Boolean] :validate Validate table consistency
+      #   (default: true)
+      def initialize(source_font, target_tables, options = {})
+        @source_font = source_font
+        @target_tables = target_tables.dup
+        @options = options
+
+        validate_source!
+        @context = VariationContext.new(source_font)
+      end
+
+      # Preserve variation tables
+      #
+      # @return [Hash<String, String>] Target tables with variation preserved
+      def preserve
+        # Copy common variation tables (fvar, avar, STAT)
+        copy_common_tables
+
+        # Copy format-specific variation tables if requested
+        if preserve_format_specific?
+          copy_format_specific_tables
+        end
+
+        # Copy metrics variation tables if requested
+        copy_metrics_tables if preserve_metrics?
+
+        # Validate consistency if requested
+        validate_consistency if validate?
+
+        @target_tables
+      end
+
+      # Check if source font is a variable font
+      #
+      # @return [Boolean] True if source has fvar table
+      def variable_font?
+        @context.variable_font?
+      end
+
+      # Get variation type of source font
+      #
+      # @return [Symbol, nil] :truetype, :cff2, or nil
+      def variation_type
+        @context.variation_type
+      end
+
+      private
+
+      # Validate source font
+      #
+      # @raise [ArgumentError] If source is invalid
+      def validate_source!
+        raise ArgumentError, "Source font cannot be nil" if @source_font.nil?
+
+        unless @source_font.respond_to?(:has_table?) &&
+            @source_font.respond_to?(:table_data)
+          raise ArgumentError,
+                "Source font must respond to :has_table? and :table_data"
+        end
+
+        if @target_tables.nil?
+          raise ArgumentError,
+                "Target tables cannot be nil"
+        end
+
+        unless @target_tables.is_a?(Hash)
+          raise ArgumentError,
+                "Target tables must be a Hash, got: #{@target_tables.class}"
+        end
+      end
+
+      # Copy common variation tables (fvar, avar, STAT)
+      #
+      # These tables are independent of outline format and can always be copied
+      def copy_common_tables
+        COMMON_TABLES.each do |tag|
+          copy_table(tag) if @source_font.has_table?(tag)
+        end
+      end
+
+      # Copy format-specific variation tables
+      #
+      # For TrueType: gvar, cvar
+      # For CFF2: CFF2 table
+      def copy_format_specific_tables
+        case variation_type
+        when :truetype
+          copy_truetype_variation_tables
+        when :postscript
+          copy_cff2_variation_tables
+        end
+      end
+
+      # Copy TrueType variation tables
+      def copy_truetype_variation_tables
+        TRUETYPE_TABLES.each do |tag|
+          copy_table(tag) if @source_font.has_table?(tag)
+        end
+      end
+
+      # Copy CFF2 variation tables
+      def copy_cff2_variation_tables
+        # CFF2 table contains both outlines and variation data
+        # Only copy if target doesn't already have CFF2 and source has it
+        return unless @source_font.has_table?("CFF2")
+        return if @target_tables.key?("CFF2")
+
+        copy_table("CFF2")
+      end
+
+      # Copy metrics variation tables (HVAR, VVAR, MVAR)
+      def copy_metrics_tables
+        METRICS_TABLES.each do |tag|
+          copy_table(tag) if @source_font.has_table?(tag)
+        end
+      end
+
+      # Copy a single table from source to target
+      #
+      # @param tag [String] Table tag
+      def copy_table(tag)
+        return unless @source_font.has_table?(tag)
+
+        table_data = @source_font.table_data[tag]
+        return unless table_data
+
+        @target_tables[tag] = table_data.dup
+      end
+
+      # Validate table consistency
+      #
+      # Ensures that copied variation tables are consistent with target font
+      # @raise [Error] If validation fails
+      def validate_consistency
+        # Must have fvar if we're preserving variations
+        unless @target_tables.key?("fvar")
+          raise Fontisan::Error,
+                "Cannot preserve variations: fvar table missing"
+        end
+
+        # If we have gvar, we must have glyf (TrueType outlines)
+        if @target_tables.key?("gvar") && !@target_tables.key?("glyf")
+          raise Fontisan::Error,
+                "Invalid variation preservation: gvar present without glyf"
+        end
+
+        # If we have CFF2, we shouldn't have glyf (CFF2 has CFF outlines)
+        # Check both source and target to catch conflicts
+        has_cff2 = @target_tables.key?("CFF2") ||
+          (@source_font.has_table?("CFF2") && preserve_format_specific?)
+        if has_cff2 && @target_tables.key?("glyf")
+          raise Fontisan::Error,
+                "Invalid variation preservation: CFF2 and glyf both present"
+        end
+
+        # Metrics variation tables require fvar
+        if metrics_tables_present? && !@target_tables.key?("fvar")
+          raise Fontisan::Error,
+                "Metrics variation tables require fvar table"
+        end
+      end
+
+      # Check if any metrics variation tables are present
+      #
+      # @return [Boolean] True if HVAR, VVAR, or MVAR present
+      def metrics_tables_present?
+        METRICS_TABLES.any? { |tag| @target_tables.key?(tag) }
+      end
+
+      # Get preserve_format_specific option
+      #
+      # @return [Boolean] True if format-specific tables should be preserved
+      def preserve_format_specific?
+        @options.fetch(:preserve_format_specific, true)
+      end
+
+      # Get preserve_metrics option
+      #
+      # @return [Boolean] True if metrics tables should be preserved
+      def preserve_metrics?
+        @options.fetch(:preserve_metrics, true)
+      end
+
+      # Get validate option
+      #
+      # @return [Boolean] True if consistency should be validated
+      def validate?
+        @options.fetch(:validate, true)
+      end
+    end
+  end
+end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/fontisan/version.rb.orig

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fontisan
+<<<<<<< HEAD
+  VERSION = "2.0.0"
+=======
+  VERSION = "0.2.0"
+>>>>>>> 4bcec10 (fix: update loading modes)
+end