fontisan 0.2.0 → 0.2.1

data/lib/fontisan/open_type_font.rb

@@ -258,6 +258,20 @@ module Fontisan
       true
     end
 
+    # Check if font is TrueType flavored
+    #
+    # @return [Boolean] false for OpenType fonts
+    def truetype?
+      false
+    end
+
+    # Check if font is CFF flavored
+    #
+    # @return [Boolean] true for OpenType fonts
+    def cff?
+      true
+    end
+
     # Check if font has a specific table
     #
     # @param tag [String] The table tag to check for
@@ -490,6 +504,7 @@ module Fontisan
         Constants::OS2_TAG => Tables::Os2,
         Constants::POST_TAG => Tables::Post,
         Constants::CMAP_TAG => Tables::Cmap,
+        Constants::CFF_TAG => Tables::Cff,
         Constants::FVAR_TAG => Tables::Fvar,
         Constants::GSUB_TAG => Tables::Gsub,
         Constants::GPOS_TAG => Tables::Gpos,
@@ -558,18 +573,19 @@ module Fontisan
     # @param path [String] Path to the OTF file
     # @return [void]
     def update_checksum_adjustment_in_file(path)
-      # Calculate file checksum
-      checksum = Utilities::ChecksumCalculator.calculate_file_checksum(path)
+      # Use tempfile-based checksum calculation for Windows compatibility
+      # This keeps the tempfile alive until we're done with the checksum
+      File.open(path, "r+b") do |io|
+        checksum, _tmpfile = Utilities::ChecksumCalculator.calculate_checksum_from_io_with_tempfile(io)
 
-      # Calculate adjustment
-      adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)
+        # Calculate adjustment
+        adjustment = Utilities::ChecksumCalculator.calculate_adjustment(checksum)
 
-      # Find head table position
-      head_entry = head_table
-      return unless head_entry
+        # Find head table position
+        head_entry = head_table
+        return unless head_entry
 
-      # Write adjustment to head table (offset 8 within head table)
-      File.open(path, "r+b") do |io|
+        # Write adjustment to head table (offset 8 within head table)
         io.seek(head_entry.offset + 8)
         io.write([adjustment].pack("N"))
       end

data/lib/fontisan/open_type_font_extensions.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Extensions to OpenTypeFont for table-based construction
+  class OpenTypeFont
+    # Create font from hash of tables
+    #
+    # This is used during font conversion when we have tables but not a file.
+    #
+    # @param tables [Hash<String, String>] Map of table tag to binary data
+    # @return [OpenTypeFont] New font instance
+    def self.from_tables(tables)
+      # Create minimal header structure
+      font = new
+      font.initialize_storage
+      font.loading_mode = LoadingModes::FULL
+
+      # Store table data
+      font.table_data = tables
+
+      # Build header from tables
+      num_tables = tables.size
+      max_power = 0
+      n = num_tables
+      while n > 1
+        n >>= 1
+        max_power += 1
+      end
+
+      search_range = (1 << max_power) * 16
+      entry_selector = max_power
+      range_shift = (num_tables * 16) - search_range
+
+      font.header.sfnt_version = 0x4F54544F # 'OTTO' for OpenType/CFF
+      font.header.num_tables = num_tables
+      font.header.search_range = search_range
+      font.header.entry_selector = entry_selector
+      font.header.range_shift = range_shift
+
+      # Build table directory
+      font.tables.clear
+      tables.each_key do |tag|
+        entry = TableDirectory.new
+        entry.tag = tag
+        entry.checksum = 0 # Will be calculated on write
+        entry.offset = 0 # Will be calculated on write
+        entry.table_length = tables[tag].bytesize
+        font.tables << entry
+      end
+
+      font
+    end
+  end
+end

data/lib/fontisan/pipeline/format_detector.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "../font_loader"
+
+module Fontisan
+  module Pipeline
+    # Detects font format and capabilities
+    #
+    # This class analyzes font files to determine:
+    # - Format: TTF, OTF, TTC, OTC, WOFF, WOFF2, SVG
+    # - Variation type: static, gvar (TrueType variable), CFF2 (OpenType variable)
+    # - Capabilities: outline type, variation support, collection support
+    #
+    # Used by the universal transformation pipeline to determine conversion
+    # strategies and validate compatibility.
+    #
+    # @example Detecting a font's format
+    #   detector = FormatDetector.new("font.ttf")
+    #   info = detector.detect
+    #   puts info[:format]        # => :ttf
+    #   puts info[:variation_type] # => :gvar
+    #   puts info[:capabilities][:outline] # => :truetype
+    class FormatDetector
+      # @return [String] Path to font file
+      attr_reader :file_path
+
+      # @return [TrueTypeFont, OpenTypeFont, TrueTypeCollection, OpenTypeCollection, nil] Loaded font
+      attr_reader :font
+
+      # Initialize detector
+      #
+      # @param file_path [String] Path to font file
+      def initialize(file_path)
+        @file_path = file_path
+        @font = nil
+      end
+
+      # Detect format and capabilities
+      #
+      # @return [Hash] Detection results with :format, :variation_type, :capabilities
+      def detect
+        load_font
+
+        {
+          format: detect_format,
+          variation_type: detect_variation,
+          capabilities: detect_capabilities,
+        }
+      end
+
+      # Detect font format
+      #
+      # @return [Symbol] One of :ttf, :otf, :ttc, :otc, :woff, :woff2, :svg
+      def detect_format
+        # Check for SVG first (from file extension even if font failed to load)
+        return :svg if @file_path.end_with?(".svg")
+
+        return :unknown unless @font
+
+        # Use is_a? for proper class checking
+        case @font
+        when Fontisan::TrueTypeCollection
+          :ttc
+        when Fontisan::OpenTypeCollection
+          :otc
+        when Fontisan::TrueTypeFont
+          if @file_path.end_with?(".woff")
+            :woff
+          elsif @file_path.end_with?(".woff2")
+            :woff2
+          else
+            :ttf
+          end
+        when Fontisan::OpenTypeFont
+          if @file_path.end_with?(".woff")
+            :woff
+          elsif @file_path.end_with?(".woff2")
+            :woff2
+          else
+            :otf
+          end
+        else
+          :unknown
+        end
+      end
+
+      # Detect variation type
+      #
+      # @return [Symbol] One of :static, :gvar, :cff2
+      def detect_variation
+        return :static unless @font
+
+        # Collections don't have has_table? method
+        # Return :static for collections (variation detection would need to load first font)
+        return :static if collection?
+
+        # Check for variable font tables
+        if @font.has_table?("fvar")
+          # Variable font detected - check variation type
+          if @font.has_table?("gvar")
+            :gvar # TrueType variable font
+          elsif @font.has_table?("CFF2")
+            :cff2 # OpenType variable font (CFF2)
+          else
+            :static # Has fvar but no variation data (shouldn't happen)
+          end
+        else
+          :static
+        end
+      end
+
+      # Detect font capabilities
+      #
+      # @return [Hash] Capabilities hash
+      def detect_capabilities
+        return default_capabilities unless @font
+
+        # Check if this is a collection
+        is_collection = collection?
+
+        font_to_check = if is_collection
+                          # Collections don't have fonts method, need to load first font
+                          nil # Will handle in API usage
+                        else
+                          @font
+                        end
+
+        # For collections, return basic capabilities
+        if is_collection
+          return {
+            outline: :unknown, # Would need to load first font to know
+            variation: false,  # Would need to load first font to know
+            collection: true,
+            tables: [],
+          }
+        end
+
+        return default_capabilities unless font_to_check
+
+        {
+          outline: detect_outline_type(font_to_check),
+          variation: detect_variation != :static,
+          collection: false,
+          tables: available_tables(font_to_check),
+        }
+      end
+
+      # Check if font is a collection
+      #
+      # @return [Boolean] True if collection (TTC/OTC)
+      def collection?
+        @font.is_a?(Fontisan::TrueTypeCollection) ||
+          @font.is_a?(Fontisan::OpenTypeCollection)
+      end
+
+      # Check if font is variable
+      #
+      # @return [Boolean] True if variable font
+      def variable?
+        detect_variation != :static
+      end
+
+      # Check if format is compatible with target
+      #
+      # @param target_format [Symbol] Target format (:ttf, :otf, etc.)
+      # @return [Boolean] True if conversion is possible
+      def compatible_with?(target_format)
+        current_format = detect_format
+        variation_type = detect_variation
+
+        # Same format is always compatible
+        return true if current_format == target_format
+
+        # Collection formats
+        if %i[ttc otc].include?(current_format)
+          return %i[ttc otc].include?(target_format)
+        end
+
+        # Variable font constraints
+        if variation_type == :static
+          # Static fonts can convert to any format
+          true
+        else
+          case variation_type
+          when :gvar
+            # TrueType variable can convert to TrueType formats
+            %i[ttf ttc woff woff2].include?(target_format)
+          when :cff2
+            # OpenType variable can convert to OpenType formats
+            %i[otf otc woff woff2].include?(target_format)
+          end
+        end
+      end
+
+      private
+
+      # Load font from file
+      def load_font
+        # Check if it's a collection first
+        @font = if FontLoader.collection?(@file_path)
+                  FontLoader.load_collection(@file_path)
+                else
+                  FontLoader.load(@file_path, mode: :full)
+                end
+      rescue StandardError => e
+        warn "Failed to load font: #{e.message}"
+        @font = nil
+      end
+
+      # Detect outline type
+      #
+      # @param font [Font] Font object
+      # @return [Symbol] :truetype or :cff
+      def detect_outline_type(font)
+        if font.has_table?("glyf") || font.has_table?("gvar")
+          :truetype
+        elsif font.has_table?("CFF ") || font.has_table?("CFF2")
+          :cff
+        else
+          :unknown
+        end
+      end
+
+      # Get available tables
+      #
+      # @param font [Font] Font object
+      # @return [Array<String>] List of table tags
+      def available_tables(font)
+        return [] unless font.respond_to?(:table_names)
+
+        font.table_names
+      rescue StandardError
+        []
+      end
+
+      # Default capabilities when font cannot be loaded
+      #
+      # @return [Hash] Default capabilities
+      def default_capabilities
+        {
+          outline: :unknown,
+          variation: false,
+          collection: false,
+          tables: [],
+        }
+      end
+    end
+  end
+end

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