Class: Fontisan::Cli

Inherits:
Thor
  • Object
show all
Defined in:
lib/fontisan/cli.rb

Overview

Command-line interface for Fontisan.

This class provides the Thor-based CLI with commands for extracting font information and listing tables. It supports multiple output formats (text, YAML, JSON) and various options for controlling output behavior.

Examples:

Run the info command

Fontisan::Cli.start(['info', 'font.ttf'])

Instance Method Summary collapse

Instance Method Details

#convert(font_file) ⇒ Object

Convert a font to a different format using the universal transformation pipeline.

Supported conversions:

  • TTF ↔ OTF: Outline format conversion
  • Type 1 ↔ TTF/OTF: Adobe Type 1 font conversion
  • WOFF/WOFF2: Web font packaging
  • 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 convert all fonts to TrueType, or --target-format otf to convert all to OpenType/CFF.

Variable Font Operations: The pipeline automatically detects whether variation data can be preserved based on source and target formats. For same outline family (TTF→WOFF or OTF→WOFF2), variation is preserved automatically. For cross-family conversions (TTF↔OTF), an instance is generated unless --preserve-variation is explicitly set.

Instance Generation: Use --coordinates to specify exact axis values (e.g., wght=700,wdth=100) or --instance-index to use a named instance. Individual axis options (--wght, --wdth) are also supported for convenience.

Examples:

Convert TTF to OTF

fontisan convert font.ttf --to otf --output font.otf

Convert Type 1 to OTF

fontisan convert font.pfb --to otf --output font.otf

Convert OTF to Type 1

fontisan convert font.otf --to type1 --output font.pfb

Convert TTC to OTC (preserves mixed formats by default)

fontisan convert family.ttc --to otc --output family.otc

Convert TTC to OTC with all fonts as TrueType

fontisan convert family.ttc --to otc --output family.otc --target-format ttf

Convert TTC to OTC with all fonts as OpenType/CFF

fontisan convert family.ttc --to otc --output family.otc --target-format otf

Generate bold instance at specific coordinates

fontisan convert variable.ttf --to ttf --output bold.ttf --coordinates "wght=700,wdth=100"

Generate bold instance using individual axis options

fontisan convert variable.ttf --to ttf --output bold.ttf --wght 700

Use named instance

fontisan convert variable.ttf --to woff2 --output bold.woff2 --instance-index 0

Force variation preservation (if compatible)

fontisan convert variable.ttf --to woff2 --output variable.woff2 --preserve-variation

Convert without validation

fontisan convert font.ttf --to otf --output font.otf --no-validate

Use named preset

fontisan convert font.pfb --to otf --output font.otf --preset type1_to_modern

Show recommended options for conversion

fontisan convert font.ttf --to otf --show-options

Convert with custom options

fontisan convert font.ttf --to otf --output font.otf --autohint --hinting-mode auto

Parameters:

  • font_file (String) —

    Path to the font file



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/fontisan/cli.rb', line 352

def convert(font_file)
  # Detect source format from file
  source_format = detect_source_format(font_file)

  # Handle --show-options
  if options[:show_options]
    show_recommended_options(source_format, options[:to])
    return
  end

  # Validate output is provided when not using --show-options
  unless options[:output]
    raise Thor::Error, "Output path is required. Use --output option."
  end

  # Build ConversionOptions
  conv_options = build_conversion_options(source_format, options[:to],
                                          options)

  # Build instance coordinates from axis options
  instance_coords = build_instance_coordinates(options)

  # Merge coordinates and ConversionOptions into convert_options
  convert_options = options.to_h.dup
  if instance_coords.any?
    convert_options[:instance_coordinates] = instance_coords
  end

  # Add ConversionOptions if built
  convert_options[:options] = conv_options if conv_options

  command = Commands::ConvertCommand.new(font_file, convert_options)
  command.run
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#dump_table(font_file, table_tag) ⇒ Object

Dump raw binary table data to stdout.

Parameters:

  • font_file (String) —

    Path to the font file

  • table_tag (String) —

    Four-character table tag (e.g., 'name', 'head')



444
445
446
447
448
449
450
451
452
453
 
# File 'lib/fontisan/cli.rb', line 444

def dump_table(font_file, table_tag)
  command = Commands::DumpTableCommand.new(font_file, table_tag, options)
  raw_data = command.run

  # Write binary data directly to stdout
  $stdout.binmode
  $stdout.write(raw_data)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#export(font_file) ⇒ Object 



559
560
561
562
563
564
565
566
567
568
 
# File 'lib/fontisan/cli.rb', line 559

def export(font_file)
  command = Commands::ExportCommand.new(
    font_file,
    output: options[:output],
    format: options[:format].to_sym,
    tables: options[:tables],
    binary_format: options[:binary_format].to_sym,
  )
  exit command.run
end

#features(font_file) ⇒ Object

List OpenType features available for scripts. If no script is specified, shows features for all scripts.

Parameters:

  • font_file (String) —

    Path to the font file



152
153
154
155
156
157
158
 
# File 'lib/fontisan/cli.rb', line 152

def features(font_file)
  command = Commands::FeaturesCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#glyphs(font_file) ⇒ Object

List glyph names from the font file.

Parameters:

  • font_file (String) —

    Path to the font file



88
89
90
91
92
93
94
 
# File 'lib/fontisan/cli.rb', line 88

def glyphs(font_file)
  command = Commands::GlyphsCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#info(path) ⇒ Object

Extract and display comprehensive font metadata.

Parameters:

  • path (String) —

    Path to the font file or collection



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/fontisan/cli.rb', line 38

def info(path)
  command = Commands::InfoCommand.new(path, options)
  info = command.run
  output_result(info) unless options[:quiet]
rescue Errno::ENOENT
  if options[:verbose]
    raise
  else
    warn "File not found: #{path}" unless options[:quiet]
    exit 1
  end
end

#instance(font_file) ⇒ Object

Generate static font instance from variable font.

You can specify axis coordinates using --wght, --wdth, etc., or use a predefined named instance with --named-instance. Use --list-instances to see available named instances.

Examples:

Generate bold instance

fontisan instance variable.ttf --wght=700 --output=bold.ttf

Use named instance

fontisan instance variable.ttf --named-instance="Bold" --output=bold.ttf

Instance with format conversion

fontisan instance variable.ttf --wght=700 --to=woff2 --output=bold.woff2

List available instances

fontisan instance variable.ttf --list-instances

Parameters:

  • font_file (String) —

    Path to the variable font file



432
433
434
435
436
437
 
# File 'lib/fontisan/cli.rb', line 432

def instance(font_file)
  command = Commands::InstanceCommand.new
  command.execute(font_file, options)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#ls(file) ⇒ Object

List contents of font files with auto-detection.

For collections (TTC/OTC): Lists all fonts in the collection For individual fonts (TTF/OTF): Shows quick font summary

Examples:

List fonts in collection

fontisan ls fonts.ttc

Show font summary

fontisan ls font.ttf

Parameters:

  • file (String) —

    Path to the font or collection file



64
65
66
67
68
69
70
 
# File 'lib/fontisan/cli.rb', line 64

def ls(file)
  command = Commands::LsCommand.new(file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#optical_size(font_file) ⇒ Object

Display optical size information from the font file.

Parameters:

  • font_file (String) —

    Path to the font file



124
125
126
127
128
129
130
 
# File 'lib/fontisan/cli.rb', line 124

def optical_size(font_file)
  command = Commands::OpticalSizeCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#pack(*font_files) ⇒ Object

Create a TTC (TrueType Collection), OTC (OpenType Collection), or dfont (Apple Data Fork Font) from multiple font files.

This command combines multiple fonts into a single collection file with shared table deduplication to save space. It supports TTC, OTC, and dfont formats.

Examples:

Pack fonts into TTC

fontisan pack font1.ttf font2.ttf font3.ttf --output family.ttc

Pack into OTC with analysis

fontisan pack Regular.otf Bold.otf Italic.otf --output family.otc --analyze

Pack into dfont (Apple suitcase)

fontisan pack font1.ttf font2.otf --output family.dfont --format dfont

Pack without optimization

fontisan pack font1.ttf font2.ttf --output collection.ttc --no-optimize

Parameters:

  • font_files (Array<String>) —

    Paths to input font files (minimum 2 required)



656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
 
# File 'lib/fontisan/cli.rb', line 656

def pack(*font_files)
  command = Commands::PackCommand.new(font_files, options)
  result = command.run

  unless options[:quiet]
    puts "Collection created successfully:"
    puts "  Output: #{result[:output_path] || result[:output]}"
    puts "  Format: #{result[:format].upcase}"
    puts "  Fonts: #{result[:num_fonts]}"
    puts "  Size: #{format_size(result[:output_size] || result[:total_size])}"
    if result[:space_savings]&.positive?
      puts "  Space saved: #{format_size(result[:space_savings])}"
      puts "  Sharing: #{result[:statistics][:sharing_percentage]}%"
    end
  end
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#scripts(font_file) ⇒ Object

List all scripts supported by the font from GSUB and GPOS tables.

Parameters:

  • font_file (String) —

    Path to the font file



136
137
138
139
140
141
142
 
# File 'lib/fontisan/cli.rb', line 136

def scripts(font_file)
  command = Commands::ScriptsCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#subset(font_file) ⇒ Object

Subset a font to specific glyphs.

You must specify one of --text, --glyphs, or --unicode to define which glyphs to include in the subset.

Parameters:

  • font_file (String) —

    Path to the font file



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/fontisan/cli.rb', line 190

def subset(font_file)
  command = Commands::SubsetCommand.new(font_file, options)
  result = command.run

  unless options[:quiet]
    puts "Subset font created:"
    puts "  Input: #{result[:input]}"
    puts "  Output: #{result[:output]}"
    puts "  Original glyphs: #{result[:original_glyphs]}"
    puts "  Subset glyphs: #{result[:subset_glyphs]}"
    puts "  Profile: #{result[:profile]}"
    puts "  Size: #{format_size(result[:size])}"
  end
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#tables(font_file) ⇒ Object

List all OpenType tables in the font file.

Parameters:

  • font_file (String) —

    Path to the font file



76
77
78
79
80
81
82
 
# File 'lib/fontisan/cli.rb', line 76

def tables(font_file)
  command = Commands::TablesCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#unicode(font_file) ⇒ Object

List Unicode to glyph index mappings from the font file.

Parameters:

  • font_file (String) —

    Path to the font file



100
101
102
103
104
105
106
 
# File 'lib/fontisan/cli.rb', line 100

def unicode(font_file)
  command = Commands::UnicodeCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#unpack(font_file) ⇒ Object

Extract individual fonts from a TTC (TrueType Collection) or OTC (OpenType Collection) file.

This command unpacks fonts from collection files, optionally converting them to different formats during extraction.

Examples:

Extract all fonts to directory

fontisan unpack family.ttc --output-dir extracted/

Extract specific font by index

fontisan unpack family.ttc --output-dir extracted/ --font-index 0

Extract with format conversion

fontisan unpack family.ttc --output-dir extracted/ --format woff2

Extract with custom prefix

fontisan unpack family.ttc --output-dir extracted/ --prefix "NotoSans"

Parameters:

  • font_file (String) —

    Path to the TTC/OTC collection file



607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
 
# File 'lib/fontisan/cli.rb', line 607

def unpack(font_file)
  command = Commands::UnpackCommand.new(font_file, options)
  result = command.run

  unless options[:quiet]
    puts "Collection unpacked successfully:"
    puts "  Input: #{result[:collection]}"
    puts "  Output directory: #{result[:output_dir]}"
    puts "  Fonts extracted: #{result[:fonts_extracted]}/#{result[:num_fonts]}"
    result[:extracted_files].each do |file|
      size = File.size(file)
      puts "  - #{File.basename(file)} (#{format_size(size)})"
    end
  end
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#validate(*font_files) ⇒ Object 



500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
 
# File 'lib/fontisan/cli.rb', line 500

def validate(*font_files)
  if options[:list]
    list_available_tests
    return
  end

  # Validate argument count
  if font_files.empty?
    raise(Thor::Error, "FONT_FILE is required unless using --list")
  elsif font_files.size > 1
    raise(Thor::Error,
          "Too many arguments. validate accepts only one font file.\n" \
          "To validate multiple files, run validate separately for each.\n" \
          "To validate all fonts in a collection, use: fontisan validate collection.ttc")
  end

  font_file = font_files.first

  cmd = Commands::ValidateCommand.new(
    input: font_file,
    profile: options[:profile],
    exclude: options[:exclude] || [],
    output: options[:output],
    format: options[:format].to_sym,
    full_report: options[:full_report],
    summary_report: options[:summary_report],
    table_report: options[:table_report],
    verbose: options[:verbose],
    suppress_warnings: options[:suppress_warnings],
    return_value_results: options[:return_value_results],
  )

  exit cmd.run
rescue Thor::Error => e
  unless options[:quiet]
    warn "ERROR: #{e.message}"
    warn
    help("validate")
  end
  exit 1
rescue StandardError => e
  error "Validation failed: #{e.message}"
  exit 1
end

#variable(font_file) ⇒ Object

Display variable font variation axes and instances.

Parameters:

  • font_file (String) —

    Path to the font file



112
113
114
115
116
117
118
 
# File 'lib/fontisan/cli.rb', line 112

def variable(font_file)
  command = Commands::VariableCommand.new(font_file, options)
  result = command.run
  output_result(result)
rescue Errno::ENOENT, Error => e
  handle_error(e)
end

#version ⇒ Object

Display the Fontisan version.



572
573
574
 
# File 'lib/fontisan/cli.rb', line 572

def version
  puts "Fontisan version #{Fontisan::VERSION}"
end