Orkuncakilkaya
cf814d4a97
A pack root is packed wholesale, and that is the right default - a game writes `pack "assets"` and everything it opens is in the pack. What also goes in is everything the game does NOT open: the preview renders a model pipeline leaves beside its meshes, the intermediate a texture bake writes and never reads again, the .blend the .gltf came out of. Nothing errors, nothing looks wrong, and the app is simply bigger than the game. The only way out the manifest offered was naming every file by hand, which is worse - a list that goes stale the day someone adds a texture. So `.packignore`, with gitignore's rules, because that is the file everyone already knows. Anchored and floating patterns, `preview/` for directories only, `*` and `?` stopping at a separator where `**` crosses one, `[a-z]` classes, `!` re-includes with the last line winning, a deeper file beating a shallower one, and no re-including out of an ignored directory. The semantics are not claimed, they are checked: the implementation was diffed against git itself over two fixtures - 35 paths, 19 patterns, nested ignore files, directory negation, `[!0-9]` and `\#` escaping - and `git check-ignore` and `ludic pack` agree on every path. Two rules of its own, because a pack is not a working tree. `.packignore` is never packed (nothing reads one at run time, and --no-ignore does not bring it back). And it governs the project's own roots only: a package's resources - the renderer's shaders above all - are added after the gather, so a stray `*.frag` in a game's ignore file cannot quietly un-ship what it needs to draw anything. `ludic pack` reports what it left out; `--no-ignore` packs everything so you can see what a rule is costing. `ludic bundle` gathers through the same path, so the two agree by construction.
138 lines
6.5 KiB
Text
138 lines
6.5 KiB
Text
# ludic — the command-line interface to the Ludic language. One native binary
|
|
# (bin/ludic) written in Ludic and compiled by Ludic; the unix tools, clang and
|
|
# the compiler it drives are invoked through the `run` intrinsic.
|
|
#
|
|
# This is everything a user of the language does: create a project, build it, run
|
|
# it, test it, add a package, format, upgrade. Nothing here is about the
|
|
# toolchain's own repository — building the compiler, reseeding it, generating
|
|
# the docs site, cutting a release live in a separate tool (dev.ludic ->
|
|
# bin/ludic-dev) that only exists in a checkout and is never installed. Someone
|
|
# who installs Ludic should not have to read past commands they cannot use.
|
|
#
|
|
# Installing (macOS, Linux):
|
|
#
|
|
# curl -fsSL https://workshopsoft.pages.workshopsoft.io/ludic/install.sh | sh
|
|
#
|
|
# Building from a checkout — the one step Ludic cannot do for itself, since
|
|
# compiling Ludic needs a compiler:
|
|
#
|
|
# mkdir -p bin && clang selfhost/ludicc.seed.ll -o bin/ludicc
|
|
# bin/ludicc tools/ludic-cli/dev.ludic -o bin/ludic-dev
|
|
# bin/ludic-dev build
|
|
program Ludic {
|
|
import "prelude.ludic"
|
|
import "build.ludic"
|
|
import "project.ludic"
|
|
import "pkg.ludic"
|
|
import "assets.ludic"
|
|
import "packignore.ludic"
|
|
import "pack.ludic"
|
|
import "bundle.ludic"
|
|
|
|
function usage() -> void {
|
|
print("ludic — the toolchain for the Ludic language")
|
|
print("")
|
|
print("usage: ludic <command> [arguments]")
|
|
print("")
|
|
print("start a game:")
|
|
print(" new <name> create a project that builds and runs as it stands")
|
|
print(" run [file] [--headless] build the project and run it")
|
|
print(" build [file] [--headless] [-o out]")
|
|
print(" compile to build/<name> (a native binary, nothing to ship beside it)")
|
|
print(" test [file...] compile and run the project's tests")
|
|
print(" clean remove build/")
|
|
print("")
|
|
print("packages:")
|
|
print(" add <module>[@version] add a dependency, then resolve + fetch + link")
|
|
print(" get resolve every package.ludic dependency and write the lock")
|
|
print(" update [module] bump a dependency (or all) to its latest published version")
|
|
print(" verify check every locked package against the store by content hash")
|
|
print(" vendor copy the resolved packages into ./vendor for offline builds")
|
|
print(" assets [--force] fetch the CC0 materials the renderer needs into assets/polyhaven/")
|
|
print(" build-lib <module.ludic> compile a package's module to a prebuilt dylib in lib/<target>/")
|
|
print(" link-flags print the clang flags to link this project's prebuilt module dylibs")
|
|
print("")
|
|
print("shipping:")
|
|
print(" pack [--out FILE] [dirs...] pack the assets into build/<name>.lpak (honouring .packignore)")
|
|
print(" pack --no-ignore ... pack everything, ignoring .packignore")
|
|
print(" pack --list FILE print what is in a pack")
|
|
print(" pack --verify FILE re-hash every entry against the table")
|
|
print(" bundle [file] build a macOS .app: icon, metadata, assets, splash")
|
|
print("")
|
|
print("the toolchain:")
|
|
print(" version print the toolchain version")
|
|
print(" upgrade [version] reinstall from the docs site (the same script that installed it)")
|
|
print(" doctor check that the install is complete and usable")
|
|
print(" fmt [--check] [paths...] format Ludic source in place (--check: report, write nothing)")
|
|
print(" lsp run the language server on stdio (what editors spawn)")
|
|
print(" help this message")
|
|
print("")
|
|
print("A file argument runs it: ludic mygame.ludic")
|
|
}
|
|
|
|
# does `s` end in ".ludic"? — `ludic mygame.ludic` runs that file, the shape
|
|
# the compiler-runner had before the CLI grew subcommands.
|
|
function is_ludic_file(s: pointer) -> bool {
|
|
let n = slen(s)
|
|
if n <= 6 { return false }
|
|
return sslice(s, n - 6, n) == ".ludic"
|
|
}
|
|
|
|
# route one subcommand to its implementation and return its exit code; -1 when
|
|
# the name is unknown. Returning (rather than exiting in place) lets entry tear
|
|
# down the per-process scratch directory before the process ends.
|
|
function dispatch(cmd: pointer) -> int {
|
|
if (cmd == "new") { return cmd_new() }
|
|
if (cmd == "build") { return cmd_build() }
|
|
if (cmd == "run") { return cmd_run() }
|
|
if (cmd == "test") { return cmd_test() }
|
|
if (cmd == "clean") { return cmd_clean() }
|
|
if (cmd == "fmt") { return cmd_fmt() }
|
|
if (cmd == "lsp") { return cmd_lsp() }
|
|
if (cmd == "doctor") { return cmd_doctor() }
|
|
if (cmd == "upgrade") { return cmd_upgrade() }
|
|
|
|
if (cmd == "add") { return cmd_pkg_add() }
|
|
if (cmd == "get") { return cmd_pkg_get() }
|
|
if (cmd == "update") { return cmd_pkg_update() }
|
|
if (cmd == "verify") { return cmd_pkg_verify() }
|
|
if (cmd == "vendor") { return cmd_pkg_vendor() }
|
|
if (cmd == "assets") { return cmd_fetch_assets() }
|
|
if (cmd == "pack") { return cmd_pack() }
|
|
if (cmd == "bundle") { return cmd_bundle() }
|
|
if (cmd == "build-lib") { return cmd_pkg_build_lib() }
|
|
if (cmd == "link-flags") { return cmd_pkg_link_flags() }
|
|
|
|
if (cmd == "version") or (cmd == "--version") or (cmd == "-v") { return cmd_version() }
|
|
if (cmd == "help") or (cmd == "--help") or (cmd == "-h") { usage(); return 0 }
|
|
|
|
# The toolchain's own tasks used to live here under `ludic dev`. Say where
|
|
# they went rather than printing "unknown command" at someone who read an
|
|
# older README or a commit message.
|
|
if (cmd == "dev") {
|
|
err("ludic: the toolchain's own tasks live in `ludic-dev`, which is built from a\n")
|
|
err(" checkout of the Ludic repository and is not part of an install:\n")
|
|
err(" clang selfhost/ludicc.seed.ll -o bin/ludicc\n")
|
|
err(" bin/ludicc tools/ludic-cli/dev.ludic -o bin/ludic-dev && bin/ludic-dev help\n")
|
|
return 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
entry {
|
|
if (arg_count() < 2) { usage(); exit(1) }
|
|
let cmd = arg(1)
|
|
# `ludic mygame.ludic` — build and run that file
|
|
if is_ludic_file(cmd) {
|
|
let rc = cmd_run_file()
|
|
tmp_cleanup()
|
|
exit(rc)
|
|
}
|
|
let code = dispatch(cmd)
|
|
tmp_cleanup()
|
|
if code >= 0 { exit(code) }
|
|
err(`ludic: unknown command '{cmd}'\n`)
|
|
usage()
|
|
exit(1)
|
|
}
|
|
}
|