fontisan 0.2.11 → 0.2.13

data/lib/fontisan/conversion_options.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Conversion options for font format transformations
+  #
+  # Defines all options for opening (reading) and generating (writing) fonts
+  # during conversion operations. Includes validation, defaults, and presets.
+  #
+  # @example Using options directly
+  #   options = ConversionOptions.new(
+  #     from: :ttf,
+  #     to: :otf,
+  #     opening: { convert_curves: true, scale_to_1000: true },
+  #     generating: { hinting_mode: "auto" }
+  #   )
+  #
+  # @example Using recommended options
+  #   options = ConversionOptions.recommended(from: :ttf, to: :otf)
+  #
+  # @example Using a preset
+  #   options = ConversionOptions.from_preset(:type1_to_modern)
+  class ConversionOptions
+    # Opening options (input processing)
+    OPENING_OPTIONS = %i[
+      decompose_composites
+      convert_curves
+      scale_to_1000
+      scale_from_1000
+      autohint
+      generate_unicode
+      store_custom_tables
+      store_native_hinting
+      interpret_ot
+      read_all_records
+      preserve_encoding
+    ].freeze
+
+    # Generating options (output processing)
+    GENERATING_OPTIONS = %i[
+      write_pfm
+      write_afm
+      write_inf
+      select_encoding_automatically
+      hinting_mode
+      decompose_on_output
+      write_custom_tables
+      optimize_tables
+      reencode_first_256
+      encoding_vector
+      compression
+      transform_tables
+      preserve_metadata
+      strip_metadata
+      target_format
+    ].freeze
+
+    # Valid hinting modes
+    HINTING_MODES = %w[preserve auto none full].freeze
+
+    # Valid compression modes
+    COMPRESSION_MODES = %w[zlib brotli none].freeze
+
+    attr_reader :from, :to, :opening, :generating
+
+    # Initialize conversion options
+    #
+    # @param from [String, Symbol] Source format
+    # @param to [String, Symbol] Target format
+    # @param opening [Hash] Opening options
+    # @param generating [Hash] Generating options
+    def initialize(from:, to:, opening: {}, generating: {})
+      @from = self.class.normalize_format(from)
+      @to = self.class.normalize_format(to)
+      @opening = apply_opening_defaults(opening)
+      @generating = apply_generating_defaults(generating)
+      validate!
+    end
+
+    # Get recommended options for a conversion pair
+    #
+    # @param from [String, Symbol] Source format
+    # @param to [String, Symbol] Target format
+    # @return [ConversionOptions] Pre-configured options
+    def self.recommended(from:, to:)
+      from_sym = normalize_format(from)
+      to_sym = normalize_format(to)
+
+      options = RECOMMENDED_OPTIONS.dig(from_sym, to_sym) || {}
+      new(
+        from: from_sym,
+        to: to_sym,
+        opening: options[:opening] || {},
+        generating: options[:generating] || {},
+      )
+    end
+
+    # Load options from a named preset
+    #
+    # @param preset_name [Symbol, String] Preset name
+    # @return [ConversionOptions] Pre-configured options
+    def self.from_preset(preset_name)
+      preset_key = preset_name.to_sym
+      preset = PRESETS.fetch(preset_key) do
+        raise ArgumentError, "Unknown preset: #{preset_name}. " \
+                            "Available: #{PRESETS.keys.join(', ')}"
+      end
+
+      new(
+        from: preset[:from],
+        to: preset[:to],
+        opening: preset[:opening] || {},
+        generating: preset[:generating] || {},
+      )
+    end
+
+    # Check if an opening option is set
+    #
+    # @param key [Symbol] Option key
+    # @return [Boolean] true if option is truthy
+    def opening_option?(key)
+      !!@opening[key]
+    end
+
+    # Check if a generating option has a specific value
+    #
+    # @param key [Symbol] Option key
+    # @param value [Object] Value to check
+    # @return [Boolean] true if option equals value
+    def generating_option?(key, value = true)
+      @generating[key] == value
+    end
+
+    # Get list of available presets
+    #
+    # @return [Array<Symbol>] Available preset names
+    def self.available_presets
+      PRESETS.keys
+    end
+
+    private
+
+    # Normalize format symbol
+    #
+    # @param format [String, Symbol] Format identifier
+    # @return [Symbol] Normalized format symbol
+    def self.normalize_format(format)
+      case format.to_s.downcase
+      when "ttf", "truetype", "truetype-tt", "ot-tt" then :ttf
+      when "otf", "cff", "opentype", "ot-ps", "opentype-ps" then :otf
+      when "type1", "type-1", "t1", "pfb", "pfa" then :type1
+      when "ttc" then :ttc
+      when "otc" then :otc
+      when "dfont", "suitcase" then :dfont
+      when "woff" then :woff
+      when "woff2" then :woff2
+      when "svg" then :svg
+      else
+        raise ArgumentError, "Unknown format: #{format}. " \
+                            "Supported: ttf, otf, type1, ttc, otc, dfont, woff, woff2, svg"
+      end
+    end
+
+    # Apply default values for opening options
+    #
+    # @param options [Hash] User-provided options
+    # @return [Hash] Options with defaults applied
+    def apply_opening_defaults(options)
+      defaults = OPENING_DEFAULTS.dig(@from, @to) || {}
+      defaults.merge(options)
+    end
+
+    # Apply default values for generating options
+    #
+    # @param options [Hash] User-provided options
+    # @return [Hash] Options with defaults applied
+    def apply_generating_defaults(options)
+      defaults = GENERATING_DEFAULTS.dig(@from, @to) || {}
+      defaults.merge(options)
+    end
+
+    # Validate options
+    #
+    # @raise [ArgumentError] If options are invalid
+    def validate!
+      validate_opening_options!
+      validate_generating_options!
+    end
+
+    # Validate opening options
+    def validate_opening_options!
+      @opening.each_key do |key|
+        unless OPENING_OPTIONS.include?(key)
+          raise ArgumentError, "Unknown opening option: #{key}. " \
+                              "Available: #{OPENING_OPTIONS.join(', ')}"
+        end
+      end
+    end
+
+    # Validate generating options
+    def validate_generating_options!
+      @generating.each_key do |key|
+        unless GENERATING_OPTIONS.include?(key)
+          raise ArgumentError, "Unknown generating option: #{key}. " \
+                              "Available: #{GENERATING_OPTIONS.join(', ')}"
+        end
+      end
+
+      # Validate hinting_mode
+      if @generating[:hinting_mode]
+        mode = @generating[:hinting_mode].to_s
+        unless HINTING_MODES.include?(mode)
+          raise ArgumentError, "Invalid hinting_mode: #{mode}. " \
+                              "Available: #{HINTING_MODES.join(', ')}"
+        end
+      end
+
+      # Validate compression mode
+      if @generating[:compression]
+        comp = @generating[:compression].to_s
+        unless COMPRESSION_MODES.include?(comp)
+          raise ArgumentError, "Invalid compression: #{comp}. " \
+                              "Available: #{COMPRESSION_MODES.join(', ')}"
+        end
+      end
+
+      # Validate target_format for collection conversions
+      if @generating[:target_format]
+        target = @generating[:target_format].to_s
+        unless ["ttf", "otf", "preserve"].include?(target)
+          raise ArgumentError, "Invalid target_format: #{target}"
+        end
+      end
+    end
+
+    # Default opening options per conversion pair
+    OPENING_DEFAULTS = {
+      ttf: {
+        ttf: { decompose_composites: false, convert_curves: false,
+               store_custom_tables: true },
+        otf: { convert_curves: true, scale_to_1000: true,
+               autohint: true, decompose_composites: false },
+        type1: { convert_curves: true, scale_to_1000: true,
+                 autohint: true, decompose_composites: false },
+      },
+      otf: {
+        ttf: { convert_curves: true, decompose_composites: false,
+               interpret_ot: true },
+        otf: { decompose_composites: false, store_custom_tables: true },
+        type1: { decompose_composites: false },
+      },
+      type1: {
+        ttf: { decompose_composites: false, generate_unicode: true,
+               read_all_records: true },
+        otf: { decompose_composites: false, generate_unicode: true,
+               read_all_records: true },
+      },
+    }.freeze
+
+    # Default generating options per conversion pair
+    GENERATING_DEFAULTS = {
+      ttf: {
+        ttf: { hinting_mode: "preserve", write_custom_tables: true,
+               optimize_tables: true },
+        otf: { hinting_mode: "auto", decompose_on_output: false,
+               write_custom_tables: true },
+        type1: { write_pfm: true, write_afm: true, write_inf: true,
+                 select_encoding_automatically: true, hinting_mode: "auto" },
+      },
+      otf: {
+        ttf: { hinting_mode: "auto", decompose_on_output: false,
+               write_custom_tables: true },
+        otf: { hinting_mode: "preserve", decompose_on_output: false,
+               write_custom_tables: true, optimize_tables: true },
+        type1: { write_pfm: true, write_afm: true, write_inf: true,
+                 select_encoding_automatically: true, hinting_mode: "preserve",
+                 decompose_on_output: false },
+      },
+      type1: {
+        ttf: { hinting_mode: "auto", decompose_on_output: true },
+        otf: { hinting_mode: "preserve", decompose_on_output: true },
+        type1: { write_pfm: true, write_afm: true, write_inf: true,
+                 select_encoding_automatically: true },
+      },
+    }.freeze
+
+    # Recommended options from TypeTool 3 manual
+    # Based on "Options for Converting Fonts" table (lines 6735-6803)
+    RECOMMENDED_OPTIONS = {
+      ttf: {
+        ttf: {
+          opening: { convert_curves: false, scale_to_1000: false,
+                     decompose_composites: false, autohint: false,
+                     store_custom_tables: true, store_native_hinting: true },
+          generating: { hinting_mode: "full", write_custom_tables: true },
+        },
+        otf: {
+          opening: { convert_curves: true, scale_to_1000: true,
+                     autohint: true, decompose_composites: false,
+                     store_custom_tables: true },
+          generating: { hinting_mode: "auto", decompose_on_output: true },
+        },
+        type1: {
+          opening: { convert_curves: true, scale_to_1000: true,
+                     autohint: true, decompose_composites: false,
+                     store_custom_tables: false },
+          generating: { write_pfm: true, write_afm: true, write_inf: true,
+                        select_encoding_automatically: true },
+        },
+      },
+      otf: {
+        ttf: {
+          opening: { decompose_composites: false, read_all_records: true,
+                     interpret_ot: true, store_custom_tables: true,
+                     store_native_hinting: false },
+          generating: { hinting_mode: "full", reencode_first_256: false },
+        },
+        otf: {
+          opening: { decompose_composites: false, store_custom_tables: true },
+          generating: { hinting_mode: "none", decompose_on_output: false,
+                        write_custom_tables: true },
+        },
+        type1: {
+          opening: { decompose_composites: false },
+          generating: { write_pfm: true, write_afm: true, write_inf: true,
+                        select_encoding_automatically: true,
+                        hinting_mode: "none" },
+        },
+      },
+      type1: {
+        ttf: {
+          opening: { decompose_composites: false, generate_unicode: true },
+          generating: { hinting_mode: "full" },
+        },
+        otf: {
+          opening: { decompose_composites: false, generate_unicode: true },
+          generating: { hinting_mode: "none", decompose_on_output: true },
+        },
+        type1: {
+          opening: { decompose_composites: false, generate_unicode: true },
+          generating: { write_pfm: true, write_afm: true, write_inf: true,
+                        select_encoding_automatically: true },
+        },
+      },
+    }.freeze
+
+    # Named presets for common conversion scenarios
+    PRESETS = {
+      type1_to_modern: {
+        from: :type1,
+        to: :otf,
+        opening: { generate_unicode: true, decompose_composites: false },
+        generating: { hinting_mode: "preserve", decompose_on_output: true },
+      },
+      modern_to_type1: {
+        from: :otf,
+        to: :type1,
+        opening: { convert_curves: true, scale_to_1000: true,
+                   autohint: true, decompose_composites: false,
+                   store_custom_tables: false },
+        generating: { write_pfm: true, write_afm: true, write_inf: true,
+                      select_encoding_automatically: true, hinting_mode: "preserve" },
+      },
+      web_optimized: {
+        from: :otf,
+        to: :woff2,
+        opening: {},
+        generating: { compression: "brotli", transform_tables: true,
+                      optimize_tables: true, preserve_metadata: true },
+      },
+      archive_to_modern: {
+        from: :ttc,
+        to: :otf,
+        opening: { convert_curves: true, decompose_composites: false },
+        generating: { target_format: "otf", hinting_mode: "preserve" },
+      },
+    }.freeze
+  end
+end

data/lib/fontisan/converters/collection_converter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../conversion_options"
 require_relative "format_converter"
 require_relative "../collection/builder"
 require_relative "../collection/dfont_builder"
@@ -27,14 +28,15 @@ module Fontisan
     #   converter = CollectionConverter.new
     #   result = converter.convert(ttc_path, target_type: :otc, output: 'family.otc')
     #
-    # @example Convert TTC to OTC with outline conversion
+    # @example Convert with ConversionOptions
+    #   options = ConversionOptions.recommended(from: :ttc, to: :otc)
     #   converter = CollectionConverter.new
-    #   result = converter.convert(ttc_path, target_type: :otc,
-    #                              options: { output: 'family.otc', convert_outlines: true })
+    #   result = converter.convert(ttc_path, target_type: :otc, options: { output: 'family.otc', options: options })
     #
-    # @example Convert dfont to TTC
+    # @example Convert TTC to OTC with outline conversion
     #   converter = CollectionConverter.new
-    #   result = converter.convert(dfont_path, target_type: :ttc, output: 'family.ttc')
+    #   result = converter.convert(ttc_path, target_type: :otc,
+    #                              options: { output: 'family.otc', target_format: 'otf' })
     class CollectionConverter
       # Convert collection to target format
       #
@@ -45,6 +47,7 @@ module Fontisan
       # @option options [String] :target_format Target outline format: 'preserve' (default), 'ttf', or 'otf'
       # @option options [Boolean] :optimize Enable table sharing (default: true, TTC/OTC only)
       # @option options [Boolean] :verbose Enable verbose output (default: false)
+      # @option options [ConversionOptions] :options ConversionOptions object
       # @return [Hash] Conversion result with:
       #   - :input [String] - Input collection path
       #   - :output [String] - Output collection path
@@ -57,9 +60,19 @@ module Fontisan
       def convert(collection_path, target_type:, options: {})
         validate_parameters!(collection_path, target_type, options)
 
+        # Extract ConversionOptions if provided
+        conv_options = extract_conversion_options(options)
+
         verbose = options.fetch(:verbose, false)
         output_path = options[:output]
-        target_format = options.fetch(:target_format, "preserve").to_s
+
+        # Determine target format from ConversionOptions or options hash
+        target_format = if conv_options&.generating_option?(:target_format,
+                                                            "otf")
+                          conv_options.generating[:target_format]
+                        else
+                          options.fetch(:target_format, "preserve").to_s
+                        end
 
         # Validate target_format
         unless %w[preserve ttf otf].include?(target_format)
@@ -84,7 +97,8 @@ module Fontisan
         # Step 2: Convert - transform fonts if requested
         puts "  Converting #{fonts.size} font(s)..." if verbose
         converted_fonts, conversions = convert_fonts(fonts, source_type,
-                                                     target_type, options.merge(target_format: target_format))
+                                                     target_type, options.merge(target_format: target_format),
+                                                     conv_options)
 
         # Step 3: Repack - build target collection
         puts "  Repacking into #{target_type.to_s.upcase} format..." if verbose
@@ -206,13 +220,20 @@ module Fontisan
       # @param source_type [Symbol] Source collection type
       # @param target_type [Symbol] Target collection type
       # @param options [Hash] Conversion options
+      # @param conv_options [ConversionOptions, nil] Conversion options object
       # @return [Array<(Array<Font>, Array<Hash>)>] [converted_fonts, conversions]
-      def convert_fonts(fonts, _source_type, target_type, options)
+      def convert_fonts(fonts, _source_type, target_type, options,
+conv_options = nil)
         converted_fonts = []
         conversions = []
 
         # Determine if outline conversion is needed
-        target_format = options.fetch(:target_format, "preserve").to_s
+        target_format = if conv_options&.generating_option?(:target_format,
+                                                            "otf")
+                          conv_options.generating[:target_format]
+                        else
+                          options.fetch(:target_format, "preserve").to_s
+                        end
 
         fonts.each_with_index do |font, index|
           source_format = detect_font_format(font)
@@ -224,8 +245,12 @@ module Fontisan
             desired_format = target_format == "preserve" ? source_format : target_format.to_sym
             converter = FormatConverter.new
 
+            # Build converter options, including ConversionOptions if provided
+            converter_opts = options.dup
+            converter_opts[:options] = conv_options if conv_options
+
             begin
-              tables = converter.convert(font, desired_format, options)
+              tables = converter.convert(font, desired_format, converter_opts)
               converted_font = build_font_from_tables(tables, desired_format)
               converted_fonts << converted_font
 
@@ -442,6 +467,16 @@ conversions)
 
         puts ""
       end
+
+      # Extract ConversionOptions from options hash
+      #
+      # @param options [Hash, ConversionOptions] Options or hash containing :options key
+      # @return [ConversionOptions, nil] Extracted ConversionOptions or nil
+      def extract_conversion_options(options)
+        return options if options.is_a?(ConversionOptions)
+
+        options[:options] if options.is_a?(Hash)
+      end
     end
   end
 end

data/lib/fontisan/converters/format_converter.rb

@@ -6,6 +6,7 @@ require_relative "outline_converter"
 require_relative "woff_writer"
 require_relative "woff2_encoder"
 require_relative "svg_generator"
+require_relative "type1_converter"
 require "yaml"
 
 module Fontisan
@@ -54,6 +55,7 @@ module Fontisan
         @strategies = [
           TableCopier.new,
           OutlineConverter.new,
+          Type1Converter.new,
           WoffWriter.new,
           Woff2Encoder.new,
           SvgGenerator.new,
@@ -191,9 +193,12 @@ module Fontisan
 
       # Check if font is a variable font
       #
-      # @param font [TrueTypeFont, OpenTypeFont] Font to check
+      # @param font [TrueTypeFont, OpenTypeFont, Type1Font] Font to check
       # @return [Boolean] True if font has fvar table
       def variable_font?(font)
+        # Type 1 fonts are never variable fonts
+        return false if font.is_a?(Type1Font)
+
         font.has_table?("fvar")
       end
 
@@ -341,8 +346,12 @@ _options)
       def validate_parameters!(font, target_format)
         raise ArgumentError, "Font cannot be nil" if font.nil?
 
-        unless font.respond_to?(:table)
-          raise ArgumentError, "Font must respond to :table method"
+        # Type1Font uses a different interface (font_dictionary, charstrings, etc.)
+        # rather than the SFNT table interface
+        is_type1 = font.is_a?(Type1Font)
+
+        unless is_type1 || font.respond_to?(:table)
+          raise ArgumentError, "Font must respond to :table method or be a Type1Font"
         end
 
         unless target_format.is_a?(Symbol)
@@ -392,10 +401,13 @@ _options)
 
       # Detect font format from tables
       #
-      # @param font [TrueTypeFont, OpenTypeFont] Font to detect
-      # @return [Symbol] Format (:ttf or :otf)
+      # @param font [TrueTypeFont, OpenTypeFont, Type1Font] Font to detect
+      # @return [Symbol] Format (:ttf, :otf, or :type1)
       # @raise [Error] If format cannot be detected
       def detect_format(font)
+        # Check for Type1Font first (uses different interface)
+        return :type1 if font.is_a?(Type1Font)
+
         # Check for CFF/CFF2 tables (OpenType/CFF)
         if font.has_table?("CFF ") || font.has_table?("CFF2")
           :otf

data/lib/fontisan/converters/outline_converter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../conversion_options"
 require_relative "conversion_strategy"
 require_relative "../outline_extractor"
 require_relative "../models/outline"
@@ -54,9 +55,10 @@ module Fontisan
     #   converter = Fontisan::Converters::OutlineConverter.new
     #   otf_font = converter.convert(ttf_font, target_format: :otf)
     #
-    # @example Converting OTF to TTF
+    # @example Converting with ConversionOptions
+    #   options = ConversionOptions.recommended(from: :ttf, to: :otf)
     #   converter = Fontisan::Converters::OutlineConverter.new
-    #   ttf_font = converter.convert(otf_font, target_format: :ttf)
+    #   otf_font = converter.convert(ttf_font, options: options)
     #
     # @example Converting with hint preservation
     #   converter = Fontisan::Converters::OutlineConverter.new
@@ -89,19 +91,31 @@ module Fontisan
       # @option options [Boolean] :preserve_variations Keep variation data during conversion (default: true)
       # @option options [Boolean] :generate_instance Generate static instance instead of variable font (default: false)
       # @option options [Hash] :instance_coordinates Axis coordinates for instance generation (default: {})
+      # @option options [ConversionOptions] :options ConversionOptions object
       # @return [Hash<String, String>] Map of table tags to binary data
       def convert(font, options = {})
         @font = font
         @options = options
+
+        # Extract ConversionOptions if provided
+        conv_options = extract_conversion_options(options)
+
         @optimize_cff = options.fetch(:optimize_cff, false)
-        @preserve_hints = options.fetch(:preserve_hints, false)
+        @preserve_hints = options.fetch(:preserve_hints,
+                                        conv_options&.generating_option?(
+                                          :hinting_mode, "preserve"
+                                        ) || false)
         @preserve_variations = options.fetch(:preserve_variations, true)
         @generate_instance = options.fetch(:generate_instance, false)
         @instance_coordinates = options.fetch(:instance_coordinates, {})
-        target_format = options[:target_format] ||
+
+        target_format = options[:target_format] || conv_options&.to ||
           detect_target_format(font)
         validate(font, target_format)
 
+        # Apply opening options to source font
+        apply_opening_options(font, conv_options) if conv_options
+
         source_format = detect_format(font)
 
         # Check if we should generate a static instance instead
@@ -664,6 +678,66 @@ module Fontisan
       def variable_font?(font)
         font.has_table?("fvar")
       end
+
+      # Extract ConversionOptions from options hash
+      #
+      # @param options [Hash, ConversionOptions] Options or hash containing :options key
+      # @return [ConversionOptions, nil] Extracted ConversionOptions or nil
+      def extract_conversion_options(options)
+        return options if options.is_a?(ConversionOptions)
+
+        options[:options] if options.is_a?(Hash)
+      end
+
+      # Apply opening options to source font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Source font
+      # @param conv_options [ConversionOptions] Conversion options with opening options
+      def apply_opening_options(font, conv_options)
+        return unless conv_options
+
+        # Decompose composites if requested
+        if conv_options.opening_option?(:decompose_composites)
+          decompose_composite_glyphs(font)
+        end
+
+        # Interpret OpenType tables if requested
+        if conv_options.opening_option?(:interpret_ot)
+          # Ensure GSUB/GPOS tables are fully loaded
+          interpret_opentype_features(font)
+        end
+
+        # Note: scale_to_1000 and convert_curves are handled during conversion
+        # These options affect the conversion process itself
+      end
+
+      # Decompose composite glyphs in font
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Source font
+      def decompose_composite_glyphs(_font)
+        # Placeholder: Decompose composite glyphs
+        # A full implementation would:
+        # 1. Identify composite glyphs (TrueType: flags & 0x0020, CFF: seac operator)
+        # 2. Extract component outlines
+        # 3. Merge into single glyph
+        #
+        # For now, this is a no-op placeholder
+        nil
+      end
+
+      # Interpret OpenType layout features
+      #
+      # @param font [TrueTypeFont, OpenTypeFont] Source font
+      def interpret_opentype_features(_font)
+        # Placeholder: Interpret GSUB/GPOS tables
+        # A full implementation would:
+        # 1. Parse GSUB table for substitution rules
+        # 2. Parse GPOS table for positioning rules
+        # 3. Store interpreted features for later use
+        #
+        # For now, this is a no-op placeholder
+        nil
+      end
     end
   end
 end