fontisan 0.1.0 → 0.2.1

data/lib/fontisan/pipeline/output_writer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "../font_writer"
+
+module Fontisan
+  module Pipeline
+    # Handles writing font tables to various output formats
+    #
+    # This class abstracts the complexity of writing different font formats:
+    # - SFNT formats (TTF, OTF) via FontWriter
+    # - WOFF via WoffWriter
+    # - WOFF2 via Woff2Encoder
+    #
+    # Single Responsibility: Coordinate output writing for different formats
+    #
+    # @example Write TTF font
+    #   writer = OutputWriter.new("output.ttf", :ttf)
+    #   writer.write(tables)
+    #
+    # @example Write OTF font
+    #   writer = OutputWriter.new("output.otf", :otf)
+    #   writer.write(tables)
+    class OutputWriter
+      # @return [String] Output file path
+      attr_reader :output_path
+
+      # @return [Symbol] Target format
+      attr_reader :format
+
+      # @return [Hash] Writing options
+      attr_reader :options
+
+      # Initialize output writer
+      #
+      # @param output_path [String] Path to write output
+      # @param format [Symbol] Target format (:ttf, :otf, :woff, :woff2)
+      # @param options [Hash] Writing options
+      def initialize(output_path, format, options = {})
+        @output_path = output_path
+        @format = format
+        @options = options
+      end
+
+      # Write font tables to output file
+      #
+      # @param tables [Hash<String, String>, Hash] Font tables (tag => binary data) or special format result
+      # @return [Integer] Number of bytes written
+      # @raise [ArgumentError] If format is unsupported
+      def write(tables)
+        case @format
+        when :ttf, :otf
+          write_sfnt(tables)
+        when :woff
+          write_woff(tables)
+        when :woff2
+          write_woff2(tables)
+        when :svg
+          write_svg(tables)
+        else
+          raise ArgumentError, "Unsupported output format: #{@format}"
+        end
+      end
+
+      private
+
+      # Write SVG format
+      #
+      # @param result [Hash] Result with :svg_xml key
+      # @return [Integer] Number of bytes written
+      def write_svg(result)
+        svg_xml = result[:svg_xml] || result["svg_xml"]
+        raise ArgumentError, "SVG result must contain :svg_xml key" unless svg_xml
+
+        File.write(@output_path, svg_xml)
+      end
+
+      # Write SFNT format (TTF or OTF)
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @return [Integer] Number of bytes written
+      def write_sfnt(tables)
+        sfnt_version = determine_sfnt_version
+        FontWriter.write_to_file(tables, @output_path, sfnt_version: sfnt_version)
+      end
+
+      # Write WOFF format
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @return [Integer] Number of bytes written
+      def write_woff(tables)
+        require_relative "../converters/woff_writer"
+
+        writer = Converters::WoffWriter.new
+        font = build_font_from_tables(tables)
+        result = writer.convert(font, @options)
+
+        File.binwrite(@output_path, result[:woff_data])
+      end
+
+      # Write WOFF2 format
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @return [Integer] Number of bytes written
+      def write_woff2(tables)
+        require_relative "../converters/woff2_encoder"
+
+        encoder = Converters::Woff2Encoder.new
+        font = build_font_from_tables(tables)
+        result = encoder.convert(font, @options)
+
+        File.binwrite(@output_path, result[:woff2_binary])
+      end
+
+      # Determine SFNT version based on format and tables
+      #
+      # @return [Integer] SFNT version (0x00010000 for TTF, 0x4F54544F for OTF)
+      def determine_sfnt_version
+        case @format
+        when :ttf, :woff, :woff2 then 0x00010000
+        when :otf then 0x4F54544F # 'OTTO'
+        else raise ArgumentError, "Unsupported format: #{@format}"
+        end
+      end
+
+      # Build font object from tables
+      #
+      # Helper to create font object from tables for converters that need it.
+      #
+      # @param tables [Hash<String, String>] Font tables
+      # @return [Font] Font object
+      def build_font_from_tables(tables)
+        # Detect font type from tables
+        has_cff = tables.key?("CFF ") || tables.key?("CFF2")
+        has_glyf = tables.key?("glyf")
+
+        if has_cff
+          OpenTypeFont.from_tables(tables)
+        elsif has_glyf
+          TrueTypeFont.from_tables(tables)
+        else
+          # Default based on format
+          case @format
+          when :ttf, :woff, :woff2
+            TrueTypeFont.from_tables(tables)
+          when :otf
+            OpenTypeFont.from_tables(tables)
+          else
+            raise ArgumentError, "Cannot determine font type for format: #{@format}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/pipeline/strategies/base_strategy.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Pipeline
+    module Strategies
+      # Base class for variation resolution strategies
+      #
+      # This abstract class defines the interface that all variation resolution
+      # strategies must implement. It follows the Strategy pattern to allow
+      # different approaches to handling variable font data during conversion.
+      #
+      # Subclasses must implement:
+      # - resolve(font): Process the font and return tables
+      # - preserves_variation?: Indicate if variation data is preserved
+      # - strategy_name: Return the strategy identifier
+      #
+      # @example Implementing a strategy
+      #   class MyStrategy < BaseStrategy
+      #     def resolve(font)
+      #       # Implementation
+      #     end
+      #
+      #     def preserves_variation?
+      #       false
+      #     end
+      #
+      #     def strategy_name
+      #       :my_strategy
+      #     end
+      #   end
+      class BaseStrategy
+        # @return [Hash] Strategy options
+        attr_reader :options
+
+        # Initialize strategy with options
+        #
+        # @param options [Hash] Strategy-specific options
+        def initialize(options = {})
+          @options = options
+        end
+
+        # Resolve variation data
+        #
+        # This method must be implemented by subclasses to process the font
+        # and return the appropriate tables based on the strategy.
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Font to process
+        # @return [Hash<String, String>] Map of table tags to binary data
+        # @raise [NotImplementedError] If not implemented by subclass
+        def resolve(font)
+          raise NotImplementedError,
+                "#{self.class.name} must implement #resolve"
+        end
+
+        # Check if strategy preserves variation data
+        #
+        # @return [Boolean] True if variation data is preserved
+        # @raise [NotImplementedError] If not implemented by subclass
+        def preserves_variation?
+          raise NotImplementedError,
+                "#{self.class.name} must implement #preserves_variation?"
+        end
+
+        # Get strategy name
+        #
+        # @return [Symbol] Strategy identifier
+        # @raise [NotImplementedError] If not implemented by subclass
+        def strategy_name
+          raise NotImplementedError,
+                "#{self.class.name} must implement #strategy_name"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/pipeline/strategies/instance_strategy.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy"
+require_relative "../../variation/instance_generator"
+require_relative "../../variation/variation_context"
+
+module Fontisan
+  module Pipeline
+    module Strategies
+      # Strategy for generating static instances from variable fonts
+      #
+      # This strategy creates a static font instance at specific design space
+      # coordinates by applying variation deltas and removing variation tables.
+      # It's used for:
+      # - Variable TTF → Static TTF at specific weight
+      # - Variable OTF → Static OTF at specific coordinates
+      # - Variable → Static for any format conversion
+      #
+      # The strategy uses the InstanceGenerator to:
+      # 1. Apply variation deltas (gvar or CFF2 blend)
+      # 2. Apply metrics variations (HVAR, VVAR, MVAR)
+      # 3. Remove variation tables (fvar, gvar, CFF2, avar, etc.)
+      #
+      # If no coordinates are provided, uses default coordinates (axis default values).
+      #
+      # @example Generate instance at specific weight
+      #   strategy = InstanceStrategy.new(coordinates: { "wght" => 700.0 })
+      #   tables = strategy.resolve(variable_font)
+      #   # tables has no variation tables
+      #
+      # @example Generate instance at default coordinates
+      #   strategy = InstanceStrategy.new
+      #   tables = strategy.resolve(variable_font)
+      class InstanceStrategy < BaseStrategy
+        # @return [Hash<String, Float>] Design space coordinates
+        attr_reader :coordinates
+
+        # Initialize strategy with coordinates
+        #
+        # @param options [Hash] Strategy options
+        # @option options [Hash<String, Float>] :coordinates Design space coordinates
+        #   (axis tag => value). If not provided, uses default coordinates.
+        def initialize(options = {})
+          super
+          @coordinates = options[:coordinates] || {}
+        end
+
+        # Resolve by generating static instance
+        #
+        # Creates a static font instance at the specified coordinates using
+        # the InstanceGenerator. If coordinates are not provided, uses the
+        # default coordinates from the font's axes.
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Variable font
+        # @return [Hash<String, String>] Static font tables
+        # @raise [Variation::InvalidCoordinatesError] If coordinates out of range
+        def resolve(font)
+          # Validate coordinates if provided
+          validate_coordinates(font) unless @coordinates.empty?
+
+          # Use InstanceGenerator to create static instance
+          generator = Variation::InstanceGenerator.new(font, @coordinates)
+          generator.generate
+        end
+
+        # Check if strategy preserves variation data
+        #
+        # @return [Boolean] Always false for this strategy
+        def preserves_variation?
+          false
+        end
+
+        # Get strategy name
+        #
+        # @return [Symbol] :instance
+        def strategy_name
+          :instance
+        end
+
+        private
+
+        # Validate coordinates against font axes
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Variable font
+        # @raise [Variation::InvalidCoordinatesError] If invalid
+        def validate_coordinates(font)
+          context = Variation::VariationContext.new(font)
+          context.validate_coordinates(@coordinates)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/pipeline/strategies/named_strategy.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy"
+require_relative "instance_strategy"
+require_relative "../../variation/variation_context"
+
+module Fontisan
+  module Pipeline
+    module Strategies
+      # Strategy for generating instances from named instances
+      #
+      # This strategy creates a static font instance using coordinates from
+      # a named instance defined in the fvar table. It extracts the coordinates
+      # from the specified instance and delegates to InstanceStrategy for
+      # actual generation.
+      #
+      # Named instances are predefined design space coordinates stored in the
+      # fvar table, typically representing common styles like "Bold", "Light",
+      # "Condensed", etc.
+      #
+      # @example Generate "Bold" instance
+      #   strategy = NamedStrategy.new(instance_index: 0)
+      #   tables = strategy.resolve(variable_font)
+      #
+      # @example Use specific named instance
+      #   # Find instance by name first, then use index
+      #   fvar = font.table("fvar")
+      #   bold_index = fvar.instances.find_index { |i| i[:name] =~ /Bold/ }
+      #   strategy = NamedStrategy.new(instance_index: bold_index)
+      #   tables = strategy.resolve(variable_font)
+      class NamedStrategy < BaseStrategy
+        # @return [Integer] Named instance index
+        attr_reader :instance_index
+
+        # Initialize strategy with instance index
+        #
+        # @param options [Hash] Strategy options
+        # @option options [Integer] :instance_index Index of named instance in fvar
+        # @raise [ArgumentError] If instance_index not provided
+        def initialize(options = {})
+          super
+          @instance_index = options[:instance_index]
+
+          if @instance_index.nil?
+            raise ArgumentError, "instance_index is required for NamedStrategy"
+          end
+        end
+
+        # Resolve by using named instance coordinates
+        #
+        # Extracts coordinates from the fvar table's named instance and
+        # delegates to InstanceStrategy for actual instance generation.
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Variable font
+        # @return [Hash<String, String>] Static font tables
+        # @raise [ArgumentError] If instance index is invalid
+        def resolve(font)
+          # Extract coordinates from named instance
+          coordinates = extract_coordinates(font)
+
+          # Use InstanceStrategy to generate instance
+          instance_strategy = InstanceStrategy.new(coordinates: coordinates)
+          instance_strategy.resolve(font)
+        end
+
+        # Check if strategy preserves variation data
+        #
+        # @return [Boolean] Always false for this strategy
+        def preserves_variation?
+          false
+        end
+
+        # Get strategy name
+        #
+        # @return [Symbol] :named
+        def strategy_name
+          :named
+        end
+
+        private
+
+        # Extract coordinates from named instance in fvar table
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Variable font
+        # @return [Hash<String, Float>] Design space coordinates
+        # @raise [ArgumentError] If instance index is invalid
+        def extract_coordinates(font)
+          context = Variation::VariationContext.new(font)
+
+          unless context.fvar
+            raise ArgumentError, "Font is not a variable font (no fvar table)"
+          end
+
+          instances = context.fvar.instances
+          if @instance_index.negative? || @instance_index >= instances.length
+            raise ArgumentError,
+                  "Invalid instance index #{@instance_index}. " \
+                  "Font has #{instances.length} named instances."
+          end
+
+          instance = instances[@instance_index]
+          axes = context.axes
+
+          # Map instance coordinates to axis tags
+          coordinates = {}
+          instance[:coordinates].each_with_index do |value, i|
+            next if i >= axes.length
+
+            axis = axes[i]
+            coordinates[axis.axis_tag] = value
+          end
+
+          coordinates
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/pipeline/strategies/preserve_strategy.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy"
+
+module Fontisan
+  module Pipeline
+    module Strategies
+      # Strategy for preserving variation data during conversion
+      #
+      # This strategy maintains all variation tables intact, making it suitable
+      # for conversions between compatible formats:
+      # - Variable TTF → Variable TTF (same format)
+      # - Variable OTF → Variable OTF (same format)
+      # - Variable TTF → Variable WOFF/WOFF2 (packaging change only)
+      # - Variable OTF → Variable WOFF/WOFF2 (packaging change only)
+      #
+      # The strategy copies all font tables including:
+      # - Variation tables: fvar, gvar/CFF2, avar, HVAR, VVAR, MVAR
+      # - Base tables: All non-variation tables
+      #
+      # @example Preserve variation data
+      #   strategy = PreserveStrategy.new
+      #   tables = strategy.resolve(variable_font)
+      #   # tables includes fvar, gvar, etc.
+      class PreserveStrategy < BaseStrategy
+        # Resolve by preserving all variation data
+        #
+        # Returns all font tables including variation tables. This is a simple
+        # copy operation that maintains the variable font's full capabilities.
+        #
+        # @param font [TrueTypeFont, OpenTypeFont] Variable font
+        # @return [Hash<String, String>] All font tables
+        def resolve(font)
+          # Return a copy of all font tables
+          # This preserves variation tables (fvar, gvar, CFF2, avar, HVAR, etc.)
+          # and all base tables
+          font.table_data.dup
+        end
+
+        # Check if strategy preserves variation data
+        #
+        # @return [Boolean] Always true for this strategy
+        def preserves_variation?
+          true
+        end
+
+        # Get strategy name
+        #
+        # @return [Symbol] :preserve
+        def strategy_name
+          :preserve
+        end
+      end
+    end
+  end
+end