compile.onyx

//+optional-semicolons

use core.os
use core.io
use core.iter
use core.encoding.json
use core {
    printf
    tprintf
}

Examples_Dir    :: "./examples"
Compilation_Dir :: "./compilation"

Example :: struct {
    code: str
    title: str
    name: str
    tags: [] str
    author: str
    description: str
}

ExamplesMetadata :: struct {
    by_tag: json.Value

    // These examples will not have the code property set,
    // to avoid lot of bloat.
    list:   [..] Example 
}

main :: () {
    examples: [..] Example

    //
    // Find and process all examples
    for file in os.list_directory(Examples_Dir) {
        name := file->name()
        if !name->ends_with(".onyx") do continue

        contents := os.get_contents(os.path_join(Examples_Dir, name))
        basename := str.bisect(name, ".") |> str.copy()

        ex: Example
        ex.name = basename

        if !contents->starts_with("/*===") {
            logf(.Error, "'{}' is not a valid example because it does not contain a metadata block.", name)
        }

        metadata, code := str.bisect(contents, "===*/")
        ex.code = str.strip_whitespace(code)

        for md in metadata->split_iter("\n") {
            key, value := str.bisect(md, ":")
            key = str.strip_whitespace(key)
            value = str.strip_whitespace(value)

            switch key {
                case "title"       do ex.title = value
                case "author"      do ex.author = value
                case "description" do ex.description = value
                case "tags"        do ex.tags = str.split_iter(value, " ")->collect()
            }
        }

        examples << ex
    }

    //
    // Output processed examples into compilation folder.
    if !os.dir_exists(Compilation_Dir) {
        os.dir_create(Compilation_Dir)
    }

    for &ex in examples {
        logf(.Info, "Generating {}", ex.name)
        use f := os.open(os.path_join(Compilation_Dir, tprintf("{}.html", ex.name)), .Write)->unwrap()
        use w := io.Writer.make(&f)

        io.write_format(&w, "<h1 class='title'>{}</h1>\n", ex.title)
        io.write_format(&w, "<p class='author'>{}</p>\n", ex.author)
        io.write_format(&w, "<div class='description'>{}</div>\n", ex.description)
        io.write_format(&w, "<pre class='hljs'><code class='language-onyx'>{}</code></pre>\n", ex.code)
    }

    //
    // Output metadata.
    md: ExamplesMetadata
    md.list = iter.as_iter(examples)
        ->map(x => Example.{
            title = x.title,
            name = x.name,
            description = x.description,
            author = x.author,
            tags = x.tags,
        })
        ->collect()

    by_tag := make(Map(str, [..] str))
    for &ex in examples {
        for tag in ex.tags {
            example_list := by_tag->get_ptr_or_create(tag)
            example_list->push(ex.name)
        }
    }

    md.by_tag = json.empty_object()
    for by_tag->as_iter() {
        json.set(md.by_tag, it.key, json.from_any(&it.value))
    }

    use f := os.open(os.path_join(Compilation_Dir, "index.json"), .Write).Ok?
    use w := io.Writer.make(&f)

    json.encode(&w, md)
}