fontisan 0.4.6 → 0.4.8

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

data/lib/fontisan/commands/validate_collection_command.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Validates the structural integrity of a TTC/OTC/dfont collection
+    # (TODO 74). Complements {ValidateCommand}, which runs profile-based
+    # checks against a single face. This command runs collection-level
+    # checks: face count, per-face glyph cap, optional cmap-union size.
+    #
+    # Returns an integer exit code (0 = all checks passed, 1 = any check
+    # failed) suitable for use as the CLI's exit status.
+    #
+    # The command is intentionally narrow: it does not subclass
+    # {BaseCommand} (which eagerly loads a single font at construction
+    # time) because the input here is a collection, not a single face.
+    # It owns its own loading via {Collection::Reader}.
+    class ValidateCollectionCommand
+      # Per-check result. The +message+ is +nil+ on pass.
+      #
+      # @!attribute [r] name
+      #   @return [Symbol] check identifier (:face_count, :glyph_cap, :cmap_union)
+      # @!attribute [r] passed
+      #   @return [Boolean]
+      # @!attribute [r] message
+      #   @return [String, nil] human-readable failure detail
+      Check = Struct.new(:name, :passed, :message, keyword_init: true) do
+        # Predicate form so callers can write +check.passed?+ instead of
+        # +check.passed+. Struct does not provide the +?+ suffix
+        # automatically.
+        def passed?
+          passed
+        end
+      end
+
+      DEFAULT_MAX_GLYPHS = 65_535
+
+      # @param input [String] path to a TTC/OTC/dfont
+      # @param expected_faces [Integer, nil] required face count, or nil to skip
+      # @param max_glyphs [Integer] per-face glyph cap (default 65,535)
+      # @param expected_cmap_union [Integer, nil] minimum cmap-union size, or nil to skip
+      def initialize(input:, expected_faces: nil, max_glyphs: DEFAULT_MAX_GLYPHS,
+                     expected_cmap_union: nil)
+        @input = input
+        @expected_faces = expected_faces
+        @max_glyphs = max_glyphs
+        @expected_cmap_union = expected_cmap_union
+      end
+
+      # @return [Integer] 0 if all checks passed, 1 otherwise
+      def run
+        reader = Collection::Reader.open(@input)
+        @checks = [
+          check_face_count(reader),
+          check_glyph_cap(reader),
+          check_cmap_union(reader),
+        ].compact
+
+        render_report(reader)
+        @checks.all?(&:passed?) ? 0 : 1
+      end
+
+      # @return [Array<Check>] the most recent run's checks
+      attr_reader :checks
+
+      private
+
+      def check_face_count(reader)
+        return nil unless @expected_faces
+
+        actual = reader.face_count
+        passed = actual == @expected_faces
+        Check.new(
+          name: :face_count,
+          passed: passed,
+          message: passed ? nil : "expected #{@expected_faces} faces, got #{actual}",
+        )
+      end
+
+      def check_glyph_cap(reader)
+        over = reader.stats.select { |s| s.glyph_count > @max_glyphs }
+        Check.new(
+          name: :glyph_cap,
+          passed: over.empty?,
+          message: over.empty? ? nil : "faces over cap: #{over.map { |s| "##{s.index}=#{s.glyph_count}" }.join(', ')}",
+        )
+      end
+
+      def check_cmap_union(reader)
+        return nil unless @expected_cmap_union
+
+        actual = reader.cmap_union.size
+        passed = actual >= @expected_cmap_union
+        Check.new(
+          name: :cmap_union,
+          passed: passed,
+          message: passed ? nil : "cmap union #{actual} < expected #{@expected_cmap_union}",
+        )
+      end
+
+      # Default rendering. Callers wanting structured output can
+      # instantiate the command, call +#run+, then read +#checks+
+      # directly instead of relying on stdout.
+      def render_report(reader)
+        reader.stats.each do |s|
+          marker = s.glyph_count <= @max_glyphs ? "✓" : "✗"
+          puts format("face %<index>d: %<glyphs>7d glyphs %<marker>s",
+                      index: s.index, glyphs: s.glyph_count, marker: marker)
+        end
+        puts "all #{reader.face_count} faces within #{@max_glyphs}-glyph cap ✓"
+
+        @checks.each do |check|
+          if check.passed?
+            puts "#{check.name}: ✓"
+          else
+            puts "#{check.name}: ✗ (#{check.message})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/commands.rb

@@ -13,6 +13,7 @@ module Fontisan
     autoload :InfoCommand, "fontisan/commands/info_command"
     autoload :InstanceCommand, "fontisan/commands/instance_command"
     autoload :LsCommand, "fontisan/commands/ls_command"
+    autoload :MultiFormatOutput, "fontisan/commands/multi_format_output"
     autoload :OpticalSizeCommand, "fontisan/commands/optical_size_command"
     autoload :PackCommand, "fontisan/commands/pack_command"
     autoload :ScriptsCommand, "fontisan/commands/scripts_command"
@@ -20,6 +21,7 @@ module Fontisan
     autoload :TablesCommand, "fontisan/commands/tables_command"
     autoload :UnicodeCommand, "fontisan/commands/unicode_command"
     autoload :UnpackCommand, "fontisan/commands/unpack_command"
+    autoload :ValidateCollectionCommand, "fontisan/commands/validate_collection_command"
     autoload :ValidateCommand, "fontisan/commands/validate_command"
     autoload :VariableCommand, "fontisan/commands/variable_command"
   end

data/lib/fontisan/error.rb

@@ -206,6 +206,62 @@ module Fontisan
   # CBDT/CBLC across multiple sources requires a dedicated rebuild.
   class MultipleCbdtSourcesError < Error; end
 
+  # Stitcher produced more glyphs than the output format supports.
+  #
+  # Raised by Stitcher::GlyphLimit.check! before writing, so the user
+  # gets an actionable message instead of a silently truncated font.
+  class GlyphLimitExceededError < Error
+    attr_reader :actual, :limit, :format
+
+    def initialize(actual:, limit:, format:)
+      @actual = actual
+      @limit = limit
+      @format = format
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      "Stitcher produced #{actual} unique glyphs, exceeding the " \
+        "#{format.to_s.upcase} limit of #{format_limit}. Both TTF and OTF " \
+        "(CFF1) cap at 65,535 glyphs — the maxp.num_glyphs field is uint16 " \
+        "and the CFF CharStrings INDEX count is card16. Options: " \
+        "(1) split the output into a TTC (TrueType Collection) by Unicode plane, " \
+        "(2) reduce the number of donors, " \
+        "(3) wait for CFF2 support in fontisan (card24 INDEX counts, no glyph cap)."
+    end
+
+    def format_limit
+      limit == Float::INFINITY ? "infinity" : limit.to_s
+    end
+  end
+
+  # Partition strategy could not satisfy the requested cap.
+  #
+  # Raised by {Stitcher::PartitionStrategy} when a single Unicode block
+  # contains more codepoints than the configured cap, so the partitioner
+  # cannot sub-split it further. This is a partitioning-time detection
+  # distinct from {GlyphLimitExceededError}, which fires at compile time
+  # after the Stitcher has produced more glyphs than the output format
+  # supports. Both surface the same underlying constraint (65,535-glyph
+  # cap) but at different stages.
+  class PartitionCapExceededError < Error
+    attr_reader :block_label, :actual, :cap
+
+    # @param block_label [String] e.g. "CJK_Ext_B", or "plane_N" if the
+    #   overflow is not attributable to a known block
+    # @param actual [Integer] number of codepoints in the block
+    # @param cap [Integer] the cap that was exceeded
+    def initialize(block_label:, actual:, cap:)
+      @block_label = block_label
+      @actual = actual
+      @cap = cap
+      super("single Unicode block #{block_label} (#{actual} cps) exceeds " \
+            "cap #{cap}; cannot sub-split further")
+    end
+  end
+
   # Variation data corrupted (for use in data_extractor)
   #
   # Raised when extracted variation data appears corrupted.

data/lib/fontisan/models.rb

@@ -15,7 +15,6 @@ module Fontisan
     autoload :CollectionListInfo, "fontisan/models/collection_list_info"
     autoload :CollectionValidationReport,
              "fontisan/models/collection_validation_report"
-    autoload :Cldr, "fontisan/models/cldr"
     autoload :ColorGlyph, "fontisan/models/color_glyph"
     autoload :ColorLayer, "fontisan/models/color_layer"
     autoload :ColorPalette, "fontisan/models/color_palette"

data/lib/fontisan/stitcher/collection_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Per-subfont stats computed from the loaded, on-disk subfont (not the
+    # in-memory UFO target — the compiler may add glyphs, e.g. .notdef).
+    SubfontStats = Struct.new(:name, :glyph_count, :codepoint_count,
+                              keyword_init: true)
+
+    # Return value of {Stitcher#write_collection}. Carries the output path,
+    # total bytes, and one {SubfontStats} per declared subfont.
+    CollectionResult = Struct.new(:path, :bytes, :subfonts, keyword_init: true) do
+      def face_count
+        subfonts.size
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/deduplicator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Registry mapping glyph signatures to canonical glyph names in
+    # the target font. Enables signature-based deduplication: when
+    # two bindings produce glyphs with identical outlines, they share
+    # one gid and the duplicate's codepoint is redirected to the
+    # canonical glyph.
+    #
+    # Replaces the Stitcher's previous name-based dedup with
+    # outline-based dedup. This merges visually identical glyphs
+    # from different donors even when their names differ, reducing
+    # the glyph count below the TrueType 65,535 cap.
+    class Deduplicator
+      attr_reader :signatures
+
+      def initialize
+        @signatures = {}
+      end
+
+      # Record that `glyph` maps to `canonical_name` in the target.
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @param canonical_name [String] the name under which the glyph
+      #   was added to the target font
+      def register(glyph, canonical_name)
+        @signatures[GlyphSignature.for(glyph)] = canonical_name
+      end
+
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String, nil] the canonical name if an identical
+      #   glyph was already registered, nil otherwise
+      def find(glyph)
+        @signatures[GlyphSignature.for(glyph)]
+      end
+
+      # @return [Integer] number of unique signatures registered
+      def size
+        @signatures.size
+      end
+
+      def empty?
+        @signatures.empty?
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_limit.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Format-specific glyph-count caps.
+    #
+    # Both TTF and OTF (CFF1) cap at 65,535 because:
+    #   - TTF: maxp.num_glyphs is uint16
+    #   - OTF (CFF1): maxp.num_glyphs is uint16 AND the CFF CharStrings
+    #     INDEX count is card16
+    #
+    # Exceeding the cap produces a silently truncated font (the BinData
+    # uint16 writer truncates without raising). The Stitcher checks
+    # the cap BEFORE writing so the user gets a clear error.
+    #
+    # To exceed 65,535 glyphs, the font must be split into a TTC
+    # (TrueType Collection) or fontisan must implement CFF2 (card24
+    # INDEX counts). Both are future work.
+    module GlyphLimit
+      TTF_GLYPH_CAP = 65_535
+      OTF_GLYPH_CAP = 65_535
+
+      # @param format [Symbol] :ttf or :otf
+      # @return [Integer, Float::INFINITY] the max glyph count
+      def self.for_format(format)
+        case format.to_sym
+        when :ttf then TTF_GLYPH_CAP
+        when :otf then OTF_GLYPH_CAP
+        when :otf2 then OTF_GLYPH_CAP # CFF2 CharStrings count must match maxp.numGlyphs
+        else
+          raise ArgumentError, "unknown format: #{format.inspect}"
+        end
+      end
+
+      # Raise GlyphLimitExceededError if `glyph_count` exceeds the cap
+      # for the given format.
+      #
+      # @param glyph_count [Integer]
+      # @param format [Symbol]
+      # @raise [GlyphLimitExceededError]
+      def self.check!(glyph_count, format:)
+        limit = for_format(format)
+        return if glyph_count <= limit
+
+        raise GlyphLimitExceededError.new(
+          actual: glyph_count,
+          limit: limit,
+          format: format,
+        )
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_signature.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Fontisan
+  class Stitcher
+    # Stateless signature computation for a Ufo::Glyph's visual identity.
+    #
+    # Two glyphs with the same signature are visually interchangeable
+    # and can share a gid in the output font. The signature captures
+    # advance width, every contour's points (x, y, type), and every
+    # component reference (base glyph + transform presence).
+    #
+    # Used by Deduplicator to merge identical outlines from different
+    # donors, reducing the glyph count below the TrueType 65,535 cap.
+    module GlyphSignature
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String] SHA-256 hex digest of the glyph's outline identity
+      def self.for(glyph)
+        Digest::SHA256.hexdigest(canonical_representation(glyph))
+      end
+
+      # Build a deterministic string capturing the glyph's visual identity.
+      # The representation is ordered and normalized so that semantically
+      # identical glyphs produce byte-identical strings.
+      #
+      # @param glyph [Fontisan::Ufo::Glyph]
+      # @return [String]
+      def self.canonical_representation(glyph)
+        io = +""
+        io << "w:#{glyph.width.to_i};"
+
+        glyph.contours.each_with_index do |contour, ci|
+          io << "c#{ci}:"
+          contour.points.each do |pt|
+            io << "#{pt.x.to_i},#{pt.y.to_i},#{pt.type};"
+          end
+        end
+
+        glyph.components.each_with_index do |comp, i|
+          io << "comp#{i}:#{comp.base_glyph}"
+          io << ":t" if comp.transformation
+        end
+
+        io
+      end
+
+      private_class_method :canonical_representation
+    end
+  end
+end

data/lib/fontisan/stitcher/partition_strategy/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module PartitionStrategy
+      # Abstract base. Concrete partitioners (ByPlane, ByBlock, …)
+      # implement {#call} and return a {Blueprint}.
+      class Base
+        # Default cap: 65,535 − .notdef − safety margin. Matches the
+        # Stitcher's own +GlyphLimit+ cap for TTF.
+        DEFAULT_CAP = 65_484
+
+        # @param cp_map [Hash{Integer=>Object}] codepoint → donor label
+        # @param cap [Integer] max codepoints per partition
+        # @return [Blueprint]
+        def call(cp_map, cap: DEFAULT_CAP)
+          raise NotImplementedError,
+                "#{self.class} must implement #call"
+        end
+      end
+    end
+  end
+end