generate method

void generate(Config config)

Render and output your static site (WARNING: overwrites existing HTML files in output directory).

Implementation

void generate(final Config config) async {
  final contentDir = Directory(path.absolute(config.contentfolder));
  final templateDir = Directory(path.absolute(config.templatefolder));
  final outputDir = Directory(path.absolute(config.outputfolder));
  final dataDir = Directory(path.absolute(config.datafolder));
  final listingsDir = Directory(path.absolute(config.listingsfolder));
  final partialsDir = Directory(path.absolute(config.partialsfolder));
  final assetsDir = Directory(path.absolute(config.assetsfolder));

  outputDir.createSync(); // ensure output dir exists

  check(contentDir.existsSync(), because: 'ContentDir ${contentDir.path} must exist!').isTrue();
  check(templateDir.existsSync(), because: 'Templatefolder ${templateDir.path} must exist!').isTrue();
  check(outputDir.existsSync(), because: 'OutputDir ${outputDir.path} must exist!').isTrue();

  log('Assets Dir:$assetsDir');
  log('Content Dir:$contentDir');
  log('Templates Dir:$templateDir');

  final files = _listContentFilesIn(contentDir);
  final images = _listImagesFilesIn(contentDir);
  final assets = _listAssetsFilesIn(assetsDir);
  final templates = _listTemplatesIn(templateDir);
  final dataFiles = dataDir.existsSync() ? _listDataFilesIn(dataDir) : <File>[];
  final listingsMap = listingsDir.existsSync() ? await getListingsMap(listingsDir, config.yamldelimeter) : null;

  final dataMap = _getDataMap(dataFiles);

  _outputFormat = config.dateformat;

  log('Listings... ${listingsMap?.keys}');

  log('Generating .html files...');

  for (final file in files) {
    final relativeFileName = file.path.replaceAll(contentDir.path, '').replaceFirst('/', '');
    final relativePath = path.dirname(relativeFileName).replaceFirst('.', '');
    final extension = path.extension(relativeFileName).replaceFirst('.', '').toLowerCase();

    log('\nFile: $relativeFileName, Path: $relativePath');

    final fileContents = file.readAsStringSync();
    fm.FrontMatterDocument fmDocument;
    try {
      fmDocument = fm.parse(fileContents, delimiter: config.yamldelimeter);
    } catch (e) {
      log('Invalid Content File: ${file.path}');
      return;
    }
    var pageOptions = <String, dynamic>{};

    final fmData = fmDocument.data;

    pageOptions.addAll(fmData.map<String, dynamic>((dynamic key, dynamic value) {
      if (value is yaml.YamlList) {
        return MapEntry<String, yaml.YamlList>(key.toString(), value);
      }
      if (value is yaml.YamlMap) {
        return MapEntry<String, yaml.YamlMap>(key.toString(), value);
      }
      return MapEntry<String, String?>(key.toString(), value.toString());
    }));

    _resolvePartialsInYamlBlock(partialsDir, pageOptions, config.usemarkdown);

    pageOptions = _fillInPageNestingLevel(relativeFileName, pageOptions);
    pageOptions = _fillInDefaultPageOptions(config.dateformat, file, pageOptions, config.siteoptions);
    pageOptions['_data'] = dataMap;
    pageOptions['_lists'] = listingsMap;
    pageOptions['_content'] = renderTemplate(fmDocument.content ?? fileContents, pageOptions,
        _partialsResolver(partialsDir, isMarkdownSupported: config.usemarkdown));

    pageOptions['_template'] = 'none';

    var outputExtension = extension;
    if (isMarkdown(file) && _isMarkdownSupported(config.usemarkdown, pageOptions)) {
      pageOptions['_content'] = md.markdownToHtml(pageOptions['_content'] as String,
          inlineSyntaxes: [md.InlineHtmlSyntax()], extensionSet: md.ExtensionSet.gitHubWeb);
      outputExtension = 'html';
    }

    String? templateContent = '{{_content}}';
    if (pageOptions.containsKey('template') == false || pageOptions['template'] != 'none') {
      final template = _getTemplateFor(file, pageOptions, templates, config.defaulttemplate);
      pageOptions['_template'] = template.path;
      log('Template: ${path.basename(template.path)}');

      templateContent = template.readAsStringSync();
    }

    if (config.loglevel == 'debug') {
      _showPageOptions(relativeFileName, relativePath, pageOptions, config);
    }

    final content = _fixPathRefs(
        renderTemplate(
            templateContent, pageOptions, _partialsResolver(partialsDir, isMarkdownSupported: config.usemarkdown)),
        config);

    final outputFilename = '${path.basenameWithoutExtension(relativeFileName)}.$outputExtension';
    final outputPath = _createOutputPath(outputDir, relativePath);
    final outputFile = File('${outputPath.path}/$outputFilename');

    outputFile.writeAsStringSync(content);
    final outputPathReplaced = outputFile.path.replaceFirst(outputDir.path, '');
    log('   $outputPathReplaced - done!');
  }

  for (final image in images) {
    final relativeFileName = image.path.replaceAll(contentDir.path, '').replaceFirst('/', '');
    final relativePath = path.dirname(relativeFileName).startsWith('.')
        ? path.dirname(relativeFileName)
        : path.dirname(relativeFileName).replaceFirst('.', '');

    final outputPath = _createOutputPath(outputDir, relativePath);
    final outputFile = File('${outputPath.path}/${path.basename(relativeFileName)}');
    image.copySync(outputFile.path);

    final outputPathReplaced = outputFile.path.replaceFirst(outputDir.path, '');
    log('image: $outputPathReplaced - copied!');
  }

  for (final asset in assets) {
    final relativeFileName = asset.path.replaceAll(assetsDir.path, '').replaceFirst('/', '');
    final relativePath = path.dirname(relativeFileName).replaceFirst('.', '');

    final outputPath = _createOutputPath(outputDir, relativePath);
    final outputFile = File('${outputPath.path}/${path.basename(relativeFileName)}');
    asset.copySync(outputFile.path);

    final outputPathReplaced = outputFile.path.replaceFirst(outputDir.path, '');
    log('asset: $outputPathReplaced - copied!');
  }
}