Jai_Format

Formats Jai source. On success result is newly allocated (free it with free); on failure it is empty and error (temporary storage) says why, with a line:column: prefix when it points at the input: text that does not lex, unbalanced brackets, or the internal token check.

formatted, ok, error := format_source("f::(a:int)->int{return a;}\n");
assert(ok);
assert(formatted == "f :: (a: int) -> int {\n    return a;\n}\n");

_, ok, error = format_source("f :: () {");
assert(!ok && error.count > 0);

Parses the [format] section of jacket.toml text (see the docs for the keys). Other tables are skipped; without a [format] section the result is the default config. Bad values are errors, reported as line N: ...; unknown keys are dropped and listed in unknown_keys.

config, ok, error := parse_config("[format]\nindent_width = 2\nbrace_style = \"preserve\"\n");
assert(ok);
assert(config.indent_width == 2 && config.brace_style == .PRESERVE);

Sets one setting from key=value, the value written as in the TOML file (4, true, "preserve"): how a caller that already resolved the settings passes them on. Unlike the file parser, a key the formatter does not have is an error.

config: Format_Config;
ok, error := format_apply_setting(*config, "indent_width=8");
assert(ok && config.indent_width == 8);
ok, error = format_apply_setting(*config, "colour=red");
assert(!ok);

The warning for an entry of config.unknown_keys found in the file file, with a suggestion when a known key is close.

config := parse_config("[format]\nindent_wdth = 2\n");
assert(config.unknown_keys.count == 1);
note := format_unknown_setting_note(config.unknown_keys[0], "jacket.toml");
assert(note.count > 0);

Whether before and after are the same program as far as the compiler can tell: the same tokens, comments and the line breaks and adjacency the parser depends on. format_source already checks its own output with this.

ok, why := format_tokens_equivalent("x:=1;", "x := 1;");
assert(ok);
ok, why = format_tokens_equivalent("x := 1;", "x := 2;");
assert(!ok && why.count > 0);

Is path ignored by config.ignore? Globs are relative to config.root: * and ? stay within a path component, ** crosses components, and a matched directory covers its contents.

config, ok := parse_config("[format]\nignore = [\"vendor\", \"**/generated_*.jai\"]\n");
config.root = "/project";
assert(format_is_ignored(config, "/project/vendor/lib/a.jai"));
assert(format_is_ignored(config, "/project/src/deep/generated_x.jai"));
assert(!format_is_ignored(config, "/project/src/main.jai"));

Whether the glob pattern matches the path text, with the rules of format_is_ignored.

assert(format_glob_match("src/*.jai", "src/a.jai"));
assert(!format_glob_match("src/*.jai", "src/deep/a.jai"));
assert(format_glob_match("**/a.jai", "src/deep/a.jai"));

The settings for files in directory, from the nearest jacket.toml at or above it (up to stop), with read supplying file contents. file is the jacket.toml that was used, or "" for the defaults.

reader :: (path: string) -> string, bool {
    if path == "/project/jacket.toml" return "[format]\nindent_width = 2\n", true;
    return "", false;
}

config, file, ok := format_find_config("/project/src", reader);
assert(ok && file == "/project/jacket.toml" && config.indent_width == 2);

a/b/c -> a/b; /a -> /; a -> "".

assert(format_parent_directory("a/b/c") == "a/b");
assert(format_parent_directory("/a") == "/");

Lines in text longer than max_width code points.

assert(format_count_long_lines("short\na much longer line\n", 10) == 1);

The settings for files in directory: the [format] of the nearest jacket.toml in it or one of its parents, up to and including stop ("" to go to the top), else the defaults. file is the jacket.toml that was used ("" for the defaults); config.root is its directory. When the file cannot be parsed, ok is false and error says why (line N: ...).

a/b/c -> a/b; /a -> /; a -> "".

Where an opening brace goes.

The formatter's settings, which are the keys of the [format] table in jacket.toml. The defaults are what you get with no config. Lines are never rewrapped; max_width only feeds format_count_long_lines.

config: Format_Config;
config.indent_width = 2;
formatted, ok := format_source("main :: () {\nx := 1;\n}\n", config);
assert(ok && formatted == "main :: () {\n  x := 1;\n}\n");

Reads the file at path for format_find_config: its text, and whether it could be read.

The config file the command-line tool looks for, upward from each file (its [format] section).