fontisan 0.2.17 → 0.2.23

data/lib/fontisan/cldr/unicode_set_parser.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # Parses ICU UnicodeSet bracket notation as used in CLDR
+    # exemplarCharacters fields.
+    #
+    # Supported syntax (sufficient for exemplar sets):
+    #   - Single chars: `a`, `à`, any BMP or supplementary codepoint
+    #   - Ranges: `a-z`, `A-Z`
+    #   - Escapes: `\uXXXX`, `\UXXXXXXXX`, `\u{XXXX...}`
+    #   - Negation: `[^...]` (inverts against 0..0x10FFFF)
+    #
+    # Unsupported (CLDR exemplars do not use these; raise ParseError):
+    #   - Property syntax `[:script=Latin:]`
+    #   - Set operations `[a-z & [b-c]]`
+    #   - Nested sets `[a[b-c]]`
+    #   - Named sequences `{a b c}`
+    #
+    # Output: sorted, deduplicated Array<Integer> of codepoints.
+    module UnicodeSetParser
+      class ParseError < Cldr::Error; end
+      MAX_CODEPOINT = 0x10FFFF
+      private_constant :MAX_CODEPOINT
+
+      module_function
+
+      # @param set_string [String] bracketed ICU UnicodeSet, e.g. "[a-zà]"
+      # @return [Array<Integer>] sorted, deduplicated codepoints
+      def call(set_string)
+        unless set_string.start_with?("[") && set_string.end_with?("]")
+          raise ParseError,
+                "input must be bracketed"
+        end
+
+        body = set_string[1..-2]
+        negate = body.start_with?("^")
+        body = body[1..] if negate
+
+        cps = parse_body(body)
+        cps = invert(cps) if negate
+        cps.sort.uniq
+      end
+
+      # Walk the body char by char, emitting codepoints and ranges.
+      def parse_body(body)
+        cps = []
+        chars = body.chars.to_a
+        i = 0
+        prev_cp = nil
+
+        while i < chars.length
+          ch = chars[i]
+
+          case ch
+          when "\\"
+            cp, advance = parse_escape(chars, i)
+            cps << cp
+            prev_cp = cp
+            i += advance
+          when "-"
+            raise ParseError, "dangling '-' at start" if prev_cp.nil?
+            raise ParseError, "dangling '-' at end" if i + 1 >= chars.length
+
+            next_cp, advance = read_next_codepoint(chars, i + 1)
+            raise ParseError, "range with no upper bound" if next_cp.nil?
+
+            cps.concat(((prev_cp + 1)..next_cp).to_a)
+            prev_cp = next_cp
+            i += 1 + advance
+          when "[", "]"
+            raise ParseError, "nested set syntax is not supported"
+          when "{"
+            raise ParseError, "named sequences ({...}) are not supported"
+          when ":"
+            raise ParseError, "property syntax ([:...:]) is not supported"
+          else
+            cps << ch.ord
+            prev_cp = ch.ord
+            i += 1
+          end
+        end
+
+        cps
+      end
+      private_class_method :parse_body
+
+      # Read the next codepoint starting at index `start`. Handles escapes.
+      # @return [Array(Integer, Integer)] codepoint + chars consumed, or
+      #   [nil, 0] if no codepoint is available.
+      def read_next_codepoint(chars, start)
+        return [nil, 0] if start >= chars.length
+
+        ch = chars[start]
+        if ch == "\\"
+          parse_escape(chars, start)
+        else
+          [ch.ord, 1]
+        end
+      end
+      private_class_method :read_next_codepoint
+
+      # Parse a backslash escape sequence.
+      # Supports \uXXXX, \UXXXXXXXX, \u{XXXX...}, and standard backslash
+      # escapes (\\, \[, \], \-, \^).
+      # @return [Array(Integer, Integer)] codepoint + chars consumed
+      def parse_escape(chars, start)
+        # chars[start] is "\\"
+        return [0, 1] if start + 1 >= chars.length
+
+        marker = chars[start + 1]
+        case marker
+        when "u"
+          brace_form(chars, start) || four_hex(chars, start, "u")
+        when "U"
+          eight_hex(chars, start)
+        when "\\"
+          [0x5C, 2]
+        when "[", "]", "-", "^"
+          [marker.ord, 2]
+        else
+          raise ParseError, "unknown escape sequence \\#{marker}"
+        end
+      end
+      private_class_method :parse_escape
+
+      def brace_form(chars, start)
+        return nil unless chars[start + 2] == "{"
+
+        # \u{XXX...} variable hex
+        end_idx = (start + 3..).find do |j|
+          j >= chars.length || chars[j] == "}"
+        end
+        if end_idx.nil? || chars[end_idx] != "}"
+          raise ParseError,
+                "unclosed \\u{ escape"
+        end
+
+        hex = chars[(start + 3)...end_idx].join
+        cp = hex.to_i(16)
+        raise ParseError, "\\u{ escape with no digits" if cp.zero? && hex.empty?
+
+        [cp, (end_idx - start) + 1]
+      end
+      private_class_method :brace_form
+
+      def four_hex(chars, start, marker)
+        # \uXXXX — exactly 4 hex digits
+        hex = chars[(start + 2), 4]&.join
+        if hex.nil? || hex.length < 4
+          raise ParseError,
+                "truncated \\#{marker} escape"
+        end
+
+        cp = hex.to_i(16)
+        if cp.zero? && !hex.match?(/\A0+\z/)
+          raise ParseError,
+                "\\#{marker} escape with non-hex digits"
+        end
+
+        [cp, 6]
+      end
+      private_class_method :four_hex
+
+      def eight_hex(chars, start)
+        # \UXXXXXXXX — exactly 8 hex digits
+        hex = chars[(start + 2), 8]&.join
+        raise ParseError, "truncated \\U escape" if hex.nil? || hex.length < 8
+
+        cp = hex.to_i(16)
+        if cp.zero? && !hex.match?(/\A0+\z/)
+          raise ParseError,
+                "\\U escape with non-hex digits"
+        end
+
+        [cp, 10]
+      end
+      private_class_method :eight_hex
+
+      def invert(cps)
+        set = cps.to_set
+        (0..MAX_CODEPOINT).each_with_object([]) do |cp, arr|
+          arr << cp unless set.include?(cp)
+        end
+      end
+      private_class_method :invert
+    end
+  end
+end

data/lib/fontisan/cldr/unknown_version_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Cldr
+    # Raised by Cldr::VersionResolver when a user-supplied version string
+    # is not in Cldr::Config.known_versions.
+    class UnknownVersionError < Cldr::Error; end
+  end
+end

data/lib/fontisan/cldr/version_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "rubygems"
+
+module Fontisan
+  module Cldr
+    # Resolves a user-supplied version intent to a concrete CLDR version.
+    #
+    # Three input modes:
+    #
+    #   resolve(nil)           # default_version from config
+    #   resolve(:default)      # default_version from config
+    #   resolve("46.0.0")      # explicit; validated against known_versions
+    #   resolve(:latest)       # probes GitHub releases, picks highest;
+    #                          # falls back to default on failure
+    module VersionResolver
+      GITHUB_RELEASE_TAG = %r{ref/tags/(\d+(?:\.\d+)+)}
+      private_constant :GITHUB_RELEASE_TAG
+
+      class << self
+        # @param intent [nil, :default, :latest, String]
+        # @return [String] a concrete version string
+        def resolve(intent)
+          case intent
+          when nil, :default
+            Config.default_version
+          when :latest
+            probe_latest
+          else
+            validate!(intent)
+            intent
+          end
+        end
+
+        # Raise UnknownVersionError unless `version` is in known_versions.
+        # @param version [String]
+        # @return [void]
+        def validate!(version)
+          return if Config.known?(version)
+
+          raise UnknownVersionError,
+                "CLDR version #{version.inspect} is not recognized. " \
+                "Known versions: #{Config.known_versions.join(', ')}"
+        end
+
+        private
+
+        # Best-effort probe of the GitHub releases API for cldr-json.
+        # Returns the highest semver found among tagged releases, or
+        # Config.default_version on any failure.
+        def probe_latest
+          versions = fetch_release_versions
+          return fallback_latest("releases listing was empty") if versions.empty?
+
+          highest = versions.max_by { |v| Gem::Version.new(v) }
+          if Config.known?(highest)
+            highest
+          else
+            fallback_latest("#{highest.inspect} is not in known_versions; using default")
+          end
+        rescue StandardError => e
+          fallback_latest(e.message)
+        end
+
+        def fallback_latest(reason)
+          warn "Cldr::VersionResolver: --latest probe failed (#{reason}); " \
+               "falling back to default #{Config.default_version.inspect}"
+          Config.default_version
+        end
+
+        def fetch_release_versions
+          uri = URI(Config.listing_url)
+          response = Net::HTTP.get_response(uri)
+          return [] unless response.is_a?(Net::HTTPSuccess)
+
+          releases = JSON.parse(response.body || "[]")
+          releases.filter_map do |release|
+            tag = release["tag_name"]
+            next unless tag
+
+            match = tag.match(/\A(\d+(?:\.\d+)+)\z/)
+            match && match[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/cldr.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Namespace hub for CLDR (Common Locale Data Repository) support.
+#
+# Provides per-language exemplar character sets so the audit can
+# compute "this font covers X% of language Y". All Cldr::* constants
+# are autoloaded from here.
+
+module Fontisan
+  module Cldr
+    autoload :Config,              "fontisan/cldr/config"
+    autoload :CacheManager,        "fontisan/cldr/cache_manager"
+    autoload :Downloader,          "fontisan/cldr/downloader"
+    autoload :VersionResolver,     "fontisan/cldr/version_resolver"
+    autoload :IndexBuilder,        "fontisan/cldr/index_builder"
+    autoload :Index,               "fontisan/cldr/index"
+    autoload :Aggregator,          "fontisan/cldr/aggregator"
+    autoload :UnicodeSetParser,    "fontisan/cldr/unicode_set_parser"
+    autoload :Error,               "fontisan/cldr/error"
+    autoload :DownloadError,       "fontisan/cldr/download_error"
+    autoload :UnknownVersionError, "fontisan/cldr/unknown_version_error"
+  end
+end

data/lib/fontisan/cli/cldr_cli.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Fontisan
+  # Thor subcommand for managing the local CLDR (Common Locale Data
+  # Repository) cache used by `fontisan audit` for per-language coverage.
+  #
+  #   fontisan cldr download [VERSION]   fetch + index CLDR exemplars
+  #   fontisan cldr status               show what's cached
+  #   fontisan cldr path [VERSION]       print local cache path
+  #   fontisan cldr list                 list known versions
+  #   fontisan cldr remove VERSION       delete a cached version
+  #
+  # With no arguments, `download` resolves the configured default version
+  # (see lib/fontisan/config/cldr.yml).
+  class CldrCli < Thor
+    desc "download [VERSION]",
+         "Download and index CLDR exemplar characters (default: configured default version)"
+    option :force, type: :boolean, default: false,
+                   desc: "Re-download even if already cached"
+    option :latest, type: :boolean, default: false,
+                    desc: "Probe GitHub releases for the latest version"
+    def download(version = nil)
+      intent = resolve_intent(version, options[:latest])
+      actual = Cldr::VersionResolver.resolve(intent)
+
+      Cldr::Downloader.download(actual, force: options[:force])
+      Cldr::IndexBuilder.build(actual) unless index_present?(actual)
+      puts "CLDR #{actual} ready at: #{Cldr::CacheManager.version_dir(actual)}"
+    rescue Cldr::Error => e
+      warn "ERROR: #{e.message}"
+      exit 1
+    end
+
+    desc "status", "Show cached CLDR versions and default version"
+    def status
+      cached = Cldr::CacheManager.cached_versions
+      puts "Default version: #{Cldr::Config.default_version}"
+      puts "Cache root:      #{Cldr::CacheManager.root}"
+      puts "Cached versions: #{cached.empty? ? '(none)' : cached.join(', ')}"
+    end
+
+    desc "path [VERSION]", "Print local cache directory for a version"
+    def path(version = nil)
+      actual = Cldr::VersionResolver.resolve(version)
+      puts Cldr::CacheManager.version_dir(actual)
+    rescue Cldr::UnknownVersionError => e
+      warn "ERROR: #{e.message}"
+      exit 1
+    end
+
+    desc "list", "List CLDR versions known to this Fontisan release"
+    def list
+      Cldr::Config.known_versions.each { |v| puts v }
+    end
+
+    desc "remove VERSION", "Remove a cached CLDR version"
+    def remove(version)
+      Cldr::VersionResolver.validate!(version)
+      unless Cldr::CacheManager.cached?(version)
+        warn "Version #{version} is not cached; nothing to remove."
+        return
+      end
+
+      Cldr::CacheManager.remove_version(version)
+      puts "Removed CLDR #{version}."
+    rescue Cldr::UnknownVersionError => e
+      warn "ERROR: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def resolve_intent(version, latest)
+      return :latest if latest && version.nil?
+
+      version
+    end
+
+    def index_present?(version)
+      Cldr::CacheManager.languages_index_path(version).exist?
+    end
+  end
+end

data/lib/fontisan/cli.rb

@@ -25,6 +25,9 @@ module Fontisan
                          desc: "Suppress non-error output",
                          aliases: "-q"
 
+    desc "cldr", "Manage local CLDR cache (subcommands)", hide: true
+    subcommand "cldr", CldrCli
+
     desc "info PATH", "Display font information"
     option :brief, type: :boolean, default: false,
                    desc: "Brief mode - only essential info (5x faster, uses metadata loading)",
@@ -203,7 +206,9 @@ module Fontisan
 
     desc "convert FONT_FILE", "Convert font to different format"
     option :to, type: :string, required: true,
-                desc: "Target format (ttf, otf, type1, t1, woff, woff2)",
+                desc: "Target format: ttf, otf, type1, t1, ttc, otc, dfont, svg, " \
+                      "woff (zlib — works on all browsers incl. legacy), " \
+                      "woff2 (Brotli — ~30% smaller, modern browsers only)",
                 aliases: "-t"
     option :output, type: :string,
                     desc: "Output file path (required unless --show-options)",
@@ -255,6 +260,19 @@ module Fontisan
                              desc: "Enable table optimization"
     option :decompose_on_output, type: :boolean,
                                  desc: "Decompose on output (generating option)"
+    # Compression knobs — declared by each strategy (single source of truth:
+    # Converters::* strategies). Cross-format misuse is caught at convert time
+    # by FormatConverter.validate_options_for_target! with a clear ArgumentError.
+    option :zlib_level, type: :numeric,
+                        desc: "WOFF only: zlib compression level (0–9, default 6)"
+    option :uncompressed, type: :boolean,
+                          desc: "WOFF only: store tables uncompressed (legal per WOFF 1.0 §5.1)"
+    option :compression_threshold, type: :numeric,
+                                   desc: "WOFF only: skip compression for tables smaller than N bytes (default 100)"
+    option :brotli_quality, type: :numeric,
+                            desc: "WOFF2 only: Brotli quality (0–11, default 11)"
+    option :transform_tables, type: :boolean,
+                              desc: "WOFF2 only: apply glyf/loca and hmtx transformations"
     # Convert a font to a different format using the universal transformation pipeline.
     #
     # Supported conversions:
@@ -264,6 +282,14 @@ module Fontisan
     # - Variable fonts: Automatic variation preservation or instance generation
     # - Collections (TTC/OTC/dfont): Preserve mixed TTF+OTF by default, or standardize with --target-format
     #
+    # Web fonts — WOFF vs WOFF2:
+    # WOFF uses zlib compression and works on every browser that supports
+    # web fonts at all (IE9+, all evergreen browsers). WOFF2 uses Brotli and
+    # is ~30% smaller but requires modern browsers (Chrome 36+, Firefox 39+,
+    # Safari 12+, Edge 14+). Old browsers cannot decode Brotli, so for legacy
+    # support serve WOFF. Tune knobs with --zlib-level / --brotli-quality /
+    # --uncompressed (WOFF only) / --transform-tables (WOFF2 only).
+    #
     # Collection Format Support:
     # TTC, OTC, and dfont all support mixed TrueType and OpenType fonts. By default, original font formats
     # are preserved during collection conversion (--target-format preserve). Use --target-format ttf to
@@ -678,6 +704,10 @@ module Fontisan
       puts output unless options[:quiet]
     end
 
+    def serialize_report(report, format)
+      format == :json ? report.to_json : report.to_yaml
+    end
+
     # Format result as human-readable text.
     #
     # @param result [Object] The result object to format
@@ -720,7 +750,6 @@ module Fontisan
     #
     # @return [void]
     def list_available_tests
-      require_relative "validators/profile_loader"
       profiles = Validators::ProfileLoader.all_profiles
       puts "Available validation profiles:"
       profiles.each do |profile_name, config|

data/lib/fontisan/collection/builder.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "table_analyzer"
-require_relative "table_deduplicator"
-require_relative "offset_calculator"
-require_relative "writer"
 require "yaml"
 
 module Fontisan

data/lib/fontisan/collection/dfont_builder.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../font_writer"
-require_relative "../error"
-require_relative "../validation/collection_validator"
-
 module Fontisan
   module Collection
     # DfontBuilder creates Apple dfont (Data Fork Font) resource fork structures

data/lib/fontisan/collection/shared_logic.rb

@@ -15,8 +15,6 @@ module Fontisan
       # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Array of fonts
       # @return [Models::TableSharingInfo] Sharing statistics
       def calculate_table_sharing_for_fonts(fonts)
-        require_relative "../models/table_sharing_info"
-
         # Build table hash map (checksum -> size)
         table_map = {}
         total_table_size = 0

data/lib/fontisan/collection/writer.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../constants"
-require_relative "../utilities/checksum_calculator"
-
 module Fontisan
   module Collection
     # CollectionWriter writes binary TTC/OTC files

data/lib/fontisan/collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Collection namespace.
+
+module Fontisan
+  module Collection
+    autoload :Builder, "fontisan/collection/builder"
+    autoload :DfontBuilder, "fontisan/collection/dfont_builder"
+    autoload :OffsetCalculator, "fontisan/collection/offset_calculator"
+    autoload :SharedLogic, "fontisan/collection/shared_logic"
+    autoload :TableAnalyzer, "fontisan/collection/table_analyzer"
+    autoload :TableDeduplicator, "fontisan/collection/table_deduplicator"
+    autoload :Writer, "fontisan/collection/writer"
+  end
+end

data/lib/fontisan/commands/base_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../font_loader"
-require_relative "../error"
-
 module Fontisan
   module Commands
     # Abstract base class for all CLI commands.

data/lib/fontisan/commands/convert_command.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../pipeline/transformation_pipeline"
-require_relative "../converters/collection_converter"
-require_relative "../conversion_options"
-require_relative "../font_loader"
-
 module Fontisan
   module Commands
     # Command for converting fonts between formats
@@ -67,29 +61,33 @@ module Fontisan
       def initialize(font_path, options = {})
         super(font_path, options)
 
-        # Convert string keys to symbols for Thor compatibility
-        opts = options.transform_keys(&:to_sym)
+        # Convert string keys to symbols for Thor compatibility. All command
+        # code reads @options with symbol keys (e.g., @options[:quiet]);
+        # normalizing once at construction is cleaner than threading a
+        # second opts hash alongside @options.
+        @options = options.transform_keys(&:to_sym)
 
-        @output_path = opts[:output]
+        @output_path = @options[:output]
 
         # Parse target format
-        @target_format = parse_target_format(opts[:to])
+        @target_format = parse_target_format(@options[:to])
 
         # Extract ConversionOptions if provided
-        @conv_options = extract_conversion_options(opts)
+        @conv_options = extract_conversion_options(@options)
 
         # Parse coordinates if string provided
-        @coordinates = if opts[:coordinates]
-                         parse_coordinates(opts[:coordinates])
-                       elsif opts[:instance_coordinates]
-                         opts[:instance_coordinates]
+        @coordinates = if @options[:coordinates]
+                         parse_coordinates(@options[:coordinates])
+                       elsif @options[:instance_coordinates]
+                         @options[:instance_coordinates]
                        end
 
-        @instance_index = opts[:instance_index]
-        @preserve_variation = opts[:preserve_variation]
-        @preserve_hints = opts.fetch(:preserve_hints, false)
-        @collection_target_format = opts.fetch(:target_format, "preserve").to_s
-        @validate = !opts[:no_validate]
+        @instance_index = @options[:instance_index]
+        @preserve_variation = @options[:preserve_variation]
+        @preserve_hints = @options.fetch(:preserve_hints, false)
+        @collection_target_format = @options.fetch(:target_format,
+                                                   "preserve").to_s
+        @validate = !@options[:no_validate]
       end
 
       # Execute the conversion
@@ -152,6 +150,13 @@ module Fontisan
         # Add hint preservation option
         pipeline_options[:preserve_hints] = @preserve_hints if @preserve_hints
 
+        # Forward format-specific compression knobs declared by strategies
+        # (zlib_level, brotli_quality, etc.). Cross-format misuse is caught
+        # downstream by FormatConverter.validate_options_for_target!.
+        Converters::FormatConverter.all_strategy_option_names.each do |opt|
+          pipeline_options[opt] = @options[opt] if @options.key?(opt)
+        end
+
         # Use TransformationPipeline for universal conversion
         pipeline = Pipeline::TransformationPipeline.new(
           font_path,

data/lib/fontisan/commands/dump_table_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../font_loader"
-require_relative "../error"
-
 module Fontisan
   module Commands
     # Command to dump raw table data from fonts

data/lib/fontisan/commands/export_command.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base_command"
-require_relative "../export/exporter"
-require_relative "../font_loader"
-
 module Fontisan
   module Commands
     # ExportCommand provides CLI interface for font export to YAML/JSON

data/lib/fontisan/commands/features_command.rb

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

data/lib/fontisan/commands/instance_command.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "base_command"
-require_relative "../variation/instance_generator"
-require_relative "../variation/instance_writer"
-require_relative "../variation/validator"
-require_relative "../error"
 
 module Fontisan
   module Commands

data/lib/fontisan/commands/ls_command.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../font_loader"
-require_relative "../models/collection_list_info"
-require_relative "../models/font_summary"
-require_relative "../tables/name"
-require_relative "../error"
-
 module Fontisan
   module Commands
     # Command to list contents of font files (collections or individual fonts).