createFile method

@override Future<GeneratedFile> createFile(String path, List<int> contents, { Logger? logger, OverwriteRule? overwriteRule, })

Create a file at the given path with the given contents.

Implementation

@override
Future<GeneratedFile> createFile(
  String path,
  List<int> contents, {
  Logger? logger,
  OverwriteRule? overwriteRule,
}) async {
  _overwriteRule ??= overwriteRule;
  final file = File(p.join(dir.path, path));
  final filePath = darkGray.wrap(p.relative(file.path));
  final fileExists = file.existsSync();

  if (!fileExists) {
    await file
        .create(recursive: true)
        .then<File>((_) => file.writeAsBytes(contents))
        .whenComplete(
          () => logger?.delayed('  ${green.wrap('created')} $filePath'),
        );
    return GeneratedFile.created(path: file.path);
  }

  final existingContents = file.readAsBytesSync();

  if (const ListEquality<int>().equals(existingContents, contents)) {
    logger?.delayed('  ${cyan.wrap('identical')} $filePath');
    return GeneratedFile.identical(path: file.path);
  }

  final shouldPrompt = logger != null &&
      (_overwriteRule != OverwriteRule.alwaysOverwrite &&
          _overwriteRule != OverwriteRule.alwaysSkip &&
          _overwriteRule != OverwriteRule.alwaysAppend);

  if (shouldPrompt) {
    logger.info('${red.wrap(styleBold.wrap('conflict'))} $filePath');
    _overwriteRule = logger
        .prompt(
          lightYellow.wrap('Overwrite ${p.basename(file.path)}? (Yyna)'),
        )
        .toOverwriteRule();
  }

  switch (_overwriteRule) {
    case OverwriteRule.alwaysSkip:
    case OverwriteRule.skipOnce:
      logger?.delayed('  ${yellow.wrap('skipped')} $filePath');
      return GeneratedFile.skipped(path: file.path);
    case OverwriteRule.alwaysOverwrite:
    case OverwriteRule.overwriteOnce:
    case OverwriteRule.appendOnce:
    case OverwriteRule.alwaysAppend:
    case null:
      final shouldAppend = _overwriteRule == OverwriteRule.appendOnce ||
          _overwriteRule == OverwriteRule.alwaysAppend;
      await file
          .create(recursive: true)
          .then<File>(
            (_) => file.writeAsBytes(
              contents,
              mode: shouldAppend ? FileMode.append : FileMode.write,
            ),
          )
          .whenComplete(
            () => shouldAppend
                ? logger?.delayed('  ${lightBlue.wrap('modified')} $filePath')
                : logger?.delayed('  ${green.wrap('created')} $filePath'),
          );

      return shouldAppend
          ? GeneratedFile.appended(path: file.path)
          : GeneratedFile.overwritten(path: file.path);
  }
}