CHGenerator/Sources/Generator/run.swift

import Foundation
import ArgumentParser


@main
struct CHGenerator: ParsableCommand {

    @Argument(help: "The path to the generator configuration file")
    var configPath: String

    mutating func run() throws {
        try generate(configPath: configPath)
    }
}

private func loadConfiguration(at configPath: String) -> Configuration? {
    print("                                                    ")
    print("--- CONFIGURATION ----------------------------------")
    print("                                                    ")
    print("    Configuration file: \(configPath)")
    let configUrl = URL(fileURLWithPath: configPath)
    let config: Configuration
    do {
        let data = try Data(contentsOf: configUrl)
        config = try JSONDecoder().decode(from: data)
    } catch {
        print("   Configuration error: \(error)")
        return nil
    }
    config.printOverview()
    print("                                                    ")
    return config
}

private func loadSiteData(in folder: URL, runFolder: URL) throws -> (root: Element, ids: [String : String])? {
    print("--- SOURCE FILES -----------------------------------")
    print("                                                    ")

    let log = MetadataInfoLogger(input: folder, runFolder: runFolder)
    let root = Element(atRoot: folder, log: log)
    log.printMetadataScanOverview(languages: root?.languages.count ?? 0)
    print("                                                    ")
    try log.writeResultsToFile()
    guard let root else {
        return nil
    }
    let ids = root.getContainedIds(log: log)
    return (root, ids)
}

private func generatePages(from root: Element, configuration: Configuration, fileUpdates: FileUpdateChecker, ids: [String: String], pageCount: Int, runFolder: URL) throws -> (ImageData, FileData) {
    print("--- GENERATION -------------------------------------")
    print("                                                    ")

    let results = GenerationResultsHandler(
        in: configuration.contentDirectory,
        to: configuration.outputDirectory,
        configuration: configuration,
        fileUpdates: fileUpdates,
        pagePaths: ids,
        pageCount: pageCount)

    let siteGenerator = try SiteGenerator(results: results)
    siteGenerator.generate(site: root)
    results.printOverview()
    let url = runFolder.appendingPathComponent("files.txt")
    try results.writeResultsToFile(file: url)
    return (results.images, results.files)
}

private func generateImages(_ images: ImageData, configuration: Configuration, runFolder: URL, fileUpdates: FileUpdateChecker) {
    print("--- IMAGES -----------------------------------------")
    print("                                                    ")
    let reader = ImageReader(in: configuration.contentDirectory, runFolder: runFolder, fileUpdates: fileUpdates)
    let generator = ImageGenerator(
        input: configuration.contentDirectory,
        output: configuration.outputDirectory,
        reader: reader, images: images)
    generator.generateImages()
    print("                                                    ")
}

private func copyFiles(files: FileData, configuration: Configuration, runFolder: URL) {
    print("--- FILES ------------------------------------------")
    print("                                                    ")
    let generator = FileGenerator(
        input: configuration.contentDirectory,
        output: configuration.outputDirectory,
        runFolder: runFolder,
        files: files)
    generator.generate()
}

private func finish(start: Date) {
    print("----------------------------------------------------")
    print("                                                    ")
    let duration = Int(-start.timeIntervalSinceNow.rounded())
    if duration < 60 {
        print("              Duration: \(duration) s")
    } else if duration < 3600 {
        print(String(format: "              Duration: %d:%02d", duration / 60, duration % 60))
    } else {
        print(String(format: "              Duration: %d:%02d:%02d", duration / 3600, (duration / 60) % 60, duration % 60))
    }
    print("")
}

private func generate(configPath: String) throws {
    let start = Date()

    // 1. Load configuration
    guard let configuration = loadConfiguration(at: configPath) else {
        return
    }

    let runFolder = configuration.contentDirectory.appendingPathComponent("run")

    // 2. Scan site elements
    guard let (siteRoot, ids) = try loadSiteData(in: configuration.contentDirectory, runFolder: runFolder) else {
        return
    }

    let fileUpdates = FileUpdateChecker(input: configuration.contentDirectory)
    switch fileUpdates.loadPreviousRun(from: runFolder)  {
    case .notLoaded:
        print("Regarding all files as new (no hashes loaded)")
    case .loaded:
        break
    case .failed(let error):
        print("Regarding all files as new (\(error))")
    }

    // 3. Generate pages
    let pageCount = ids.count * siteRoot.languages.count
    let (images, files) = try generatePages(from: siteRoot, configuration: configuration, fileUpdates: fileUpdates, ids: ids, pageCount: pageCount, runFolder: runFolder)

    if let error = fileUpdates.writeDetectedFileChanges(to: runFolder) {
        print(error)
    }

    // 4. Generate images
    generateImages(images, configuration: configuration, runFolder: runFolder, fileUpdates: fileUpdates)

    // 5. Copy/minify files
    copyFiles(files: files, configuration: configuration, runFolder: runFolder)

    // 6. Print summary
    finish(start: start)
}