fontisan 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9957716f86dad58d8ff9b5f0bc49bc7044ab20f073bd26b5b87f09d8a5aa1cb1
-  data.tar.gz: 5ac5083c8db47532bc1331c82209c02bc6d8b7095b8f2c27c41fecced8230b32
+  metadata.gz: 5a519f7a53629decc2b968e9c99b5979459fe33c49750aa851818a330e6fd6af
+  data.tar.gz: 805f840f58f042288c34610fa355b1be74b428a8669abc15188c08e635494148
 SHA512:
-  metadata.gz: e1fa7608f49e922735d6b677456cbf4864ced9a32e3e771960229f685208c67be6079f9b1bfcfc6f393c83bf8d5b7e0e158c397b618080229a14dd274718724e
-  data.tar.gz: 730148059f3819b6dd49c1f8b86ab9d2e4d8508671b54b59cc240e638472b0da0dd5e5b7187f30b09bbd12d8e149a93903097068a45ac281224f2482464fa2ea
+  metadata.gz: 06edc2ca7cf97a919095afee9b5bc7327d0f01f4ce304c537f1ac4a920dd7950cce67beaba34d0bf93aa99d6cb21c385ad5238c8077d7aebd87545a8c35437eb
+  data.tar.gz: 8a43a243ad4aeae715f63bf94c5e907d07b2330f59b4b37f3bfafa1ee8af063796c8ab84547f92b674f46340bfb5c96686e7b25b88f490f18ff77848c7c30d6a

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Removed
+
+- Audit/UCD documentation residue from the v0.3.0 audit/UCD subsystem
+  removal: deleted `docs/cli/audit.md`, dropped the "🔍 Font Audit"
+  feature card and "Font Audit" sidebar group, removed audit entries
+  from `docs/cli/index.md`. No behavior change.
+- CLDR subsystem (`Fontisan::Cldr`, `Models::Cldr::LanguageCoverage`,
+  `lib/fontisan/config/cldr.yml`) and the `fontisan cldr` CLI
+  subcommand. CLDR was added in TODO 21 as infrastructure for
+  `fontisan audit`'s per-language coverage extractor; with the audit
+  subsystem moved to ucode (v0.3.0), CLDR had no remaining consumer
+  in fontisan. Not released in a published gem version.
+
 ### Added
 
 - `Stitcher` explicit subfont declaration model: every `include_*`

data/docs/.vitepress/config.ts

@@ -263,13 +263,6 @@ export default defineConfig({
             { text: "Overview", link: "/cli/" },
           ],
         },
-        {
-          text: "Font Audit",
-          collapsed: true,
-          items: [
-            { text: "audit", link: "/cli/audit" },
-          ],
-        },
         {
           text: "Font Information",
           collapsed: true,

data/docs/cli/index.md

@@ -20,18 +20,6 @@ Always check your font's End User License Agreement (EULA) before processing. Ma
 
 ## Quick Reference
 
-### Font Audit
-
-| Command | Description | Example |
-|---------|-------------|---------|
-| `audit` | Comprehensive per-face audit (replaces `otfinfo`) | `fontisan audit font.ttf` |
-
-The `audit` command covers identity, style, metrics, codepoint coverage,
-licensing, hinting, color capabilities, variable-font detail, and
-OpenType layout — and supports collections, `--compare` mode, and
-whole-library `--recursive --summary` mode. See
-[audit](/cli/audit) for details.
-
 ### Font Information Commands
 
 | Command | Description | Example |
@@ -179,19 +167,11 @@ fontisan validate font.ttf --profile production
 
 ### Audit a Font (or Library)
 
-```bash
-# Full per-face audit
-fontisan audit font.ttf
-
-# Diff two fonts (or saved reports)
-fontisan audit --compare baseline.yaml new.ttf
-
-# Whole-library summary
-fontisan audit lib/ --recursive --summary
-
-# Fast inventory pass
-fontisan audit lib/ --recursive --summary --brief
-```
+The `audit` and `ucd` commands have been removed from fontisan. The
+audit/UCD subsystem moved to the
+[ucode](https://github.com/fontist/ucode) gem. For per-face font
+metadata, use [`info`](/cli/info); for pass/fail quality checks, use
+[`validate`](/cli/validate).
 
 ### Export Font Data
 
@@ -210,9 +190,6 @@ fontisan export font.ttf --format ttx --tables head,name,cmap
 
 Detailed documentation for each command:
 
-### Font Audit
-- [audit](/cli/audit) — Comprehensive per-face audit (replaces `otfinfo`); supports collections, compare, library summary
-
 ### Font Information
 - [info](/cli/info) — Extract font metadata and properties (includes brief mode)
 - [ls](/cli/ls) — List fonts in collections

data/docs/index.md

@@ -18,8 +18,6 @@ hero:
       link: /guide/migrations/fonttools
 
 features:
-  - title: "🔍 Font Audit"
-    details: Comprehensive per-face audit (replaces otfinfo) — identity, style, metrics, coverage, licensing, hinting, color, variation, OpenType layout, UCD/CLDR aggregation, compare, and library-summary modes.
   - title: "🔄 Font Conversion"
     details: Convert between TTF, OTF, WOFF, WOFF2, Type 1 (PFB/PFA), and SVG formats with curve conversion and optimization.
   - title: "✅ Font Validation"

data/lib/fontisan/cli.rb

@@ -25,9 +25,6 @@ module Fontisan
                          desc: "Suppress non-error output",
                          aliases: "-q"
 
-    desc "cldr", "Manage local CLDR cache (subcommands)", hide: true
-    subcommand "cldr", CldrCli
-
     desc "ufo", "UFO source operations (build, convert, validate)"
     subcommand "ufo", Fontisan::Ufo::Cli
 
@@ -211,10 +208,12 @@ module Fontisan
     end
 
     desc "convert FONT_FILE", "Convert font to different format"
-    option :to, type: :string, required: true,
-                desc: "Target format: ttf, otf, type1, t1, ttc, otc, dfont, svg, " \
+    option :to, type: :array, required: true,
+                desc: "Target format(s): ttf, otf, type1, t1, ttc, otc, dfont, svg, " \
                       "woff (zlib — works on all browsers incl. legacy), " \
-                      "woff2 (Brotli — ~30% smaller, modern browsers only)",
+                      "woff2 (Brotli — ~30% smaller, modern browsers only). " \
+                      "Pass multiple times (--to woff --to woff2) or comma-separated " \
+                      "(--to woff,woff2) for multi-format output.",
                 aliases: "-t"
     option :output, type: :string,
                     desc: "Output file path (required unless --show-options)",
@@ -361,7 +360,7 @@ module Fontisan
 
       # Handle --show-options
       if options[:show_options]
-        show_recommended_options(source_format, options[:to])
+        show_recommended_options(source_format, options[:to].is_a?(Array) ? options[:to].first : options[:to])
         return
       end
 
@@ -371,7 +370,8 @@ module Fontisan
       end
 
       # Build ConversionOptions
-      conv_options = build_conversion_options(source_format, options[:to],
+      conv_options = build_conversion_options(source_format,
+                                              Array(options[:to]).first,
                                               options)
 
       # Build instance coordinates from axis options
@@ -573,6 +573,27 @@ module Fontisan
       exit command.run
     end
 
+    desc "validate-collection PATH",
+         "Validate a TTC/OTC/dfont (face count, glyph cap, cmap union)"
+    option :expected_faces, type: :numeric,
+                            desc: "Required face count"
+    option :max_glyphs, type: :numeric, default: Fontisan::Commands::ValidateCollectionCommand::DEFAULT_MAX_GLYPHS,
+                        desc: "Per-face glyph cap"
+    option :expected_cmap_union, type: :numeric,
+                                 desc: "Minimum cmap union size across all faces"
+    def validate_collection(path)
+      cmd = Commands::ValidateCollectionCommand.new(
+        input: path,
+        expected_faces: options[:expected_faces],
+        max_glyphs: options[:max_glyphs],
+        expected_cmap_union: options[:expected_cmap_union],
+      )
+      exit cmd.run
+    rescue ArgumentError => e
+      warn "ERROR: #{e.message}"
+      exit 1
+    end
+
     desc "version", "Display version information"
     # Display the Fontisan version.
     def version

data/lib/fontisan/collection/reader/stats.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Collection
+    class Reader
+      # Snapshot of one face's headline metrics. Pure value object —
+      # no methods beyond accessors. Separate file from {Reader} so
+      # the Stats struct can be referenced without pulling in the
+      # full Reader (and its FontLoader dependency).
+      #
+      # @!attribute [r] index
+      #   @return [Integer] 0-based face index inside the collection
+      # @!attribute [r] glyph_count
+      #   @return [Integer] face's maxp.numGlyphs
+      # @!attribute [r] codepoint_count
+      #   @return [Integer] count of keys in face's cmap unicode_mappings
+      # @!attribute [r] sfnt_version
+      #   @return [Integer] face sfnt version (0x00010000 for TTF, 0x4F54544F for OTF)
+      Stats = Struct.new(:index, :glyph_count, :codepoint_count, :sfnt_version,
+                         keyword_init: true)
+    end
+  end
+end

data/lib/fontisan/collection/reader.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Collection
+    # Read-only counterpart to {Builder}. Opens an existing TTC/OTC/dfont
+    # and exposes per-face metadata (glyph count, codepoint count, sfnt
+    # version) and the cmap union across all faces.
+    #
+    # Delegates header parsing to {FontLoader} — never hand-rolls the
+    # TTC header bytes (that would duplicate BaseCollection.from_file
+    # and only handle TTC/OTC, not dfont).
+    #
+    # @example Per-face glyph counts
+    #   reader = Collection::Reader.open("family.ttc")
+    #   reader.stats.map { |s| [s.index, s.glyph_count] }
+    #
+    # @example Cmap union
+    #   Collection::Reader.open("family.otc").cmap_union.size
+    class Reader
+      autoload :Stats, "fontisan/collection/reader/stats"
+
+      # @!attribute [r] path
+      #   @return [String] the file path this reader was opened with
+      attr_reader :path
+
+      # Collection formats this reader accepts. Single source of truth —
+      # matches {FontLoader::COLLECTION_CLASSES}.
+      FORMATS = %i[ttc otc dfont].freeze
+
+      # @param path [String] path to a TTC/OTC/dfont file
+      # @raise [ArgumentError] if the file is not a recognized collection
+      def initialize(path)
+        @path = path
+        detected = FontLoader.detect_format(path)
+        unless FORMATS.include?(detected)
+          raise ArgumentError,
+                "#{path} is not a TTC/OTC/dfont (detected: #{detected.inspect})"
+        end
+
+        @collection = FontLoader.load_collection(path)
+      end
+
+      # Convenience constructor.
+      # @param path [String]
+      # @return [Reader]
+      def self.open(path)
+        new(path)
+      end
+
+      # @return [Integer] number of faces in the collection
+      def face_count
+        @collection.num_fonts
+      end
+
+      # Yields each face as a loaded TTF/OTF font. Without a block,
+      # returns an Enumerator (so callers can chain +each_with_index+).
+      # The Enumerator's size is set to +face_count+ so size-based
+      # assertions work without consuming it.
+      #
+      # @yieldparam face [TrueTypeFont, OpenTypeFont]
+      # @return [Enumerator, void]
+      def each_face
+        return enum_for(:each_face) { face_count } unless block_given?
+
+        face_count.times { |i| yield FontLoader.load(@path, font_index: i) }
+      end
+
+      # @return [Array<Stats>] one Stats per face, in face-index order
+      def stats
+        each_face.map.with_index do |face, i|
+          Stats.new(
+            index: i,
+            glyph_count: face.table("maxp")&.num_glyphs || 0,
+            codepoint_count: (face.table("cmap")&.unicode_mappings || {}).size,
+            sfnt_version: face.header.sfnt_version,
+          )
+        end
+      end
+
+      # Union of every face's cmap keys.
+      #
+      # @return [Set<Integer>]
+      def cmap_union
+        each_face.with_object(Set.new) do |face, union|
+          union.merge((face.table("cmap")&.unicode_mappings || {}).keys)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/collection.rb

@@ -7,6 +7,7 @@ module Fontisan
     autoload :Builder, "fontisan/collection/builder"
     autoload :DfontBuilder, "fontisan/collection/dfont_builder"
     autoload :OffsetCalculator, "fontisan/collection/offset_calculator"
+    autoload :Reader, "fontisan/collection/reader"
     autoload :SharedLogic, "fontisan/collection/shared_logic"
     autoload :TableAnalyzer, "fontisan/collection/table_analyzer"
     autoload :TableDeduplicator, "fontisan/collection/table_deduplicator"

data/lib/fontisan/commands/convert_command.rb

@@ -42,11 +42,20 @@ module Fontisan
     #   )
     #   command.run
     class ConvertCommand < BaseCommand
+      # Public readers for the parsed target formats and per-format output
+      # paths. Exposed (rather than relying on @ivar access from specs) so
+      # multi-format behaviour can be tested through the public surface.
+      attr_reader :target_formats, :output_paths
+
       # Initialize convert command
       #
       # @param font_path [String] Path to input font file
       # @param options [Hash] Conversion options
-      # @option options [String] :to Target format (ttf, otf, woff, woff2)
+      # @option options [String, Array<String>] :to Target format(s):
+      #   ttf, otf, woff, woff2, type1, ttc, otc, dfont, svg. Pass a
+      #   comma-separated string ("woff,woff2") or an array (["woff",
+      #   "woff2"]) for multi-format output. Single-font → single-font
+      #   only; multi-format + collection input is rejected.
       # @option options [String] :output Output file path (required)
       # @option options [Integer] :font_index Index for TTC/OTC (default: 0)
       # @option options [String] :coordinates Coordinate string (e.g., "wght=700,wdth=100")
@@ -69,8 +78,13 @@ module Fontisan
 
         @output_path = @options[:output]
 
-        # Parse target format
-        @target_format = parse_target_format(@options[:to])
+        # Parse target format(s). Always an Array<Symbol>, deduped, order
+        # preserved. Single-format callsites get a one-element array.
+        @target_formats = parse_target_formats(@options[:to])
+
+        # Resolve per-format output paths up front so filename ambiguity
+        # surfaces before any pipeline work is done.
+        @output_paths = resolve_output_paths
 
         # Extract ConversionOptions if provided
         @conv_options = extract_conversion_options(@options)
@@ -92,17 +106,26 @@ module Fontisan
 
       # Execute the conversion
       #
-      # @return [Hash] Result information
+      # @return [Hash, Array<Hash>] Result information. Single-format
+      #   returns one result hash (back-compat). Multi-format returns
+      #   an array of result hashes, one per target format.
       # @raise [ArgumentError] If output path is not specified
       # @raise [Error] If conversion fails
       def run
         validate_options!
 
-        # Check if input is a collection
         if collection_file?
+          if multi_format?
+            raise ArgumentError,
+                  "Multi-format conversion is not supported for collection " \
+                  "input. Specify a single target format."
+          end
+
           convert_collection
+        elsif multi_format?
+          convert_multi_format
         else
-          convert_single_font
+          convert_single_font(@target_formats.first, @output_paths.first)
         end
       rescue ArgumentError
         # Let ArgumentError propagate for validation errors
@@ -113,6 +136,11 @@ module Fontisan
 
       private
 
+      # @return [Boolean] true when more than one target format was given
+      def multi_format?
+        @target_formats.size > 1
+      end
+
       # Check if input file is a collection
       #
       # @return [Boolean] true if collection
@@ -123,15 +151,36 @@ module Fontisan
         false
       end
 
-      # Convert a single font (original implementation)
+      # Convert to each target format and aggregate results.
       #
+      # @return [Array<Hash>]
+      def convert_multi_format
+        unless @options[:quiet]
+          puts "Converting #{File.basename(font_path)} to " \
+               "#{@target_formats.join(', ')}..."
+        end
+
+        @target_formats.zip(@output_paths).map do |fmt, out_path|
+          result = convert_single_font(fmt, out_path)
+          unless @options[:quiet]
+            puts "  #{fmt}: wrote #{File.basename(out_path)} " \
+                 "(#{format_size(File.size(out_path))})"
+          end
+          result
+        end
+      end
+
+      # Convert a single font to a single target format at +out_path+.
+      #
+      # @param target_format [Symbol]
+      # @param out_path [String]
       # @return [Hash] Result information
-      def convert_single_font
-        puts "Converting #{File.basename(font_path)} to #{@target_format}..." unless @options[:quiet]
+      def convert_single_font(target_format, out_path)
+        puts "Converting #{File.basename(font_path)} to #{target_format}..." unless @options[:quiet]
 
         # Build pipeline options
         pipeline_options = {
-          target_format: @target_format,
+          target_format: target_format,
           validate: @validate,
           verbose: @options[:verbose],
         }
@@ -160,7 +209,7 @@ module Fontisan
         # Use TransformationPipeline for universal conversion
         pipeline = Pipeline::TransformationPipeline.new(
           font_path,
-          @output_path,
+          out_path,
           pipeline_options,
         )
 
@@ -168,12 +217,12 @@ module Fontisan
 
         # Display results
         unless @options[:quiet]
-          output_size = File.size(@output_path)
+          output_size = File.size(out_path)
           input_size = File.size(font_path)
 
           puts "Conversion complete!"
           puts "  Input:  #{font_path} (#{format_size(input_size)})"
-          puts "  Output: #{@output_path} (#{format_size(output_size)})"
+          puts "  Output: #{out_path} (#{format_size(output_size)})"
           puts "  Format: #{result[:details][:source_format]} → #{result[:details][:target_format]}"
 
           if result[:details][:variation_preserved]
@@ -186,11 +235,11 @@ module Fontisan
         {
           success: true,
           input_path: font_path,
-          output_path: @output_path,
+          output_path: out_path,
           source_format: result[:details][:source_format],
           target_format: result[:details][:target_format],
           input_size: File.size(font_path),
-          output_size: File.size(@output_path),
+          output_size: File.size(out_path),
           variation_strategy: result[:details][:variation_strategy],
         }
       end
@@ -200,11 +249,11 @@ module Fontisan
       # @return [Hash] Result information
       def convert_collection
         # Determine target collection type from target format
-        target_type = collection_type_from_format(@target_format)
+        target_type = collection_type_from_format(@target_formats.first)
 
         unless target_type
           raise ArgumentError,
-                "Target format #{@target_format} is not a collection format. " \
+                "Target format #{@target_formats.first} is not a collection format. " \
                 "Use ttc, otc, or dfont for collection conversion."
         end
 
@@ -302,12 +351,41 @@ module Fontisan
                 "Output path is required. Use --output option."
         end
 
-        unless @target_format
+        if @target_formats.empty?
           raise ArgumentError,
                 "Target format is required. Use --to option."
         end
       end
 
+      # Normalize the +--to+ value into a deduplicated Array<Symbol>.
+      #
+      # Accepts:
+      #   - "woff"               → [:woff]
+      #   - "woff,woff2"         → [:woff, :woff2]
+      #   - ["woff", "woff2"]    → [:woff, :woff2]
+      #   - ["woff,woff2", "ttf"] → [:woff, :woff2, :ttf]
+      #   - nil / ""             → []
+      #
+      # @return [Array<Symbol>]
+      def parse_target_formats(raw)
+        array = Array(raw).flat_map { |s| s.to_s.split(",") }
+          .map { |s| s.strip.downcase }
+          .reject(&:empty?)
+          .map { |s| parse_target_format(s) }
+        array.uniq
+      end
+
+      # Resolve the per-format output paths via {MultiFormatOutput}.
+      # Returns nil when no target formats have been parsed yet (the
+      # validate_options! path will surface the missing-format error).
+      #
+      # @return [Array<String>, nil]
+      def resolve_output_paths
+        return nil if @target_formats.empty? || @output_path.nil?
+
+        MultiFormatOutput.new(@output_path, @target_formats).paths
+      end
+
       # Parse target format from string/symbol
       #
       # @param format [String, Symbol, nil] Target format

data/lib/fontisan/commands/multi_format_output.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Resolves the on-disk output path for each target format in a
+    # multi-format conversion (TODO 72).
+    #
+    # Rules:
+    #   - One format + path has extension → use the path as-is.
+    #   - One format + path has no extension → append ".<format>".
+    #   - Many formats + path has extension → +ArgumentError+ (ambiguous).
+    #   - Many formats + path has no extension → append ".<format>" per target.
+    #
+    # Pure value object: no I/O, no mutation. Extracted from
+    # {ConvertCommand} so multi-format path resolution can be tested
+    # independently of the transformation pipeline.
+    class MultiFormatOutput
+      # @param base_path [String] user-supplied --output value
+      # @param target_formats [Array<Symbol>] non-empty, deduplicated
+      def initialize(base_path, target_formats)
+        @base_path = base_path
+        @target_formats = target_formats
+      end
+
+      # @return [Array<String>] one resolved path per target format,
+      #   in the same order as +target_formats+
+      # @raise [ArgumentError] if the base path is ambiguous
+      def paths
+        single? ? [single_format_path] : multi_format_paths
+      end
+
+      private
+
+      def single?
+        @target_formats.size == 1
+      end
+
+      def single_format_path
+        has_extension? ? @base_path : "#{@base_path}.#{@target_formats.first}"
+      end
+
+      def multi_format_paths
+        if has_extension?
+          raise ArgumentError,
+                "Output path #{@base_path.inspect} has an extension but " \
+                "#{@target_formats.size} target formats were given " \
+                "(#{@target_formats.join(', ')}). Drop the extension or " \
+                "specify a single format."
+        end
+
+        @target_formats.map { |fmt| "#{@base_path}.#{fmt}" }
+      end
+
+      def has_extension?
+        !File.extname(@base_path).strip.downcase.empty?
+      end
+    end
+  end
+end