generate method

void generate(
  1. List<String> args
)

Generates translation files based on the provided command-line arguments.

This method parses command-line arguments, scans the specified directory for translation strings, and generates language files in either Dart or JSON format.

Supported arguments:

  • --path or -p: Path to the main folder to scan (default: ./lib)
  • --output or -o: Path to save the output files
  • --languages or -l: Comma-separated language codes to generate (default: en)
  • --ignore-todo or --todo: Language codes that should not receive TODO comments
  • --include-invalid or --invalid: Include commented-out duplicated or invalid entries
  • --dart-format or --format: Run dart format on generated files (default: true)
  • --dart-fix or --fix: Run dart fix --apply on generated files (default: true)
  • --fvm: Use fvm prefix when running dart commands
  • --json: Export to JSON files instead of Dart files
  • --lazy: Generate LazyLanguageData instead of LanguageData (default: true)
  • --keep-deprecated: Keep deprecated translations that are no longer in use (default: false)
  • --verbose or -v: Show verbose logs
  • --help or -h: Show help message

Example:

final generator = LanguageHelperGenerator();
generator.generate([
  '--languages=en,vi',
  '--ignore-todo=en',
  '--path=./lib',
  '--output=./lib/languages',
]);

Implementation

void generate(List<String> args) {
  final parser = ArgParser()
    ..addOption(
      'path',
      abbr: 'p',
      help:
          'Path to the main folder that you want to to create a base language. Default is `./lib`.',
      valueHelp: './lib',
      defaultsTo: './lib',
    )
    ..addOption(
      'output',
      abbr: 'o',
      help: 'Path to the folder that you want to save the output.',
      valueHelp: 'Dart: ./lib/languages, JSON: ./assets/languages',
    )
    ..addOption(
      'languages',
      abbr: 'l',
      help:
          'Generate boilerplate translation files for the provided comma separated language codes.',
      defaultsTo: 'en',
      valueHelp: 'en,vi',
    )
    ..addOption(
      'ignore-todo',
      aliases: ['todo'],
      help:
          'Comma separated language codes that should not receive TODO comments when generating boilerplate.',
      valueHelp: 'en,vi',
    )
    ..addFlag(
      'include-invalid',
      aliases: ['invalid'],
      negatable: false,
      help: 'Include commented-out duplicated or invalid entries in outputs.',
      defaultsTo: false,
    )
    ..addFlag(
      'dart-format',
      aliases: ['format'],
      help: 'Running `dart format` for the generated files.',
      negatable: false,
      defaultsTo: true,
    )
    ..addFlag(
      'dart-fix',
      aliases: ['fix'],
      negatable: false,
      help: 'Running `dart fix --apply` for the generated files.',
      defaultsTo: true,
    )
    ..addFlag(
      'fvm',
      help: 'Should use `fvm` prefix when running the `dart` commands',
      defaultsTo: false,
    )
    ..addFlag(
      'json',
      defaultsTo: false,
      help: 'Export translations to JSON files instead of Dart files.',
    )
    ..addFlag(
      'lazy',
      defaultsTo: true,
      help:
          'Generate LazyLanguageData (lazy loading) instead of LanguageData.',
    )
    ..addFlag(
      'keep-deprecated',
      help:
          'Keep deprecated translations that are no longer in use. By default, unused translations are removed.',
      defaultsTo: false,
    )
    ..addFlag(
      'verbose',
      abbr: 'v',
      help: 'Show verbose logs',
      negatable: false,
      defaultsTo: false,
    )
    ..addFlag('help', abbr: 'h', help: 'Show help', negatable: false);
  final argResult = parser.parse(args);

  if (argResult.flag('verbose')) {
    logger = LiteLogger(
      name: 'LanguageHelperGenerator',
      minLevel: LogLevel.debug,
      usePrint: true,
    );
  } else {
    logger = LiteLogger(name: 'LanguageHelperGenerator', usePrint: true);
  }

  _log(LogLevel.info, 'Starting language helper code generation...');

  // Show helps
  if (argResult.flag('help')) {
    _log(LogLevel.info, 'Showing help message.');
    // ignore: avoid_print
    print(parser.usage);
    return;
  }

  _log(LogLevel.info, 'Arguments parsed: $args');

  final Map<String, Object?>? pubspecConfig = _loadPubspecConfig();

  final path = argResult.wasParsed('path')
      ? argResult['path'] as String
      : (pubspecConfig != null && pubspecConfig['path'] is String
            ? pubspecConfig['path'] as String
            : argResult['path'] as String);

  String? output = argResult.wasParsed('output')
      ? argResult['output'] as String?
      : (pubspecConfig != null && pubspecConfig['output'] is String
            ? pubspecConfig['output'] as String
            : argResult['output'] as String?);

  final languageCodes = argResult.wasParsed('languages')
      ? _parseLanguageCodes(argResult['languages'] as String?)
      : _parseLanguageCodes(
          _extractLanguagesFromPubspec(pubspecConfig) ??
              (argResult['languages'] as String?),
        );

  final ignoreTodoCodes = argResult.wasParsed('ignore-todo')
      ? _parseOptionalLanguageCodes(argResult['ignore-todo'] as String?)
      : _parseOptionalLanguageCodes(
          _extractIgnoreTodoFromPubspec(pubspecConfig) ??
              (argResult['ignore-todo'] as String?),
        );

  final includeInvalid = argResult.wasParsed('include-invalid')
      ? argResult['include-invalid'] as bool
      : (pubspecConfig != null && pubspecConfig['include-invalid'] is bool
            ? pubspecConfig['include-invalid'] as bool
            : argResult['include-invalid'] as bool);

  final dartFormat = argResult.wasParsed('dart-format')
      ? argResult['dart-format'] as bool
      : (pubspecConfig != null && pubspecConfig['dart-format'] is bool
            ? pubspecConfig['dart-format'] as bool
            : argResult['dart-format'] as bool);

  final dartFix = argResult.wasParsed('dart-fix')
      ? argResult['dart-fix'] as bool
      : (pubspecConfig != null && pubspecConfig['dart-fix'] is bool
            ? pubspecConfig['dart-fix'] as bool
            : argResult['dart-fix'] as bool);

  final fvm = argResult.wasParsed('fvm')
      ? argResult['fvm'] as bool
      : (pubspecConfig != null && pubspecConfig['fvm'] is bool
            ? pubspecConfig['fvm'] as bool
            : argResult['fvm'] as bool);

  final isLazy = argResult.wasParsed('lazy')
      ? argResult['lazy'] as bool
      : (pubspecConfig != null && pubspecConfig['lazy'] is bool
            ? pubspecConfig['lazy'] as bool
            : argResult['lazy'] as bool);

  final keepDeprecated = argResult.wasParsed('keep-deprecated')
      ? argResult['keep-deprecated'] as bool
      : (pubspecConfig != null && pubspecConfig['keep-deprecated'] is bool
            ? pubspecConfig['keep-deprecated'] as bool
            : argResult['keep-deprecated'] as bool);

  _log(LogLevel.debug, 'Path: $path');
  _log(LogLevel.debug, 'Output: ${output ?? 'default'}');
  _log(LogLevel.debug, 'Languages: ${languageCodes.join(', ')}');
  _log(LogLevel.debug, 'Ignore TODO: ${ignoreTodoCodes.join(', ')}');
  _log(LogLevel.debug, 'Include Invalid: $includeInvalid');
  _log(LogLevel.debug, 'Dart Format: $dartFormat');
  _log(LogLevel.debug, 'Dart Fix: $dartFix');
  _log(LogLevel.debug, 'FVM: $fvm');
  _log(LogLevel.debug, 'Export to JSON: ${argResult['json']}');
  _log(LogLevel.debug, 'Lazy: $isLazy');
  _log(LogLevel.debug, 'Keep Deprecated: $keepDeprecated');

  final result = _generate(path, output ?? p.join('.', 'lib', 'languages'));
  if (result == null) {
    _log(LogLevel.error, 'Generation failed: No data parsed.');
    return;
  }
  if (argResult['json']) {
    _log(LogLevel.step, 'Exporting to JSON files...');
    _exportJson(
      result,
      output ?? p.join('.', 'assets', 'languages'),
      languageCodes,
      keepDeprecated: keepDeprecated,
    );
    _log(LogLevel.success, 'JSON export completed.');
  } else {
    _log(LogLevel.step, 'Generating Dart language files...');
    final outputPath = output ?? p.join('.', 'lib', 'languages');
    d.exportDart(
      result,
      outputPath,
      languageCodes,
      includeInvalid: includeInvalid,
      ignoreTodoCodes: ignoreTodoCodes,
      dartFormat: dartFormat,
      dartFix: dartFix,
      fvm: fvm,
      isLazy: isLazy,
      keepDeprecated: keepDeprecated,
      logger: logger,
    );
    _log(LogLevel.success, 'Dart language file generation complete.');
  }
  _log(LogLevel.success, 'Language helper code generation finished.');
}