fontisan 0.2.0 → 0.2.2

data/lib/fontisan/open_type_font.rb

@@ -211,7 +211,8 @@ module Fontisan
           batch_entries.each do |entry|
             relative_offset = entry.offset - batch_offset
             tag_key = entry.tag.dup.force_encoding("UTF-8")
-            @table_data[tag_key] = batch_data[relative_offset, entry.table_length]
+            @table_data[tag_key] =
+              batch_data[relative_offset, entry.table_length]
           end
         end
 
@@ -258,6 +259,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
@@ -272,6 +287,7 @@ module Fontisan
     # @return [Boolean] true if table is available in current mode
     def table_available?(tag)
       return false unless has_table?(tag)
+
       LoadingModes.table_allowed?(@loading_mode, tag)
     end
 
@@ -490,6 +506,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 +575,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/optimizers/pattern_analyzer.rb

@@ -222,7 +222,8 @@ module Fontisan
                 if @stack_aware
                   tracker = @stack_trackers[glyph_id]
                   next unless tracker
-                  next unless tracker.stack_neutral?(start_pos, start_pos + length)
+                  next unless tracker.stack_neutral?(start_pos,
+                                                     start_pos + length)
                 end
 
                 pattern_bytes = charstring[start_pos, length]

data/lib/fontisan/optimizers/subroutine_generator.rb

@@ -74,7 +74,7 @@ module Fontisan
         # 2. Analyze patterns
         analyzer = PatternAnalyzer.new(
           min_length: @min_pattern_length,
-          stack_aware: true
+          stack_aware: true,
         )
         patterns = analyzer.analyze(charstrings)
 

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,159 @@
+# 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"]
+        unless svg_xml
+          raise ArgumentError,
+                "SVG result must contain :svg_xml key"
+        end
+
+        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