fontisan 0.2.17 → 0.2.23

data/lib/fontisan/commands/optical_size_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../models/optical_size_info"
-
 module Fontisan
   module Commands
     # Command to extract optical size information from fonts

data/lib/fontisan/commands/pack_command.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../collection/builder"
-require_relative "../collection/dfont_builder"
-require_relative "../font_loader"
-
 module Fontisan
   module Commands
     # Command for packing multiple fonts into a TTC/OTC collection

data/lib/fontisan/commands/scripts_command.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "yaml"
-require_relative "base_command"
-require_relative "../models/scripts_info"
 
 module Fontisan
   module Commands

data/lib/fontisan/commands/subset_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../subset/builder"
-require_relative "../subset/options"
 require "fileutils"
 
 module Fontisan

data/lib/fontisan/commands/unicode_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../models/unicode_mappings"
-
 module Fontisan
   module Commands
     # Command to list Unicode to glyph index mappings from a font file

data/lib/fontisan/commands/unpack_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../font_loader"
-require_relative "../font_writer"
 require "fileutils"
 
 module Fontisan
@@ -144,10 +141,8 @@ module Fontisan
           # Load as TTC or OTC based on extension hint
           # Both use same structure, main difference is expected font types
           if ext == ".otc"
-            require_relative "../open_type_collection"
             OpenTypeCollection.read(io)
           else
-            require_relative "../true_type_collection"
             TrueTypeCollection.read(io)
           end
         end
@@ -252,8 +247,6 @@ module Fontisan
       # @param output_path [String] Output file path
       # @return [void]
       def convert_and_write(font, output_path)
-        require_relative "../converters/format_converter"
-
         converter = Converters::FormatConverter.new
         converter.convert(font, @format, output_path: output_path)
       rescue StandardError => e

data/lib/fontisan/commands/validate_command.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../validators/profile_loader"
-require_relative "../font_loader"
-require_relative "../tables/name"
-
 module Fontisan
   module Commands
     # ValidateCommand provides CLI interface for font validation
@@ -138,9 +133,6 @@ module Fontisan
       # @param mode [Symbol] Loading mode
       # @return [Integer] Exit code
       def validate_collection(mode)
-        require_relative "../models/collection_validation_report"
-        require_relative "../models/font_report"
-
         # Load collection metadata
         collection = FontLoader.load_collection(@input)
 

data/lib/fontisan/commands/variable_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../variation/inspector"
-
 module Fontisan
   module Commands
     # Command to extract variable font information.

data/lib/fontisan/commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Commands namespace.
+
+module Fontisan
+  module Commands
+    autoload :BaseCommand, "fontisan/commands/base_command"
+    autoload :ConvertCommand, "fontisan/commands/convert_command"
+    autoload :DumpTableCommand, "fontisan/commands/dump_table_command"
+    autoload :ExportCommand, "fontisan/commands/export_command"
+    autoload :FeaturesCommand, "fontisan/commands/features_command"
+    autoload :GlyphsCommand, "fontisan/commands/glyphs_command"
+    autoload :InfoCommand, "fontisan/commands/info_command"
+    autoload :InstanceCommand, "fontisan/commands/instance_command"
+    autoload :LsCommand, "fontisan/commands/ls_command"
+    autoload :OpticalSizeCommand, "fontisan/commands/optical_size_command"
+    autoload :PackCommand, "fontisan/commands/pack_command"
+    autoload :ScriptsCommand, "fontisan/commands/scripts_command"
+    autoload :SubsetCommand, "fontisan/commands/subset_command"
+    autoload :TablesCommand, "fontisan/commands/tables_command"
+    autoload :UnicodeCommand, "fontisan/commands/unicode_command"
+    autoload :UnpackCommand, "fontisan/commands/unpack_command"
+    autoload :ValidateCommand, "fontisan/commands/validate_command"
+    autoload :VariableCommand, "fontisan/commands/variable_command"
+  end
+end

data/lib/fontisan/config/cldr.yml

@@ -0,0 +1,22 @@
+# UCD alternative: CLDR (Common Locale Data Repository) configuration.
+#
+# This file is the single source of truth for which CLDR version Fontisan
+# uses by default, what versions are recognized, and where to fetch them.
+#
+# Update `default_version` and `known_versions` when a new CLDR release
+# ships (typically 2× per year, alongside Unicode releases).
+# Users override at runtime via `fontisan cldr download --version X.Y.Z`
+# or `fontisan audit --cldr-version X.Y.Z`.
+
+default_version: "46.0.0"
+
+known_versions:
+  - "45.0.0"
+  - "46.0.0"
+
+# CLDR JSON releases are published on GitHub.
+# Full URL: <base_url>/<version>/cldr-<version>-json-full.zip
+base_url: "https://github.com/unicode-org/cldr-json/releases/download"
+
+# Releases listing URL for `--latest` probing. JSON API.
+listing_url: "https://api.github.com/repos/unicode-org/cldr-json/releases"

data/lib/fontisan/config/conversion_matrix.yml

@@ -174,6 +174,25 @@ conversions:
       WOFF decompression with zlib. Preserves all font data and metadata.
       Automatically detects font flavor from WOFF header.
 
+  - from: woff
+    to: woff2
+    strategy: woff_reader
+    description: "Transcode WOFF to WOFF2 (re-wrap with Brotli)"
+    status: implemented
+    notes: >
+      Web-format transcoding. The pipeline decodes WOFF (zlib) into its
+      underlying SFNT tables, then re-wraps them as WOFF2 with Brotli.
+      Useful for migrating legacy web fonts to the smaller WOFF2 format.
+
+  - from: woff
+    to: svg
+    strategy: svg_generator
+    description: "Generate SVG font from WOFF"
+    status: implemented
+    notes: >
+      Decodes WOFF (zlib) to SFNT tables, then renders glyph outlines as
+      SVG paths. Note: SVG fonts are deprecated in favor of WOFF2.
+
   # Phase 2 conversions (Milestone 2.2) - SVG
   - from: ttf
     to: svg
@@ -254,6 +273,25 @@ conversions:
       Same-format copy operation. Decompresses and re-compresses WOFF2 data
       with Brotli, useful for normalizing compression or updating metadata.
 
+  - from: woff2
+    to: woff
+    strategy: woff2_decoder
+    description: "Transcode WOFF2 to WOFF (re-wrap with zlib)"
+    status: implemented
+    notes: >
+      Web-format transcoding. The pipeline decodes WOFF2 (Brotli) into its
+      underlying SFNT tables, then re-wraps them as WOFF with zlib. Useful
+      for legacy browser compatibility where WOFF2 is unavailable.
+
+  - from: woff2
+    to: svg
+    strategy: svg_generator
+    description: "Generate SVG font from WOFF2"
+    status: implemented
+    notes: >
+      Decodes WOFF2 (Brotli) to SFNT tables, then renders glyph outlines as
+      SVG paths. Note: SVG fonts are deprecated in favor of WOFF2.
+
   # Collection format conversions (TTC/OTC/dfont)
   # Same-format collection operations
   - from: ttc

data/lib/fontisan/constants.rb

@@ -89,6 +89,9 @@ module Fontisan
     # Fvar table tag identifier (Font Variations)
     FVAR_TAG = "fvar"
 
+    # Avar table tag identifier (Axis Variation)
+    AVAR_TAG = "avar"
+
     # Gvar table tag identifier (Glyph Variations for TrueType)
     GVAR_TAG = "gvar"
 
@@ -129,6 +132,22 @@ module Fontisan
     # Control Value Table (metrics used by TrueType hinting)
     CVT_TAG = "cvt "
 
+    # Grid-fitting And Scan-conversion Procedure table (per-ppem hinting policy)
+    GASP_TAG = "gasp"
+
+    # Color font tables.
+    # COLR: COLR vector color glyph table (v0 or v1).
+    # CPAL: Color Palette table.
+    # SVG:  SVG-in-OpenType color glyph table (tag is "SVG " — 4 bytes incl. trailing space).
+    # CBDT/CBLC: Color Bitmap Data / Location (paired — EBLC/EBDT equivalents for color).
+    # sbix: Apple bitmap glyph table.
+    COLR_TAG = "COLR"
+    CPAL_TAG = "CPAL"
+    SVG_TAG  = "SVG "
+    CBDT_TAG = "CBDT"
+    CBLC_TAG = "CBLC"
+    SBIX_TAG = "sbix"
+
     # Magic number used for font file checksum adjustment calculation.
     # This constant is used in conjunction with the file checksum to compute
     # the checksumAdjustment value stored in the 'head' table.

data/lib/fontisan/conversion_options.rb

@@ -35,8 +35,12 @@ module Fontisan
       preserve_encoding
     ].freeze
 
-    # Generating options (output processing)
-    GENERATING_OPTIONS = %i[
+    # Generating options (output processing) declared statically by
+    # ConversionOptions itself. Format-specific compression knobs (zlib_level,
+    # brotli_quality, transform_tables, etc.) are declared by each strategy
+    # via the ConversionStrategy DSL and discovered via
+    # FormatConverter.all_strategy_option_names — see `.generating_options`.
+    STATIC_GENERATING_OPTIONS = %i[
       write_pfm
       write_afm
       write_inf
@@ -47,19 +51,28 @@ module Fontisan
       optimize_tables
       reencode_first_256
       encoding_vector
-      compression
-      transform_tables
       preserve_metadata
       strip_metadata
       target_format
     ].freeze
 
+    # Full list of recognized generating options, computed lazily because
+    # converters `require_relative` this file, creating a load cycle that
+    # prevents resolving `FormatConverter` at class-definition time. The first
+    # call resolves all strategies (which are loaded before any conversion
+    # actually runs) and caches the result.
+    #
+    # @return [Array<Symbol>]
+    def self.generating_options
+      @generating_options ||= (
+        STATIC_GENERATING_OPTIONS +
+        Converters::FormatConverter.all_strategy_option_names
+      ).uniq.freeze
+    end
+
     # 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
@@ -199,9 +212,9 @@ module Fontisan
     # Validate generating options
     def validate_generating_options!
       @generating.each_key do |key|
-        unless GENERATING_OPTIONS.include?(key)
+        unless self.class.generating_options.include?(key)
           raise ArgumentError, "Unknown generating option: #{key}. " \
-                              "Available: #{GENERATING_OPTIONS.join(', ')}"
+                              "Available: #{self.class.generating_options.join(', ')}"
         end
       end
 
@@ -214,15 +227,6 @@ module Fontisan
         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
@@ -364,9 +368,16 @@ module Fontisan
         from: :otf,
         to: :woff2,
         opening: {},
-        generating: { compression: "brotli", transform_tables: true,
+        generating: { brotli_quality: 11, transform_tables: true,
                       optimize_tables: true, preserve_metadata: true },
       },
+      legacy_web: {
+        from: :otf,
+        to: :woff,
+        opening: {},
+        generating: { zlib_level: 9, optimize_tables: true,
+                      preserve_metadata: true },
+      },
       archive_to_modern: {
         from: :ttc,
         to: :otf,

data/lib/fontisan/converters/cff_table_builder.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../tables/cff/index_builder"
-require_relative "../tables/cff/dict_builder"
-
 module Fontisan
   module Converters
     # Builds CFF table data from glyph outlines

data/lib/fontisan/converters/collection_converter.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../conversion_options"
-require_relative "format_converter"
-require_relative "../collection/builder"
-require_relative "../collection/dfont_builder"
-require_relative "../parsers/dfont_parser"
-require_relative "../font_loader"
-
 module Fontisan
   module Converters
     # CollectionConverter handles conversion between collection formats
@@ -343,7 +336,6 @@ conv_options = nil)
       # @return [Font] Font object
       def build_font_from_tables(tables, format)
         # Create temporary font from tables
-        require_relative "../font_writer"
         require "stringio"
 
         sfnt_version = format == :otf ? 0x4F54544F : 0x00010000

data/lib/fontisan/converters/conversion_strategy.rb

@@ -2,45 +2,171 @@
 
 module Fontisan
   module Converters
-    # Interface module for font format conversion strategies
+    # Interface module and declarative options DSL for conversion strategies
     #
     # [`ConversionStrategy`](lib/fontisan/converters/conversion_strategy.rb)
-    # defines the contract that all conversion strategy classes must implement.
-    # This follows the Strategy pattern to enable polymorphic handling of
-    # different conversion types (TTF→OTF, OTF→TTF, same-format copying).
+    # defines the contract that all conversion strategy classes must implement,
+    # plus a declarative DSL for declaring the options each strategy accepts.
     #
-    # Each strategy must implement:
-    # - convert(font, options) - Perform the actual conversion
-    # - supported_conversions - Return array of [source, target] format pairs
-    # - validate(font, target_format) - Validate conversion is possible
+    # ## Why a declarative options DSL
     #
-    # Strategies are selected by [`FormatConverter`](lib/fontisan/converters/format_converter.rb)
-    # based on source and target formats.
+    # Each format has its own spec-mandated knobs (WOFF: zlib level,
+    # WOFF2: Brotli quality, etc.). Letting each strategy declare its own
+    # options keeps the schema with the code that consumes it (encapsulation),
+    # and makes adding a new format a pure additive change (OCP): write a new
+    # strategy class, declare its options, done — no edits to central option
+    # lists, the CLI option parser, or ConversionOptions.
     #
-    # @example Implementing a strategy
-    #   class MyStrategy
-    #     include Fontisan::Converters::ConversionStrategy
+    # The strategy is also the sole validator of its own options. The
+    # runtime check at `FormatConverter#convert` calls
+    # `strategy.class.validate_options!` to enforce the format ↔ option
+    # mapping (e.g., rejecting `--zlib-level` on a WOFF2 conversion). This
+    # is the MECE guarantee: every option belongs to exactly one strategy,
+    # and a strategy rejects anything it did not declare.
     #
-    #     def convert(font, options = {})
-    #       # Perform conversion
-    #       tables = {...}
-    #       tables
-    #     end
+    # @example Declaring options
+    #   class WoffWriter
+    #     include ConversionStrategy
     #
-    #     def supported_conversions
-    #       [[:ttf, :otf], [:otf, :ttf]]
-    #     end
+    #     option :zlib_level, type: :integer, range: 0..9, default: 6,
+    #            cli: "--zlib-level", desc: "zlib compression level"
+    #     option :uncompressed, type: :boolean, default: false,
+    #            cli: "--uncompressed", desc: "store tables uncompressed"
     #
-    #     def validate(font, target_format)
-    #       # Validate font can be converted
-    #       raise Error unless valid
+    #     def convert(font, options = {})
+    #       self.class.validate_options!(options)
+    #       # ...
     #     end
     #   end
     module ConversionStrategy
-      # Convert font to target format
+      # Declarative description of a single strategy option.
+      # `allowed_values` is spelled out (not `values`) to avoid shadowing
+      # Struct#values.
+      Option = Struct.new(:name, :type, :default, :cli, :desc, :range,
+                          :allowed_values, keyword_init: true)
+
+      # Class methods mixed into including classes via `included`.
+      module ClassMethods
+        # Declare an option this strategy accepts.
+        #
+        # @param name [Symbol] Option name (the hash key used in `convert`)
+        # @param type [Symbol] One of :integer, :boolean, :string
+        # @param default [Object] Default value when the caller omits the option
+        # @param cli [String] CLI flag shape (for help text generation)
+        # @param desc [String] Human-readable description
+        # @param range [Range, nil] For :integer; valid range
+        # @param values [Array, nil] For :string; allowed values
+        # @return [void]
+        def option(name, type:, default:, cli:, desc:, range: nil, values: nil)
+          declared_options << Option.new(
+            name: name, type: type, default: default, cli: cli, desc: desc,
+            range: range, allowed_values: values
+          )
+        end
+
+        # All options declared by this class.
+        #
+        # @return [Array<Option>]
+        def declared_options
+          @declared_options ||= []
+        end
+
+        # Public accessor: the full list of options for this strategy.
+        alias supported_options declared_options
+
+        # Find the option schema for a given key (symbol or string).
+        #
+        # @param name [Symbol, String]
+        # @return [Option, nil]
+        def option_for(name)
+          supported_options.find { |o| o.name == name.to_sym }
+        end
+
+        # Default values for every declared option.
+        #
+        # @return [Hash{Symbol => Object}]
+        def default_options
+          supported_options.to_h { |o| [o.name, o.default] }
+        end
+
+        # Validate a user-provided options hash against this strategy's schema.
+        #
+        # Raises ArgumentError for any unknown key, wrong type, or
+        # out-of-range value. Called by FormatConverter after strategy
+        # selection, so cross-format misuse (e.g., `--zlib-level` on a
+        # WOFF2 conversion) is caught here.
+        #
+        # @param user_options [Hash{Symbol, String => Object}]
+        # @return [void]
+        # @raise [ArgumentError] if any key is unknown or any value is invalid
+        def validate_options!(user_options)
+          user_options.each_key do |key|
+            opt = option_for(key)
+            next if opt
+
+            names = supported_options.map(&:name)
+            list = names.empty? ? "(none)" : names.join(", ")
+            raise ArgumentError,
+                  "Unknown option #{key.inspect} for #{name}. " \
+                  "Supported: #{list}"
+          end
+
+          user_options.each do |key, value|
+            opt = option_for(key)
+            validate_option_value!(opt, value) unless value.nil?
+          end
+        end
+
+        private
+
+        # Type-check a single value against its declared schema.
+        #
+        # @param opt [Option]
+        # @param value [Object]
+        # @return [void]
+        # @raise [ArgumentError] if value fails type or range/values check
+        def validate_option_value!(opt, value)
+          case opt.type
+          when :integer
+            unless value.is_a?(Integer)
+              raise ArgumentError,
+                    "#{opt.name} must be an Integer, got #{value.inspect} " \
+                    "(#{value.class})"
+            end
+            return unless opt.range && !opt.range.cover?(value)
+
+            raise ArgumentError,
+                  "#{opt.name} must be in #{opt.range}, got #{value}"
+          when :boolean
+            return if [true, false].include?(value)
+
+            raise ArgumentError,
+                  "#{opt.name} must be true or false, got #{value.inspect}"
+          when :string
+            unless value.is_a?(String)
+              raise ArgumentError,
+                    "#{opt.name} must be a String, got #{value.class}"
+            end
+            return unless opt.allowed_values && !opt.allowed_values.include?(value)
+
+            raise ArgumentError,
+                  "#{opt.name} must be one of #{opt.allowed_values.join(', ')}, " \
+                  "got #{value.inspect}"
+          else
+            raise "Unknown option type #{opt.type.inspect} on #{opt.name}"
+          end
+        end
+      end
+
+      # Mix ClassMethods into any class that includes this module.
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Convert font to target format.
       #
-      # This method must return a hash of table tags to binary data,
-      # which will be assembled into a complete font by FontWriter.
+      # Strategies must implement this. Subclasses should call
+      # `self.class.validate_options!(options)` first to enforce their schema.
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font
       # @param options [Hash] Conversion options
@@ -51,30 +177,19 @@ module Fontisan
               "#{self.class.name} must implement convert(font, options)"
       end
 
-      # Get list of supported conversions
-      #
-      # Returns an array of [source_format, target_format] pairs that
-      # this strategy can handle.
+      # Get list of supported conversions.
       #
-      # @return [Array<Array<Symbol>>] Supported conversion pairs
+      # @return [Array<Array<Symbol>>] Supported [source, target] pairs
       # @raise [NotImplementedError] If not implemented by strategy
-      #
-      # @example
-      #   strategy.supported_conversions
-      #   # => [[:ttf, :otf], [:otf, :ttf]]
       def supported_conversions
         raise NotImplementedError,
               "#{self.class.name} must implement supported_conversions"
       end
 
-      # Validate that conversion is possible
-      #
-      # Checks if the given font can be converted to the target format.
-      # Should raise an error with a clear message if conversion is not
-      # possible.
+      # Validate that conversion is possible.
       #
       # @param font [TrueTypeFont, OpenTypeFont] Font to validate
-      # @param target_format [Symbol] Target format (:ttf, :otf, etc.)
+      # @param target_format [Symbol] Target format
       # @return [Boolean] True if valid
       # @raise [Error] If conversion is not possible
       # @raise [NotImplementedError] If not implemented by strategy
@@ -83,11 +198,11 @@ module Fontisan
               "#{self.class.name} must implement validate(font, target_format)"
       end
 
-      # Check if strategy supports a conversion
+      # Check if strategy supports a given conversion.
       #
-      # @param source_format [Symbol] Source format
-      # @param target_format [Symbol] Target format
-      # @return [Boolean] True if supported
+      # @param source_format [Symbol]
+      # @param target_format [Symbol]
+      # @return [Boolean]
       def supports?(source_format, target_format)
         supported_conversions.include?([source_format, target_format])
       end