feat: Added --color flag.

Allows printing data in tabular or json format.

TODOS.md

@@ -1,42 +1,34 @@
 # TODOs
 
-1. Commands are still leaking.
+1. Bring back windows support / cross-compilation.
 
-2. Add color flag and support non colored output.
+2. Commands are still leaking. (Write tests for everything first)
 
-3. Rewrite `write_command_help` to use text/tables
+3. procedures should be ordered by use, main at the top, then in the order they are called from main.
 
-4. Generate md and man pages again.
+4. Check for prealloc opportunities. i.e. `make([dynamic]string)` -> `make([dynamic]string, 5)`.
 
-5. Json may be an expensive encoding for remotes. Confirm with spall, and use null terminated strings if necessary.
+5. Test all cmds / terminal branches.
 
-6. Make sure official path separators are used when appropriate, rather than '/'.
+6. Generate md and man pages again.
 
-7. Consistently ignore allocator errors
+7. Shell completion
 
-8. Check for prealloc opportunities. i.e. `make([dynamic]string)` -> `make([dynamic]string, 5)`.
+8. Add tests for untested commands.
 
-9. Add a text filter to the multi_select.
+9. Update `read_wire_string` to use a slice.
 
-10. Add tests for untested commands.
+10. Pass allocator to findr?
 
-11. add --format -f flag to commands that draw tables.
+11. Smarter flag parsing?
 
-12. Replace `testing.expect` calls with `testing.expect_value` calls where appropriate.
+12. Rewrite `write_command_help` to use text/tables
 
-13. procedures should be ordered by use, main at the top, then in the order they are called from main.
+13. Instead of using a writer to strip colors, just don't print the colors.
 
-14. Shell completion
+14. Add a text filter to the multi_select.
 
-15. Bring back windows support / cross-compilation.
+15. init -h doesn't show --force flag. Separate into multiple structs: Global_FLags, and Init_Flags?
-
-16. Test all cmds / terminal branches.
-
-17. Fix error messages to use fmt.eprintf (stderr) instead of fmt.printf (stdout)
-
-18. Pass allocator to findr?
-
-19. Update `read_wire_string` to use a slice.
 
 ## Double-check AI output
 
@@ -64,6 +56,7 @@
 - [ ] db.odin
 - [ ] db_integration_test.odin
 - [ ] db_test.odin
+- [ ] flags.odin
 - [x] main.odin
 - [x] prompt.odin
 - [x] scan.odin

cli.odin

@@ -5,19 +5,39 @@ import "core:fmt"
 import "core:io"
 import "core:os"
 import "core:strings"
+import "core:terminal"
 import "core:text/table"
 
 Command :: struct {
 	name:    string,
 	args:    [dynamic]string,
-	flags:       map[string]string,
+	flags:   Flags,
-	bool_set:    map[string]bool,
-	config_path: string,
 	out_buf: ^bufio.Writer,
 	out:     io.Writer,
 	err:     io.Writer,
 }
 
+// TODO: Put help test in usage:"whatever" tag.
+Flags :: struct {
+	help:        bool `args:"short=h"`,
+	config_file: string `args:"name=config-file,short=c"`,
+	output:      Output_Format `args:"short=o"`,
+	color:       Color_Mode,
+	force:       bool `args:"short=f"`,
+}
+
+Output_Format :: enum {
+	Auto,
+	Table,
+	JSON,
+}
+
+Color_Mode :: enum {
+	Auto,
+	Always,
+	Never,
+}
+
 CommandInfo :: struct {
 	name:    string,
 	usage:   string,
@@ -71,53 +91,33 @@ parse_args :: proc(args: []string, out: io.Stream, err: io.Stream) -> (cmd: Comm
 	}
 
 	cmd.name = args[1]
-
 	cmd.args = make([dynamic]string)
-	cmd.flags = make(map[string]string)
-	cmd.bool_set = make(map[string]bool)
 
-	// TODO: Optimize loop?
+	overflow := parse_flags(&cmd.flags, args[2:])
-	i := 2
+	for arg in overflow {
-	for i < len(args) {
-		arg := args[i]
-		if strings.starts_with(arg, "--") {
-			key := arg[2:]
-			if i + 1 < len(args) && !strings.starts_with(args[i + 1], "-") {
-				cmd.flags[key] = args[i + 1]
-				i += 2
-			} else {
-				cmd.bool_set[key] = true
-				i += 1
-			}
-		} else if strings.starts_with(arg, "-") && len(arg) == 2 {
-			key_slice := arg[1:2]
-			if i + 1 < len(args) && !strings.starts_with(args[i + 1], "-") {
-				cmd.flags[key_slice] = args[i + 1]
-				i += 2
-			} else {
-				cmd.bool_set[key_slice] = true
-				i += 1
-			}
-		} else {
 		append(&cmd.args, arg)
-			i += 1
-		}
 	}
 
-	val: string = ---
+	if cmd.flags.output == .Auto {
-	if val, ok = cmd.flags["config-file"]; ok {
+		cmd.flags.output = terminal.is_terminal(os.stdout) ? .Table : .JSON
-		cmd.config_path = val
+	}
-	} else if val, ok = cmd.flags["c"]; ok {
+
-		cmd.config_path = val
+	if cmd.flags.color == .Auto {
-	} else {
+		cmd.flags.color = terminal.is_terminal(os.stdout) ? .Always : .Never
+	}
+	if cmd.flags.color == .Never {
+		cmd.out = make_ansi_strip_writer(cmd.out)
+	}
+
+	if cmd.flags.config_file == "" {
 		// FIXME: Handle err
 		// TODO: Is this right?
 		home, _ := os.user_home_dir(context.temp_allocator)
 		// TODO: should we copy out of the temp_allocator?
-		cmd.config_path = default_config_path(home, context.temp_allocator)
+		cmd.flags.config_file = default_config_path(home, context.temp_allocator)
 	}
 
-	if has_flag(&cmd, "help") {
+	if cmd.flags.help {
 		print_command_help(&cmd)
 		return cmd, false
 	}
@@ -288,6 +288,16 @@ at before, restore your backup with:
 		COLOR_FLAGS + "-c, --config-file" + ANSI_RESET + " <path>",
 		`config file (default "~/.envr/config.json")`,
 	)
+	table.row(
+		&tbl,
+		COLOR_FLAGS + "-o, --output" + ANSI_RESET + " 'table'|'json'",
+		`the format of output data. (default 'table')`,
+	)
+	table.row(
+		&tbl,
+		COLOR_FLAGS + "--color" + ANSI_RESET + " 'auto'|'always'|'never'",
+		`Whether or not to colorize output. (default 'auto')`,
+	)
 	write_borderless_table(w, &tbl)
 
 	fmt.wprintf(
@@ -299,15 +309,9 @@ at before, restore your backup with:
 	)
 }
 
-has_flag :: proc(cmd: ^Command, name: string) -> bool {
-	return name in cmd.flags || name in cmd.bool_set
-}
-
 delete_command :: proc(cmd: ^Command) {
 	bufio.writer_flush(cmd.out_buf)
 	delete(cmd.args)
-	delete(cmd.flags)
-	delete(cmd.bool_set)
 	bufio.writer_destroy(cmd.out_buf)
 	free(cmd.out_buf)
 }

cli_test.odin

@@ -123,7 +123,7 @@ test_command_help_unknown :: proc(t: ^testing.T) {
 
 	text := strings.to_string(b)
 	testing.expect_value(t, len(text), 0)
-}
+}
 
 @(test)
 test_command_help_version :: proc(t: ^testing.T) {
@@ -144,53 +144,6 @@ test_command_help_version :: proc(t: ^testing.T) {
 }
 
 test_parse_args :: proc(
-test_has_flag_bool_set :: proc(t: ^testing.T) {
-	cmd := Command {
-		name = "test",
-		bool_set = map[string]bool{"force" = true},
-	}
-	defer delete(cmd.bool_set)
-
-	testing.expect(t, has_flag(&cmd, "force"), "should find flag in bool_set")
-	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
-}
-
-@(test)
-test_has_flag_value_map :: proc(t: ^testing.T) {
-	cmd := Command {
-		name = "test",
-		flags = map[string]string{"output" = "/tmp/out"},
-	}
-	defer delete(cmd.flags)
-
-	testing.expect(t, has_flag(&cmd, "output"), "should find flag in flags map")
-	testing.expect(t, !has_flag(&cmd, "force"), "should not find missing flag")
-}
-
-@(test)
-test_has_flag_both_maps :: proc(t: ^testing.T) {
-	cmd := Command {
-		name = "test",
-		flags = map[string]string{"output" = "/tmp/out"},
-		bool_set = map[string]bool{"force" = true},
-	}
-	defer delete(cmd.flags)
-	defer delete(cmd.bool_set)
-
-	testing.expect(t, has_flag(&cmd, "output"), "should find in flags")
-	testing.expect(t, has_flag(&cmd, "force"), "should find in bool_set")
-	testing.expect(t, !has_flag(&cmd, "verbose"), "should not find missing flag")
-}
-
-@(test)
-test_has_flag_empty_command :: proc(t: ^testing.T) {
-	cmd := Command {
-		name = "test",
-	}
-	testing.expect(t, !has_flag(&cmd, "anything"), "empty command should have no flags")
-}
-
-test_parse_args :: proc(
 	args: []string,
 ) -> (
 	cmd: Command,
@@ -226,8 +179,6 @@ test_parse_args_bare_command :: proc(t: ^testing.T) {
 	testing.expect_value(t, cmd.name, "list")
 	testing.expect_value(t, len(cmd.args), 0)
 }
-	testing.expect_value(t, len(cmd.bool_set), 0)
-}
 
 @(test)
 test_parse_args_positional :: proc(t: ^testing.T) {
@@ -236,49 +187,51 @@ test_parse_args_positional :: proc(t: ^testing.T) {
 	testing.expect(t, ok, "should succeed")
 
 	testing.expect_value(t, cmd.name, "backup")
-	testing.expect(t, len(cmd.args) == 1)
+	testing.expect_value(t, len(cmd.args), 1)
-	testing.expect(t, cmd.args[0] == "/project/.env")
+	testing.expect_value(t, cmd.args[0], "/project/.env")
-}
+}
 
 @(test)
 test_parse_args_config_file_long_flag :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "sync", "--config", "x.json"})
+	cmd, ok, _, _ := test_parse_args(
-	testing.expect(t, ok, "should succeed")
+		[]string{"envr", "sync", "--config-file", "x.json"},
+	)
+	testing.expect(t, ok, "should succeed")
 	if !ok do return
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, cmd.flags.config_file, "x.json")
-}
+}
 
 @(test)
 test_parse_args_config_file_short_flag :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "sync", "-c", "x.json"})
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "sync", "-c", "x.json"})
 	testing.expect(t, ok, "should succeed")
 	if !ok do return
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, cmd.flags.config_file, "x.json")
-}
+}
 
 @(test)
 test_parse_args_force_long_flag :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "init", "--force"})
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "init", "--force"})
 	testing.expect(t, ok, "should succeed")
 	if !ok do return
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, cmd.flags.force, true)
-}
+}
 
 @(test)
 test_parse_args_force_short_flag :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "version", "-l"})
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "init", "-f"})
-	testing.expect(t, ok, "should succeed")
+	testing.expect(t, ok, "should succeed")
 	if !ok do return
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, cmd.flags.force, true)
-}
+}
 
 @(test)
 test_parse_args_multiple_positionals :: proc(t: ^testing.T) {
@@ -288,9 +241,9 @@ test_parse_args_multiple_positionals :: proc(t: ^testing.T) {
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, len(cmd.args), 2)
-	testing.expect(t, cmd.args[0] == "a")
+	testing.expect_value(t, cmd.args[0], "a")
-	testing.expect(t, cmd.args[1] == "b")
+	testing.expect_value(t, cmd.args[1], "b")
-}
+}
 
 @(test)
 test_parse_args_mixed_flags_and_positionals :: proc(t: ^testing.T) {
@@ -300,9 +253,9 @@ test_parse_args_mixed_flags_and_positionals :: proc(t: ^testing.T) {
 	defer delete_command(&cmd)
 
 	testing.expect_value(t, cmd.flags.force, true)
-	testing.expect(t, len(cmd.args) == 1)
+	testing.expect_value(t, len(cmd.args), 1)
-	testing.expect(t, cmd.args[0] == "/project/.env")
+	testing.expect_value(t, cmd.args[0], "/project/.env")
-}
+}
 
 @(test)
 test_parse_args_no_args :: proc(t: ^testing.T) {
@@ -314,58 +267,77 @@ test_parse_args_no_args :: proc(t: ^testing.T) {
 @(test)
 test_parse_args_flag_then_positional_then_flag :: proc(t: ^testing.T) {
 	cmd, ok, _, _ := test_parse_args([]string{"envr", "backup", "--force", "a.env", "--output", "json"})
-	defer delete_command(&cmd)
+	defer delete_command(&cmd)
 	testing.expect(t, ok, "should succeed")
 
 	testing.expect_value(t, cmd.flags.force, true)
-	testing.expect(t, cmd.bool_set["verbose"] == true)
+	testing.expect_value(t, cmd.flags.output, Output_Format.JSON)
-	testing.expect(t, len(cmd.args) == 1)
+	testing.expect_value(t, len(cmd.args), 1)
-	testing.expect(t, cmd.args[0] == "a.env")
+	testing.expect_value(t, cmd.args[0], "a.env")
-}
+}
 
 @(test)
 test_parse_args_config_file_default :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args(
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list"})
-		[]string{"envr", "list", "--config-file", "/custom/config.json"},
-	)
-	testing.expect(t, ok, "should succeed")
-	if !ok do return
-	defer delete_command(&cmd)
-
-	testing.expect(
-		t,
-		cmd.config_path == "/custom/config.json",
-		"config_path should be set from --config-file",
-	)
-}
-
-@(test)
-test_parse_args_config_file_short_flag :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "-c", "/custom/config.json"})
-	testing.expect(t, ok, "should succeed")
-	if !ok do return
-	defer delete_command(&cmd)
-
-	testing.expect(
-		t,
-		cmd.config_path == "/custom/config.json",
-		"config_path should be set from -c",
-	)
-}
-
-@(test)
-test_parse_args_config_file_defaults :: proc(t: ^testing.T) {
-	cmd, ok, _, _ := test_parse_args([]string{"envr", "list"})
 	testing.expect(t, ok, "should succeed")
 	if !ok do return
 	defer delete_command(&cmd)
 
 	testing.expect(t, len(cmd.flags.config_file) > 0, "config_file should default to non-empty path")
-	testing.expect(
+	testing.expect(
 		t,
 		strings.contains(cmd.flags.config_file, ".envr"),
-		"default config_path should contain .envr dir, got %s",
+		"default config_file should contain .envr dir, got %s",
-	)
+	)
 }
 
 @(test)
+test_parse_args_output_long_json :: proc(t: ^testing.T) {
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "--output", "json"})
+	testing.expect(t, ok, "should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	testing.expect_value(t, cmd.flags.output, Output_Format.JSON)
+}
+
+@(test)
+test_parse_args_output_short_json :: proc(t: ^testing.T) {
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "-o", "json"})
+	testing.expect(t, ok, "should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	testing.expect_value(t, cmd.flags.output, Output_Format.JSON)
+}
+
+@(test)
+test_parse_args_output_long_table :: proc(t: ^testing.T) {
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "--output", "table"})
+	testing.expect(t, ok, "should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	testing.expect_value(t, cmd.flags.output, Output_Format.Table)
+}
+
+@(test)
+test_parse_args_output_short_table :: proc(t: ^testing.T) {
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "-o", "table"})
+	testing.expect(t, ok, "should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	testing.expect_value(t, cmd.flags.output, Output_Format.Table)
+}
+
+@(test)
+test_parse_args_output_equals_syntax :: proc(t: ^testing.T) {
+	cmd, ok, _, _ := test_parse_args([]string{"envr", "list", "--output=json"})
+	testing.expect(t, ok, "should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	testing.expect_value(t, cmd.flags.output, Output_Format.JSON)
+}
+

cmd_backup.odin

@@ -23,7 +23,7 @@ cmd_backup :: proc(cmd: ^Command) {
 		return
 	}
 
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}

cmd_check.odin

@@ -24,7 +24,7 @@ cmd_check :: proc(cmd: ^Command) {
 		return
 	}
 
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}

cmd_check_test.odin

@@ -1,7 +1,6 @@
 #+test
 package main
 
-import "core:fmt"
 import "core:testing"
 
 @(test)
@@ -10,13 +9,9 @@ test_find_unbacked_finds_missing :: proc(t: ^testing.T) {
 	db := []EnvFile{{path = "/a/.env"}, {path = "/b/.env"}}
 
 	result := find_unbacked(local, db[:])
-	testing.expect(t, len(result) == 1, fmt.tprintf("expected 1 unbacked, got %d", len(result)))
+	testing.expect_value(t, len(result), 1)
 	if len(result) > 0 {
-		testing.expect(
+		testing.expect_value(t, result[0], "/c/.env")
-			t,
-			result[0] == "/c/.env",
-			fmt.tprintf("expected /c/.env, got %s", result[0]),
-		)
 	}
 }
 
@@ -26,7 +21,7 @@ test_find_unbacked_all_backed :: proc(t: ^testing.T) {
 	db := []EnvFile{{path = "/a/.env"}, {path = "/b/.env"}}
 
 	result := find_unbacked(local, db[:])
-	testing.expect(t, len(result) == 0, fmt.tprintf("expected 0 unbacked, got %d", len(result)))
+	testing.expect_value(t, len(result), 0)
 }
 
 @(test)
@@ -35,7 +30,7 @@ test_find_unbacked_no_local :: proc(t: ^testing.T) {
 	db := []EnvFile{{path = "/a/.env"}}
 
 	result := find_unbacked(local, db[:])
-	testing.expect(t, len(result) == 0, fmt.tprintf("expected 0 unbacked, got %d", len(result)))
+	testing.expect_value(t, len(result), 0)
 }
 
 @(test)
@@ -44,6 +39,6 @@ test_find_unbacked_none_backed :: proc(t: ^testing.T) {
 	db: []EnvFile
 
 	result := find_unbacked(local, db[:])
-	testing.expect(t, len(result) == 2, fmt.tprintf("expected 2 unbacked, got %d", len(result)))
+	testing.expect_value(t, len(result), 2)
 }
 

cmd_edit_config.odin

@@ -10,7 +10,7 @@ cmd_edit_config :: proc(cmd: ^Command) {
 		return
 	}
 
-	config_path := cmd.config_path
+	config_path := cmd.flags.config_file
 
 	if !os.exists(config_path) {
 		fmt.wprintf(

cmd_init.odin

@@ -4,11 +4,12 @@ import "core:fmt"
 import "core:terminal/ansi"
 
 cmd_init :: proc(cmd: ^Command) {
-	force := has_flag(cmd, "force") || has_flag(cmd, "f")
+	force := cmd.flags.force
+	config_file := cmd.flags.config_file
 
-	fmt.wprintln(cmd.out, cmd.config_path, flush = false)
+	fmt.wprintln(cmd.out, cmd.flags.config_file, flush = false)
 
-	_, cfg_exists := load_config(cmd.config_path)
+	_, cfg_exists := load_config(config_file)
 	if cfg_exists && !force {
 		fmt.wprintln(
 			cmd.out,
@@ -25,15 +26,23 @@ Run again with the --force flag if you want to reinitialize.`,
 	}
 
 	if len(keys) == 0 {
-		fmt.wprintln(cmd.err, `No ssh-ed25519 keys found in ~/.ssh
+		fmt.wprintln(
-Generate one with: ssh-keygen -t ed25519`, flush = false)
+			cmd.err,
+			`No ssh-ed25519 keys found in ~/.ssh
+Generate one with: ssh-keygen -t ed25519`,
+			flush = false,
+		)
 		return
 	}
 
 	selected, result := multi_select("Select SSH private keys:", keys[:])
 	defer delete(selected)
 	if result == .Cancel {
-		fmt.wprintln(cmd.out, ansi.CSI + ansi.FAINT + ansi.SGR + "Cancelled." + ANSI_RESET, flush = false)
+		fmt.wprintln(
+			cmd.out,
+			ansi.CSI + ansi.FAINT + ansi.SGR + "Cancelled." + ANSI_RESET,
+			flush = false,
+		)
 		return
 	}
 
@@ -49,7 +58,7 @@ Generate one with: ssh-keygen -t ed25519`, flush = false)
 		return
 	}
 
-	cfg := new_config(selected_paths[:], cmd.config_path)
+	cfg := new_config(selected_paths[:], config_file)
 	if !save_config(cfg, force = force) {
 		return
 	}
@@ -61,3 +70,4 @@ Generate one with: ssh-keygen -t ed25519`, flush = false)
 		flush = false,
 	)
 }
+

cmd_list.odin

@@ -5,7 +5,6 @@ import "core:fmt"
 import "core:os"
 import "core:path/filepath"
 import "core:strings"
-import "core:terminal"
 import "core:text/table"
 
 ListEntry :: struct {
@@ -13,10 +12,9 @@ ListEntry :: struct {
 	path: string `json:"path"`,
 }
 
-// TODO: Support --format flag
 // TODO: Improve table rendering
 cmd_list :: proc(cmd: ^Command) {
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}
@@ -27,7 +25,7 @@ cmd_list :: proc(cmd: ^Command) {
 		return
 	}
 
-	if terminal.is_terminal(os.stdout) {
+	if cmd.flags.output == .Table {
 		t: table.Table
 		table.init(&t, context.temp_allocator, context.temp_allocator)
 		table.padding(&t, 1, 1)
@@ -51,18 +49,22 @@ cmd_list :: proc(cmd: ^Command) {
 		table.write_decorated_table(cmd.out, &t, decorations, ansi_aware_width)
 	} else {
 		// TODO: Should we instead print full entries here?
-		entries: [dynamic]ListEntry
+		entries := make([dynamic]ListEntry, 0, len(rows), context.temp_allocator)
 		for row in rows {
 			filename := filepath.base(row.path)
 			append(
 				&entries,
 				ListEntry {
-					dir = strings.concatenate({row.dir, "/"}, context.temp_allocator),
+					dir = strings.concatenate(
+						{row.dir, os.Path_Separator_String},
+						context.temp_allocator,
+					),
 					path = filename,
 				},
 			)
 		}
 
+
 		data, marshal_err := json.marshal(entries[:], allocator = context.temp_allocator)
 		if marshal_err != nil {
 			fmt.wprintf(cmd.err, "Error marshaling JSON: %v\n", marshal_err, flush = false)

cmd_list_test.odin

@@ -1,7 +1,11 @@
+#+feature dynamic-literals
 #+test
 package main
 
+import "core:bufio"
+import "core:os"
 import "core:path/filepath"
+import "core:strings"
 import "core:testing"
 
 @(test)
@@ -11,9 +15,101 @@ test_filepath_base_equals_rel :: proc(t: ^testing.T) {
 	for path in cases {
 		dir := filepath.dir(path)
 		rel, rel_err := filepath.rel(dir, path, context.temp_allocator)
-		testing.expect(t, rel_err == nil, "filepath.rel returned an error")
+		testing.expect_value(t, rel_err, nil)
 		base := filepath.base(path)
-		testing.expect(t, rel == base, "filepath.rel(dir, path) should equal filepath.base(path)")
+		testing.expect_value(t, rel, base)
 	}
 }
 
+@(test)
+test_cmd_list_output_json :: proc(t: ^testing.T) {
+	base := test_temp_dir(t, "envr-test-list-json-*")
+	defer os.remove_all(base)
+
+	cfg_path, _ := filepath.join([]string{base, "config.json"}, context.temp_allocator)
+	cfg := new_config([]string{"fixtures/keys/insecure-test-key"}, cfg_path)
+	testing.expect(t, save_config(cfg, force = true), "save should succeed")
+	delete_config(&cfg)
+
+	db, db_ok := db_open(cfg_path)
+	testing.expect(t, db_ok, "db should open")
+	if !db_ok do return
+	f := make_test_env_file("/project/.env", "abc123", "SECRET=value")
+	defer delete(f.remotes)
+	testing.expect(t, db_insert(&db, f), "insert should succeed")
+	db_close(&db)
+
+	out_b: strings.Builder
+	strings.builder_init(&out_b)
+	defer strings.builder_destroy(&out_b)
+	err_b: strings.Builder
+	strings.builder_init(&err_b)
+	defer strings.builder_destroy(&err_b)
+
+	cmd, ok := parse_args(
+		[]string{"envr", "list", "--output", "json", "--config-file", cfg_path},
+		strings.to_stream(&out_b),
+		strings.to_stream(&err_b),
+	)
+	testing.expect(t, ok, "parse_args should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	cmd_list(&cmd)
+	bufio.writer_flush(cmd.out_buf)
+	output := strings.to_string(out_b)
+
+	testing.expect(t, strings.contains(output, "["), "json output should contain '['")
+	testing.expect(
+		t,
+		strings.contains(output, "\"directory\""),
+		"json output should contain directory key",
+	)
+}
+
+@(test)
+test_cmd_list_output_table :: proc(t: ^testing.T) {
+	base := test_temp_dir(t, "envr-test-list-table-*")
+	defer os.remove_all(base)
+
+	cfg_path, _ := filepath.join([]string{base, "config.json"}, context.temp_allocator)
+	cfg := new_config([]string{"fixtures/keys/insecure-test-key"}, cfg_path)
+	testing.expect(t, save_config(cfg, force = true), "save should succeed")
+	delete_config(&cfg)
+
+	db, db_ok := db_open(cfg_path)
+	testing.expect(t, db_ok, "db should open")
+	if !db_ok do return
+	f := make_test_env_file("/project/.env", "abc123", "SECRET=value")
+	defer delete(f.remotes)
+	testing.expect(t, db_insert(&db, f), "insert should succeed")
+	db_close(&db)
+
+	out_b: strings.Builder
+	strings.builder_init(&out_b)
+	defer strings.builder_destroy(&out_b)
+	err_b: strings.Builder
+	strings.builder_init(&err_b)
+	defer strings.builder_destroy(&err_b)
+
+	cmd, ok := parse_args(
+		[]string{"envr", "list", "--output", "table", "--config-file", cfg_path},
+		strings.to_stream(&out_b),
+		strings.to_stream(&err_b),
+	)
+	testing.expect(t, ok, "parse_args should succeed")
+	if !ok do return
+	defer delete_command(&cmd)
+
+	cmd_list(&cmd)
+	bufio.writer_flush(cmd.out_buf)
+	output := strings.to_string(out_b)
+
+	testing.expect(t, strings.contains(output, "│"), "table output should contain border chars")
+	testing.expect(
+		t,
+		strings.contains(output, "Directory"),
+		"table output should contain Directory header",
+	)
+}
+

cmd_remove.odin

@@ -22,7 +22,7 @@ cmd_remove :: proc(cmd: ^Command) {
 		return
 	}
 
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}

cmd_restore.odin

@@ -23,7 +23,7 @@ cmd_restore :: proc(cmd: ^Command) {
 		return
 	}
 
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}

cmd_scan.odin

@@ -7,7 +7,7 @@ import "core:terminal"
 import "core:terminal/ansi"
 
 cmd_scan :: proc(cmd: ^Command) {
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}

cmd_sync.odin

@@ -2,8 +2,6 @@ package main
 
 import "core:encoding/json"
 import "core:fmt"
-import "core:os"
-import "core:terminal"
 import "core:text/table"
 
 SyncEntry :: struct {
@@ -12,9 +10,8 @@ SyncEntry :: struct {
 }
 
 // TODO: Check for quiet failures.
-// TODO: Support --format -f flags
 cmd_sync :: proc(cmd: ^Command) {
-	db, db_ok := db_open(cmd.config_path)
+	db, db_ok := db_open(cmd.flags.config_file)
 	if !db_ok {
 		return
 	}
@@ -49,7 +46,7 @@ cmd_sync :: proc(cmd: ^Command) {
 		}
 	}
 
-	if terminal.is_terminal(os.stdout) {
+	if cmd.flags.output == .Table {
 		t: table.Table
 		table.init(&t, context.temp_allocator, context.temp_allocator)
 		table.padding(&t, 1, 1)

colors.odin

@@ -1,5 +1,6 @@
 package main
 
+import "core:io"
 import "core:terminal/ansi"
 
 COLOR_HEADINGS ::
@@ -15,3 +16,71 @@ COLOR_TABLE_HEADING :: ansi.CSI + ansi.FG_BRIGHT_GREEN + ansi.SGR
 
 ANSI_RESET :: ansi.CSI + ansi.RESET + ansi.SGR
 
+ANSI_Strip_State :: enum { Normal, GotESC, InCSI }
+
+ANSI_Strip_Data :: struct {
+	inner: io.Writer,
+	state: ANSI_Strip_State,
+}
+
+ansi_strip_proc :: proc(
+	stream_data: rawptr,
+	mode:        io.Stream_Mode,
+	p:           []byte,
+	offset:      i64,
+	whence:      io.Seek_From,
+) -> (n: i64, err: io.Error) {
+	data := cast(^ANSI_Strip_Data) stream_data
+
+	#partial switch mode {
+	case .Write:
+		start := 0
+		for i in 0..<len(p) {
+			b := p[i]
+
+			switch data.state {
+			case .Normal:
+				if b == 0x1b {
+					if i > start {
+						io.write(data.inner, p[start:i])
+					}
+					data.state = .GotESC
+				}
+
+			case .GotESC:
+				if b == '[' {
+					data.state = .InCSI
+				} else {
+					start = i
+					data.state = .Normal
+				}
+
+			case .InCSI:
+				if b >= 0x40 && b <= 0x7E {
+					start = i + 1
+					data.state = .Normal
+				}
+			}
+		}
+
+		if data.state == .Normal && len(p) > start {
+			io.write(data.inner, p[start:])
+		}
+
+		n = i64(len(p))
+		return
+
+	case .Flush:
+		return 0, io.flush(data.inner)
+	case .Close:
+		return 0, io.close(data.inner)
+	case:
+		return data.inner.procedure(data.inner.data, mode, p, offset, whence)
+	}
+}
+
+make_ansi_strip_writer :: proc(inner: io.Writer) -> io.Writer {
+	data := new(ANSI_Strip_Data, context.temp_allocator)
+	data.inner = inner
+	return io.Writer{procedure = ansi_strip_proc, data = rawptr(data)}
+}

config.odin

@@ -30,14 +30,14 @@ load_config :: proc(config_path: string, allocator := context.allocator) -> (Con
 	// TODO: Should we use context.allocator + defer delete()?
 	data, read_err := os.read_entire_file_from_path(config_path, context.temp_allocator)
 	if read_err != nil {
-		fmt.println("No config file found. Please run `envr init` to generate one.")
+		fmt.eprintln("No config file found. Please run `envr init` to generate one.")
 		return Config{}, false
 	}
 
 	cfg: Config
 	err := json.unmarshal(data, &cfg, .JSON5, allocator)
 	if err != nil {
-		fmt.printf("Error parsing config: %v\n", err)
+		fmt.eprintf("Error parsing config: %v\n", err)
 		return Config{}, false
 	}
 	cfg.config_path = config_path
@@ -79,7 +79,7 @@ save_config :: proc(cfg: Config, force: bool = false) -> bool {
 	if !os.exists(config_dir) {
 		mkdir_err := os.make_directory(config_dir)
 		if mkdir_err != nil {
-			fmt.printf("Error creating %s directory: %v\n", config_dir, mkdir_err)
+			fmt.eprintf("Error creating %s directory: %v\n", config_dir, mkdir_err)
 			return false
 		}
 	}
@@ -89,7 +89,7 @@ save_config :: proc(cfg: Config, force: bool = false) -> bool {
 		if stat_err == nil {
 			defer os.file_info_delete(info, context.temp_allocator)
 			if info.size > 0 {
-				fmt.println("Config file already exists. Run again with --force to reinitialize.")
+				fmt.eprintln("Config file already exists. Run again with --force to reinitialize.")
 				return false
 			}
 		}
@@ -101,13 +101,13 @@ save_config :: proc(cfg: Config, force: bool = false) -> bool {
 		context.temp_allocator,
 	)
 	if marshal_err != nil {
-		fmt.printf("Error marshaling config: %v\n", marshal_err)
+		fmt.eprintf("Error marshaling config: %v\n", marshal_err)
 		return false
 	}
 
 	write_err := os.write_entire_file(cfg.config_path, data)
 	if write_err != nil {
-		fmt.printf("Error writing config: %v\n", write_err)
+		fmt.eprintf("Error writing config: %v\n", write_err)
 		return false
 	}
 
@@ -123,7 +123,7 @@ new_config :: proc(
 	for priv in private_key_paths {
 		// TODO: Is this bad?
 		priv_key := strings.clone(priv)
-		pub, _ := strings.concatenate([]string{priv_key, ".pub"})
+		pub := strings.concatenate([]string{priv_key, ".pub"})
 		append(&keys, SshKeyPair{private = priv_key, public = pub})
 	}
 
@@ -150,19 +150,19 @@ new_config :: proc(
 find_ssh_private_keys :: proc() -> (keys: [dynamic]string, ok: bool) {
 	home, home_err := os.user_home_dir(context.allocator)
 	if home_err != nil {
-		fmt.printf("Error getting home dir: %v\n", home_err)
+		fmt.eprintf("Error getting home dir: %v\n", home_err)
 		return
 	}
 
 	ssh_dir, join_err := filepath.join([]string{home, ".ssh"})
 	if join_err != nil {
-		fmt.printf("Error building ssh path: %v\n", join_err)
+		fmt.eprintf("Error building ssh path: %v\n", join_err)
 		return
 	}
 
 	entries, dir_err := os.read_all_directory_by_path(ssh_dir, context.allocator)
 	if dir_err != nil {
-		fmt.printf("Could not read ~/.ssh directory: %v\n", dir_err)
+		fmt.eprintf("Could not read ~/.ssh directory: %v\n", dir_err)
 		return
 	}
 	defer os.file_info_slice_delete(entries, context.allocator)

config_test.odin

@@ -16,13 +16,9 @@ test_new_config_single_key :: proc(t: ^testing.T) {
 	cfg := new_config(paths)
 	defer delete_config(&cfg)
 
-	testing.expect(t, len(cfg.keys) == 1, "should have 1 key")
+	testing.expect_value(t, len(cfg.keys), 1)
-	testing.expect(t, cfg.keys[0].private == "/home/user/.ssh/id_ed25519", "Private path mismatch")
+	testing.expect_value(t, cfg.keys[0].private, "/home/user/.ssh/id_ed25519")
-	testing.expect(
+	testing.expect_value(t, cfg.keys[0].public, "/home/user/.ssh/id_ed25519.pub")
-		t,
-		cfg.keys[0].public == "/home/user/.ssh/id_ed25519.pub",
-		"Public path mismatch",
-	)
 }
 
 @(test)
@@ -31,9 +27,9 @@ test_new_config_multiple_keys :: proc(t: ^testing.T) {
 	cfg := new_config(paths)
 	defer delete_config(&cfg)
 
-	testing.expect(t, len(cfg.keys) == 2, "should have 2 keys")
+	testing.expect_value(t, len(cfg.keys), 2)
-	testing.expect(t, cfg.keys[0].private == "/home/user/.ssh/id_ed25519")
+	testing.expect_value(t, cfg.keys[0].private, "/home/user/.ssh/id_ed25519")
-	testing.expect(t, cfg.keys[1].private == "/home/user/.ssh/id_rsa")
+	testing.expect_value(t, cfg.keys[1].private, "/home/user/.ssh/id_rsa")
 }
 
 @(test)
@@ -42,7 +38,7 @@ test_new_config_empty_keys :: proc(t: ^testing.T) {
 	cfg := new_config(paths)
 	defer delete_config(&cfg)
 
-	testing.expect(t, len(cfg.keys) == 0, "should have 0 keys")
+	testing.expect_value(t, len(cfg.keys), 0)
 }
 
 @(test)
@@ -51,10 +47,10 @@ test_new_config_scan_defaults :: proc(t: ^testing.T) {
 	cfg := new_config(paths)
 	defer delete_config(&cfg)
 
-	testing.expect(t, cfg.scan_config.matcher == "\\.env", "matcher should be \\.env")
+	testing.expect_value(t, cfg.scan_config.matcher, "\\.env")
-	testing.expect(t, len(cfg.scan_config.exclude) == 4, "should have 4 exclude patterns")
+	testing.expect_value(t, len(cfg.scan_config.exclude), 4)
-	testing.expect(t, len(cfg.scan_config.include) == 1, "should have 1 include path")
+	testing.expect_value(t, len(cfg.scan_config.include), 1)
-	testing.expect(t, cfg.scan_config.include[0] == "~", "include should be ~")
+	testing.expect_value(t, cfg.scan_config.include[0], "~")
 }
 
 @(test)
@@ -65,7 +61,7 @@ test_new_config_exclude_patterns :: proc(t: ^testing.T) {
 
 	expected := []string{"*\\.envrc", "\\.local/", "node_modules", "vendor"}
 	for i in 0 ..< len(expected) {
-		testing.expect(t, cfg.scan_config.exclude[i] == expected[i])
+		testing.expect_value(t, cfg.scan_config.exclude[i], expected[i])
 	}
 }
 
@@ -75,7 +71,7 @@ test_save_load_config_roundtrip :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfgPath, err := filepath.join([]string{base, "config.json"}, context.temp_allocator)
-	testing.expect(t, err == nil, "cfgPath should build successfully")
+	testing.expect_value(t, err, nil)
 
 	cfg := new_config([]string{"/home/user/.ssh/id_ed25519"}, cfgPath)
 	defer delete_config(&cfg)
@@ -87,13 +83,13 @@ test_save_load_config_roundtrip :: proc(t: ^testing.T) {
 	if !ok do return
 	defer delete_config(&loaded)
 
-	testing.expect(t, len(loaded.keys) == 1, "should have 1 key")
+	testing.expect_value(t, len(loaded.keys), 1)
-	testing.expect(t, loaded.keys[0].private == "/home/user/.ssh/id_ed25519")
+	testing.expect_value(t, loaded.keys[0].private, "/home/user/.ssh/id_ed25519")
-	testing.expect(t, loaded.keys[0].public == "/home/user/.ssh/id_ed25519.pub")
+	testing.expect_value(t, loaded.keys[0].public, "/home/user/.ssh/id_ed25519.pub")
-	testing.expect(t, loaded.scan_config.matcher == "\\.env")
+	testing.expect_value(t, loaded.scan_config.matcher, "\\.env")
-	testing.expect(t, len(loaded.scan_config.exclude) == 4)
+	testing.expect_value(t, len(loaded.scan_config.exclude), 4)
-	testing.expect(t, len(loaded.scan_config.include) == 1)
+	testing.expect_value(t, len(loaded.scan_config.include), 1)
-	testing.expect(t, loaded.scan_config.include[0] == "~")
+	testing.expect_value(t, loaded.scan_config.include[0], "~")
 }
 
 @(test)
@@ -108,7 +104,7 @@ test_save_config_no_clobber :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfgPath, err := filepath.join([]string{base, "config.json"}, context.temp_allocator)
-	testing.expect(t, err == nil, "cfgPath should build successfully")
+	testing.expect_value(t, err, nil)
 
 	cfg := new_config([]string{"/home/user/.ssh/key1"}, cfgPath)
 	defer delete_config(&cfg)
@@ -125,7 +121,7 @@ test_save_config_force_overwrites :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfgPath, err := filepath.join([]string{base, "config.json"}, context.temp_allocator)
-	testing.expect(t, err == nil, "cfgPath should build successfully")
+	testing.expect_value(t, err, nil)
 
 	cfg := new_config([]string{"/home/user/.ssh/key1"}, cfgPath)
 	defer delete_config(&cfg)
@@ -140,12 +136,8 @@ test_save_config_force_overwrites :: proc(t: ^testing.T) {
 	if !ok do return
 	defer delete_config(&loaded)
 
-	testing.expect(t, len(loaded.keys) == 1, "should have 1 key")
+	testing.expect_value(t, len(loaded.keys), 1)
-	testing.expect(
+	testing.expect_value(t, loaded.keys[0].private, "/home/user/.ssh/key2")
-		t,
-		loaded.keys[0].private == "/home/user/.ssh/key2",
-		"should be the overwritten key",
-	)
 }
 
 @(test)
@@ -190,7 +182,7 @@ test_search_paths_expands_tilde :: proc(t: ^testing.T) {
 
 	paths := search_paths(cfg, context.temp_allocator)
 
-	testing.expect(t, len(paths) == 1, "should have 1 path")
+	testing.expect_value(t, len(paths), 1)
 	if len(paths) > 0 {
 		testing.expectf(
 			t,

crypto.odin

@@ -60,7 +60,7 @@ encrypt :: proc(plaintext: []u8, keys: []SshKeyPair) -> (ciphertext: []u8, ok: b
 		&sym_key[0],
 	)
 	if rc != 0 {
-		fmt.println("Error: symmetric encryption failed")
+		fmt.eprintln("Error: symmetric encryption failed")
 		delete(secret_ct)
 		return
 	}
@@ -84,7 +84,7 @@ encrypt :: proc(plaintext: []u8, keys: []SshKeyPair) -> (ciphertext: []u8, ok: b
 			&x25519_pairs[0].Private[0],
 		)
 		if rc != 0 {
-			fmt.printf("Error: failed to encrypt for recipient %d\n", i)
+			fmt.eprintf("Error: failed to encrypt for recipient %d\n", i)
 			delete(entries)
 			delete(secret_ct)
 			return
@@ -132,13 +132,13 @@ encrypt :: proc(plaintext: []u8, keys: []SshKeyPair) -> (ciphertext: []u8, ok: b
 
 decrypt :: proc(ciphertext: []u8, keys: []SshKeyPair) -> (plaintext: []u8, ok: bool) {
 	if len(ciphertext) < HEADER_SIZE {
-		fmt.println("Error: ciphertext too short (header)")
+		fmt.eprintln("Error: ciphertext too short (header)")
 		return
 	}
 
 	for i in 0 ..< 4 {
 		if ciphertext[i] != MAGIC_BYTES[i] {
-			fmt.println("Error: invalid magic bytes")
+			fmt.eprintln("Error: invalid magic bytes")
 			return
 		}
 	}
@@ -166,7 +166,7 @@ decrypt :: proc(ciphertext: []u8, keys: []SshKeyPair) -> (plaintext: []u8, ok: b
 
 	recipients_end := offset + int(num_recipients) * RECIPIENT_ENTRY_SIZE
 	if recipients_end > len(ciphertext) {
-		fmt.println("Error: ciphertext too short (recipient data)")
+		fmt.eprintln("Error: ciphertext too short (recipient data)")
 		return
 	}
 
@@ -222,7 +222,7 @@ decrypt :: proc(ciphertext: []u8, keys: []SshKeyPair) -> (plaintext: []u8, ok: b
 	}
 
 	if !found {
-		fmt.println("Error: no matching recipient found")
+		fmt.eprintln("Error: no matching recipient found")
 		return
 	}
 
@@ -236,14 +236,14 @@ decrypt :: proc(ciphertext: []u8, keys: []SshKeyPair) -> (plaintext: []u8, ok: b
 		&x25519_pairs[matched_pi].Private[0],
 	)
 	if rc != 0 {
-		fmt.println("Error: failed to decrypt symmetric key")
+		fmt.eprintln("Error: failed to decrypt symmetric key")
 		return
 	}
 
 	ct_data := ciphertext[recipients_end:]
 	pt_len := len(ct_data) - CRYPTO_SECRETBOX_MAC_BYTES
 	if pt_len < 0 {
-		fmt.println("Error: ciphertext too short (no encrypted data)")
+		fmt.eprintln("Error: ciphertext too short (no encrypted data)")
 		return
 	}
 
@@ -260,7 +260,7 @@ decrypt :: proc(ciphertext: []u8, keys: []SshKeyPair) -> (plaintext: []u8, ok: b
 		&sym_key[0],
 	)
 	if rc != 0 {
-		fmt.println("Error: symmetric decryption failed")
+		fmt.eprintln("Error: symmetric decryption failed")
 		delete(plaintext)
 		return
 	}
@@ -285,21 +285,21 @@ ssh_to_x25519 :: proc(
 	for i in 0 ..< len(keys) {
 		ssh_kp, parse_ok := parse_ssh_private_key(keys[i].private)
 		if !parse_ok {
-			fmt.printf("Error: failed to parse SSH private key: %s\n", keys[i].private)
+			fmt.eprintf("Error: failed to parse SSH private key: %s\n", keys[i].private)
 			delete(pairs)
 			return pairs, false
 		}
 
 		ssh_pub, pub_ok := parse_ssh_public_key(keys[i].public)
 		if !pub_ok {
-			fmt.printf("Error: failed to parse SSH public key: %s\n", keys[i].public)
+			fmt.eprintf("Error: failed to parse SSH public key: %s\n", keys[i].public)
 			delete(pairs)
 			return pairs, false
 		}
 
 		pk_rc := crypto_sign_ed25519_pk_to_curve25519(&pairs[i].Public[0], &ssh_pub[0])
 		if pk_rc != 0 {
-			fmt.println("Error: failed to convert ed25519 public key to curve25519")
+			fmt.eprintln("Error: failed to convert ed25519 public key to curve25519")
 			delete(pairs)
 			return pairs, false
 		}
@@ -314,7 +314,7 @@ ssh_to_x25519 :: proc(
 
 		sk_rc := crypto_sign_ed25519_sk_to_curve25519(&pairs[i].Private[0], &ed25519_sk[0])
 		if sk_rc != 0 {
-			fmt.println("Error: failed to convert ed25519 private key to curve25519")
+			fmt.eprintln("Error: failed to convert ed25519 private key to curve25519")
 			delete(pairs)
 			return pairs, false
 		}

crypto_test.odin

@@ -27,13 +27,10 @@ test_encrypt_decrypt_roundtrip :: proc(t: ^testing.T) {
 	testing.expect(t, dec_ok, "decryption should succeed")
 	defer delete(decrypted)
 
-	testing.expect(
+	testing.expect_value(t, len(decrypted), len(original))
-		t,
+	// TODO: Should this be a loop?
-		len(decrypted) == len(original),
-		fmt.tprintf("expected %d bytes, got %d", len(original), len(decrypted)),
-	)
 	for i in 0 ..< len(original) {
-		testing.expect(t, decrypted[i] == original[i], fmt.tprintf("byte mismatch at index %d", i))
+		testing.expect_value(t, decrypted[i], original[i])
 	}
 }
 
@@ -56,16 +53,8 @@ test_encrypt_decrypt_multi_recipient :: proc(t: ^testing.T) {
 	defer delete(decrypted2)
 
 	for i in 0 ..< len(original) {
-		testing.expect(
+		testing.expect_value(t, decrypted1[i], original[i])
-			t,
+		testing.expect_value(t, decrypted2[i], original[i])
-			decrypted1[i] == original[i],
-			fmt.tprintf("key1: byte mismatch at %d", i),
-		)
-		testing.expect(
-			t,
-			decrypted2[i] == original[i],
-			fmt.tprintf("key2: byte mismatch at %d", i),
-		)
 	}
 }
 
@@ -96,7 +85,7 @@ test_encrypt_empty_plaintext :: proc(t: ^testing.T) {
 	testing.expect(t, dec_ok, "decryption should succeed")
 	defer delete(decrypted)
 
-	testing.expect(t, len(decrypted) == 0, "decrypted empty data should be empty")
+	testing.expect_value(t, len(decrypted), 0)
 }
 
 @(test)
@@ -113,8 +102,9 @@ test_recipient_can_decrypt_senders_data :: proc(t: ^testing.T) {
 	testing.expect(t, dec_ok, "second recipient should decrypt without the sender key present")
 	defer delete(decrypted)
 
+	// TODO: Should this be a loop?
 	for i in 0 ..< len(original) {
-		testing.expect(t, decrypted[i] == original[i], fmt.tprintf("byte mismatch at %d", i))
+		testing.expect_value(t, decrypted[i], original[i])
 	}
 }
 
@@ -128,9 +118,9 @@ test_ciphertext_has_magic :: proc(t: ^testing.T) {
 	defer delete(encrypted)
 
 	testing.expect(t, len(encrypted) >= 4, "ciphertext should have at least 4 bytes")
-	testing.expect(t, encrypted[0] == u8('E'), "magic byte 0")
+	testing.expect_value(t, encrypted[0], u8('E'))
-	testing.expect(t, encrypted[1] == u8('N'), "magic byte 1")
+	testing.expect_value(t, encrypted[1], u8('N'))
-	testing.expect(t, encrypted[2] == u8('V'), "magic byte 2")
+	testing.expect_value(t, encrypted[2], u8('V'))
-	testing.expect(t, encrypted[3] == u8('R'), "magic byte 3")
+	testing.expect_value(t, encrypted[3], u8('R'))
 }
 

db.odin

@@ -94,14 +94,14 @@ db_init :: proc() -> (db: Db, ok: bool) {
 	conn: sqlite.Db
 	rc := sqlite.open(":memory:", &conn)
 	if rc != sqlite.OK {
-		fmt.printf("Error opening in-memory database: %s\n", sqlite.errmsg(conn))
+		fmt.eprintf("Error opening in-memory database: %s\n", sqlite.errmsg(conn))
 		return
 	}
 
 	create_sql: cstring = "CREATE TABLE IF NOT EXISTS envr_env_files (path TEXT PRIMARY KEY NOT NULL, remotes TEXT, sha256 TEXT NOT NULL, contents TEXT NOT NULL)"
 	rc = sqlite.exec(conn, create_sql, nil, nil, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error creating table: %s\n", sqlite.errmsg(conn))
+		fmt.eprintf("Error creating table: %s\n", sqlite.errmsg(conn))
 		sqlite.close(conn)
 		return
 	}
@@ -119,14 +119,14 @@ db_allocator :: proc(db: ^Db) -> mem.Allocator {
 db_restore_from_encrypted :: proc(db: ^Db, data_path: string) -> bool {
 	encrypted_data, read_err := os.read_entire_file_from_path(data_path, context.temp_allocator)
 	if read_err != nil {
-		fmt.printf("Error reading encrypted database: %v\n", read_err)
+		fmt.eprintf("Error reading encrypted database: %v\n", read_err)
 		return false
 	}
 
 	// TODO: Use context.temp_allocator
 	plaintext, dec_ok := decrypt(encrypted_data, db.cfg.keys[:])
 	if !dec_ok {
-		fmt.println("Error: decryption failed")
+		fmt.eprintln("Error: decryption failed")
 		return false
 	}
 	defer delete(plaintext)
@@ -134,7 +134,7 @@ db_restore_from_encrypted :: proc(db: ^Db, data_path: string) -> bool {
 	n := i64(len(plaintext))
 	buf := sqlite.malloc64(n)
 	if buf == nil {
-		fmt.println("Error: failed to allocate buffer for deserialization")
+		fmt.eprintln("Error: failed to allocate buffer for deserialization")
 		return false
 	}
 	copy(buf[:len(plaintext)], plaintext)
@@ -144,7 +144,7 @@ db_restore_from_encrypted :: proc(db: ^Db, data_path: string) -> bool {
 	rc := sqlite.deserialize(db.conn, "main", buf, n, n, flags)
 	if rc != sqlite.OK {
 		sqlite.free(buf)
-		fmt.printf("Error deserializing database: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error deserializing database: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
@@ -167,14 +167,14 @@ db_close :: proc(db: ^Db) {
 	if db.changed && len(db.cfg.keys) > 0 {
 		rc := sqlite.exec(db.conn, "VACUUM", nil, nil, nil)
 		if rc != sqlite.OK {
-			fmt.printf("Error vacuuming database: %s\n", sqlite.errmsg(db.conn))
+			fmt.eprintf("Error vacuuming database: %s\n", sqlite.errmsg(db.conn))
 			return
 		}
 
 		sz: i64
-		data := sqlite.serialize(db.conn, "main", &sz, 0)
+		data := sqlite.serialize(db.conn, "main", &sz, {})
 		if data == nil {
-			fmt.println("Error: failed to serialize database")
+			fmt.eprintln("Error: failed to serialize database")
 			return
 		}
 		defer sqlite.free(data)
@@ -195,7 +195,7 @@ db_close :: proc(db: ^Db) {
 		write_err := os.write_entire_file(data_path, encrypted)
 		delete(encrypted)
 		if write_err != nil {
-			fmt.printf("Error writing encrypted database: %v\n", write_err)
+			fmt.eprintf("Error writing encrypted database: %v\n", write_err)
 			return
 		}
 
@@ -214,7 +214,7 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 		nil,
 	)
 	if rc != sqlite.OK {
-		fmt.printf("Error preparing query: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error preparing query: %s\n", sqlite.errmsg(db.conn))
 		return []EnvFile{}, false
 	}
 	defer sqlite.finalize(stmt)
@@ -222,23 +222,34 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 	allocator := db_allocator(db)
 	results := make([dynamic]EnvFile, 0, 10, allocator)
 
+	migrate := false
 	for {
 		rc = sqlite.step(stmt)
 		if rc == sqlite.DONE {
 			break
 		}
 		if rc != sqlite.ROW {
-			fmt.printf("Error stepping query: %s\n", sqlite.errmsg(db.conn))
+			fmt.eprintf("Error stepping query: %s\n", sqlite.errmsg(db.conn))
 			#no_bounds_check return results[:], false
 		}
 
-		remotes_json := string(sqlite.column_text(stmt, 1))
+		// TODO: Remove json support after next major release
 		remotes: [dynamic]string = ---
-		if len(remotes_json) > 0 {
+		remotes_raw := string(sqlite.column_text(stmt, 1))
-			err := json.unmarshal_string(remotes_json, &remotes, allocator = allocator)
+		if len(remotes_raw) > 0 {
+			if remotes_raw[0] == '[' {
+				err := json.unmarshal_string(remotes_raw, &remotes, allocator = allocator)
 				if err != nil {
 					fmt.eprintf("Warning: malformed remotes JSON: %v\n", err)
 				}
+				migrate = true
+			} else {
+				split := strings.split_lines(remotes_raw, context.temp_allocator)
+				remotes = make([dynamic]string, 0, len(split), allocator = allocator)
+				for s in split {
+					append(&remotes, strings.clone(s, allocator))
+				}
+			}
 		}
 		path := clone_cstring(sqlite.column_text(stmt, 0), allocator)
 
@@ -254,16 +265,16 @@ db_list :: proc(db: ^Db) -> ([]EnvFile, bool) {
 		)
 	}
 
+	if migrate {
+		migrate_remotes(db)
+	}
+
 	#no_bounds_check return results[:], true
 }
 
 // TODO: Should we use context.temp_allocator for proc scoped lifetimes?
 db_insert :: proc(db: ^Db, file: EnvFile) -> bool {
-	remotes_json, marshal_err := json.marshal(file.remotes, allocator = context.temp_allocator)
+	remotes := strings.join(file.remotes[:], "\n", allocator = context.temp_allocator)
-	if marshal_err != nil {
-		fmt.printf("Error marshaling remotes: %v\n", marshal_err)
-		return false
-	}
 
 	sql: cstring =
 		"INSERT OR REPLACE INTO " +
@@ -271,7 +282,7 @@ db_insert :: proc(db: ^Db, file: EnvFile) -> bool {
 	stmt: sqlite.Stmt
 	rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error preparing insert: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error preparing insert: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 	defer sqlite.finalize(stmt)
@@ -281,15 +292,15 @@ db_insert :: proc(db: ^Db, file: EnvFile) -> bool {
 	defer delete(cpath)
 	rc = sqlite.bind_text(stmt, 1, cpath, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding path: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding path: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
-	cremotes := to_cstring(string(remotes_json))
+	cremotes := to_cstring(remotes)
 	defer delete(cremotes)
 	rc = sqlite.bind_text(stmt, 2, cremotes, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding remotes: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding remotes: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
@@ -297,7 +308,7 @@ db_insert :: proc(db: ^Db, file: EnvFile) -> bool {
 	defer delete(csha)
 	rc = sqlite.bind_text(stmt, 3, csha, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding sha256: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding sha256: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
@@ -305,13 +316,13 @@ db_insert :: proc(db: ^Db, file: EnvFile) -> bool {
 	defer delete(ccontents)
 	rc = sqlite.bind_text(stmt, 4, ccontents, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding contents: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding contents: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
 	rc = sqlite.step(stmt)
 	if rc != sqlite.DONE {
-		fmt.printf("Error inserting: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error inserting: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
@@ -329,7 +340,7 @@ db_fetch :: proc(db: ^Db, path: string) -> (EnvFile, bool) {
 	stmt: sqlite.Stmt
 	rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error preparing fetch: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error preparing fetch: %s\n", sqlite.errmsg(db.conn))
 		return EnvFile{}, false
 	}
 	defer sqlite.finalize(stmt)
@@ -340,30 +351,46 @@ db_fetch :: proc(db: ^Db, path: string) -> (EnvFile, bool) {
 	defer delete(cpath, allocator)
 	rc = sqlite.bind_text(stmt, 1, cpath, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding path: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding path: %s\n", sqlite.errmsg(db.conn))
 		return EnvFile{}, false
 	}
 	rc = sqlite.step(stmt)
 	if rc == sqlite.DONE {
-		fmt.printf("No file found with path: %s\n", path)
+		fmt.eprintf("No file found with path: %s\n", path)
 		return EnvFile{}, false
 	}
 	if rc != sqlite.ROW {
-		fmt.printf("Error fetching: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error fetching: %s\n", sqlite.errmsg(db.conn))
 		return EnvFile{}, false
 	}
 
-	remotes_json := string(sqlite.column_text(stmt, 1))
+	// TODO: Remove json support after next major release
+	migrate := false
 	remotes: [dynamic]string = ---
-	if len(remotes_json) > 0 {
+	remotes_raw := string(sqlite.column_text(stmt, 1))
-		err := json.unmarshal_string(remotes_json, &remotes, allocator = allocator)
+	if len(remotes_raw) > 0 {
+		if remotes_raw[0] == '[' {
+			err := json.unmarshal_string(remotes_raw, &remotes, allocator = allocator)
 			if err != nil {
 				fmt.eprintf("Warning: malformed remotes JSON: %v\n", err)
 			}
+
+			migrate = true
+		} else {
+			split := strings.split_lines(remotes_raw, context.temp_allocator)
+			remotes = make([dynamic]string, 0, len(split), allocator = allocator)
+			for s in split {
+				append(&remotes, strings.clone(s, allocator))
+			}
+		}
 	}
 
 	file_path := clone_cstring(sqlite.column_text(stmt, 0), allocator)
 
+	if migrate {
+		migrate_remotes(db)
+	}
+
 	return EnvFile {
 			path = file_path,
 			dir = filepath.dir(file_path),
@@ -379,7 +406,7 @@ db_delete :: proc(db: ^Db, path: string) -> bool {
 	stmt: sqlite.Stmt
 	rc := sqlite.prepare_v2(db.conn, sql, -1, &stmt, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error preparing delete: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error preparing delete: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 	defer sqlite.finalize(stmt)
@@ -388,17 +415,17 @@ db_delete :: proc(db: ^Db, path: string) -> bool {
 	defer delete(cpath)
 	rc = sqlite.bind_text(stmt, 1, cpath, -1, nil)
 	if rc != sqlite.OK {
-		fmt.printf("Error binding path: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error binding path: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 	rc = sqlite.step(stmt)
 	if rc != sqlite.DONE {
-		fmt.printf("Error deleting: %s\n", sqlite.errmsg(db.conn))
+		fmt.eprintf("Error deleting: %s\n", sqlite.errmsg(db.conn))
 		return false
 	}
 
 	if sqlite.changes(db.conn) == 0 {
-		fmt.printf("No file found with path: %s\n", path)
+		fmt.eprintf("No file found with path: %s\n", path)
 		return false
 	}
 
@@ -410,7 +437,7 @@ db_delete :: proc(db: ^Db, path: string) -> bool {
 new_env_file :: proc(path: string) -> (EnvFile, bool) {
 	abs_path, abs_err := filepath.abs(path)
 	if abs_err != nil {
-		fmt.printf("Error getting absolute path: %v\n", abs_err)
+		fmt.eprintf("Error getting absolute path: %v\n", abs_err)
 		return EnvFile{}, false
 	}
 
@@ -421,7 +448,7 @@ new_env_file :: proc(path: string) -> (EnvFile, bool) {
 
 	data, read_err := os.read_entire_file_from_path(abs_path, context.allocator)
 	if read_err != nil {
-		fmt.printf("Error reading file %s: %v\n", abs_path, read_err)
+		fmt.eprintf("Error reading file %s: %v\n", abs_path, read_err)
 		return EnvFile{}, false
 	}
 
@@ -498,6 +525,27 @@ db_persist :: proc(db: ^Db, f: ^EnvFile, old_path: string) -> bool {
 	return db_insert(db, f^)
 }
 
+// TODO: Remove after the next major release
+migrate_remotes :: proc(db: ^Db) {
+	sql ::
+		"UPDATE envr_env_files " +
+		"SET remotes = COALESCE((" +
+		"  SELECT group_concat(atom, char(10)) " +
+		"  FROM json_each(envr_env_files.remotes)" +
+		"), '') " +
+		"WHERE remotes LIKE '[%'"
+
+	rc := sqlite.exec(db.conn, sql, nil, nil, nil)
+	if rc != sqlite.OK {
+		fmt.eprintf("Warning: failed to migrate remotes: %s\n", sqlite.errmsg(db.conn))
+		return
+	}
+
+	if sqlite.changes(db.conn) > 0 {
+		db.changed = true
+	}
+}
+
 try_move_dir :: proc(db: ^Db, f: ^EnvFile, allocator: mem.Allocator) -> (bool, SyncError) {
 	roots, ok := find_git_roots(db.cfg)
 	if !ok {
@@ -524,7 +572,7 @@ try_move_dir :: proc(db: ^Db, f: ^EnvFile, allocator: mem.Allocator) -> (bool, S
 	case 0:
 		return false, .DirMissing
 	case 1:
-		f.dir, _ = strings.clone(matched_dir, allocator)
+		f.dir = strings.clone(matched_dir, allocator)
 		base := filepath.base(f.path)
 		new_path, _ := filepath.join({f.dir, base}, allocator)
 		f.path = new_path
@@ -565,7 +613,7 @@ get_git_remotes :: proc(dir: string, allocator: mem.Allocator) -> [dynamic]strin
 				}
 				if !found {
 					// FIXME: Currently leaks when adding a file with envr scan
-					cloned, _ := strings.clone(url, allocator)
+					cloned := strings.clone(url, allocator)
 					append(&remotes, cloned)
 				}
 			}
@@ -583,7 +631,7 @@ to_cstring :: proc {
 string_to_cstring :: proc(s: string, allocator := context.allocator) -> cstring {
 	cs, err := strings.clone_to_cstring(s, allocator)
 	if err != nil {
-		fmt.printf("Failed to convert string to cstring: %v\n", err)
+		fmt.eprintf("Failed to convert string to cstring: %v\n", err)
 		panic("Allocation Exception")
 	}
 	return cs
@@ -593,7 +641,7 @@ string_to_cstring :: proc(s: string, allocator := context.allocator) -> cstring
 clone_cstring :: proc(c: cstring, allocator := context.allocator) -> string {
 	str, err := strings.clone_from_cstring(c, allocator)
 	if err != nil {
-		fmt.printf("Failed to convert string to cstring: %v\n", err)
+		fmt.eprintf("Failed to convert string to cstring: %v\n", err)
 		delete(str)
 		panic("Allocation Exception")
 	}

db_integration_test.odin

@@ -67,10 +67,10 @@ test_encrypt_decrypt_sqlite_roundtrip :: proc(t: ^testing.T) {
 	defer delete(encrypted)
 
 	testing.expect(t, len(encrypted) >= HEADER_SIZE, "ciphertext should have header")
-	testing.expect(t, encrypted[0] == u8('E'), "magic byte 0")
+	testing.expect_value(t, encrypted[0], u8('E'))
-	testing.expect(t, encrypted[1] == u8('N'), "magic byte 1")
+	testing.expect_value(t, encrypted[1], u8('N'))
-	testing.expect(t, encrypted[2] == u8('V'), "magic byte 2")
+	testing.expect_value(t, encrypted[2], u8('V'))
-	testing.expect(t, encrypted[3] == u8('R'), "magic byte 3")
+	testing.expect_value(t, encrypted[3], u8('R'))
 
 	plaintext, dec_ok := decrypt(encrypted, cfg.keys[:])
 	testing.expect(t, dec_ok, "decryption should succeed")
@@ -142,7 +142,7 @@ test_encrypt_write_read_decrypt :: proc(t: ^testing.T) {
 	}
 	defer delete(plaintext)
 
-	testing.expect(t, len(plaintext) == len(sqlite_data), "size mismatch after file round-trip")
+	testing.expect_value(t, len(plaintext), len(sqlite_data))
 }
 
 @(test)
@@ -189,7 +189,7 @@ test_decrypt_then_deserialize_sqlite :: proc(t: ^testing.T) {
 	copy(buf[:len(plaintext)], plaintext)
 
 	rc = sqlite.deserialize(mem_db, "main", buf, n, n, {.FREEONCLOSE, .RESIZEABLE})
-	testing.expect(t, rc == sqlite.OK, "deserialize should succeed")
+	testing.expect_value(t, rc, sqlite.OK)
 	if rc != sqlite.OK {
 		sqlite.free(buf)
 		return
@@ -198,14 +198,14 @@ test_decrypt_then_deserialize_sqlite :: proc(t: ^testing.T) {
 	sql: cstring = "SELECT path FROM envr_env_files"
 	stmt: sqlite.Stmt
 	rc = sqlite.prepare_v2(mem_db, sql, -1, &stmt, nil)
-	testing.expect(t, rc == sqlite.OK, "prepare failed")
+	testing.expect_value(t, rc, sqlite.OK)
 	if rc != sqlite.OK {
 		return
 	}
 	defer sqlite.finalize(stmt)
 
 	rc = sqlite.step(stmt)
-	testing.expect(t, rc == sqlite.ROW, "expected at least one row")
+	testing.expect_value(t, rc, sqlite.ROW)
 	if rc == sqlite.ROW {
 		path := string(sqlite.column_text(stmt, 0))
 		testing.expect(t, len(path) > 0, "path should not be empty")
@@ -275,15 +275,7 @@ test_full_db_cycle :: proc(t: ^testing.T) {
 	}
 	defer delete(plaintext2)
 
-	testing.expect(
+	testing.expect_value(t, len(plaintext2), len(original_data))
-		t,
-		len(plaintext2) == len(original_data),
-		fmt.tprintf(
-			"double round-trip size mismatch: expected %d, got %d",
-			len(original_data),
-			len(plaintext2),
-		),
-	)
 
 	os.remove(data_path)
 	os.remove(envr_dir_path)
@@ -317,7 +309,7 @@ test_ssh_key_parse_from_fixtures :: proc(t: ^testing.T) {
 		return
 	}
 
-	testing.expect(t, len(x25519_pairs) == 1, "should have 1 x25519 keypair")
+	testing.expect_value(t, len(x25519_pairs), 1)
 }
 
 @(test)
@@ -327,7 +319,7 @@ test_config_load_with_fixture_key :: proc(t: ^testing.T) {
 		delete(cfg.keys)
 	}
 
-	testing.expect(t, len(cfg.keys) == 1, "should have 1 key")
+	testing.expect_value(t, len(cfg.keys), 1)
 
 	key := cfg.keys[0]
 

db_test.odin

@@ -81,7 +81,7 @@ test_db_insert_or_replace :: proc(t: ^testing.T) {
 	results, list_ok := db_list(&db)
 	testing.expect(t, list_ok, "list should succeed")
 
-	testing.expect(t, len(results) == 1, "should have 1 row, not 2")
+	testing.expect_value(t, len(results), 1)
 
 	fetched, fetch_ok := db_fetch(&db, "/project/.env")
 	testing.expect(t, fetch_ok, "fetch should succeed")
@@ -149,7 +149,7 @@ test_db_list_empty :: proc(t: ^testing.T) {
 
 	results, list_ok := db_list(&db)
 	testing.expect(t, list_ok, "list should succeed on empty db")
-	testing.expect(t, len(results) == 0, "should have 0 rows")
+	testing.expect_value(t, len(results), 0)
 }
 
 @(test)
@@ -196,7 +196,7 @@ test_db_serialize :: proc(t: ^testing.T) {
 	db_insert(&db, f)
 
 	sz: i64
-	data := sqlite.serialize(db.conn, "main", &sz, 0)
+	data := sqlite.serialize(db.conn, "main", &sz, {})
 	testing.expect(t, data != nil, "serialize should return non-nil")
 	if data == nil do return
 	defer sqlite.free(data)
@@ -276,11 +276,11 @@ test_get_git_remotes_single :: proc(t: ^testing.T) {
 	config_content := "[core]\n\trepositoryformatversion = 0\n[remote \"origin\"]\n\turl = git@github.com:user/repo.git\n\tfetch = +refs/heads/*:refs/remotes/origin/*\n"
 	config_path := fmt.tprintf("%s/config", git_dir)
 	err := os.write_entire_file(config_path, transmute([]u8)config_content)
-	testing.expect(t, err == nil, "should write .git/config")
+	testing.expect_value(t, err, nil)
 
 	remotes := get_git_remotes(base, context.temp_allocator)
 
-	testing.expect(t, len(remotes) == 1, "should find 1 remote")
+	testing.expect_value(t, len(remotes), 1)
 	if len(remotes) != 1 do return
 	testing.expect_value(t, remotes[0], "git@github.com:user/repo.git")
 }
@@ -296,11 +296,11 @@ test_get_git_remotes_multiple :: proc(t: ^testing.T) {
 	config_content := "[remote \"origin\"]\n\turl = git@github.com:user/repo.git\n[remote \"upstream\"]\n\turl = https://gitlab.com/upstream/repo.git\n"
 	config_path := fmt.tprintf("%s/config", git_dir)
 	err := os.write_entire_file(config_path, transmute([]u8)config_content)
-	testing.expect(t, err == nil, "should write .git/config")
+	testing.expect_value(t, err, nil)
 
 	remotes := get_git_remotes(base, context.temp_allocator)
 
-	testing.expect(t, len(remotes) == 2, "should find 2 remotes")
+	testing.expect_value(t, len(remotes), 2)
 }
 
 @(test)
@@ -310,7 +310,7 @@ test_get_git_remotes_no_config :: proc(t: ^testing.T) {
 
 	remotes := get_git_remotes(base, context.temp_allocator)
 
-	testing.expect(t, len(remotes) == 0, "should return empty when no .git/config")
+	testing.expect_value(t, len(remotes), 0)
 }
 
 @(test)
@@ -324,11 +324,11 @@ test_get_git_remotes_no_remotes :: proc(t: ^testing.T) {
 	config_content := "[core]\n\trepositoryformatversion = 0\n\tbare = false\n"
 	config_path := fmt.tprintf("%s/config", git_dir)
 	err := os.write_entire_file(config_path, transmute([]u8)config_content)
-	testing.expect(t, err == nil, "should write .git/config")
+	testing.expect_value(t, err, nil)
 
 	remotes := get_git_remotes(base, context.temp_allocator)
 
-	testing.expect(t, len(remotes) == 0, "should return empty when no remote sections")
+	testing.expect_value(t, len(remotes), 0)
 }
 
 @(test)
@@ -338,7 +338,7 @@ test_new_env_file :: proc(t: ^testing.T) {
 
 	env_path := fmt.tprintf("%s/.env", base)
 	err := os.write_entire_file(env_path, "SECRET=value\n")
-	testing.expect(t, err == nil, ".env file should exists")
+	testing.expect_value(t, err, nil)
 
 	file, ok := new_env_file(env_path)
 	testing.expect(t, ok, "new_env_file should succeed")
@@ -350,8 +350,8 @@ test_new_env_file :: proc(t: ^testing.T) {
 
 	testing.expect(t, filepath.is_abs(file.path), "path should be absolute")
 	testing.expect(t, strings.has_suffix(file.path, "/.env"), "path should end with /.env")
-	testing.expect(t, file.contents == "SECRET=value\n", "contents mismatch")
+	testing.expect_value(t, file.contents, "SECRET=value\n")
-	testing.expect(t, len(file.sha256) == 64, "sha256 should be 64 hex chars")
+	testing.expect_value(t, len(file.sha256), 64)
 }
 
 @(test)
@@ -366,7 +366,7 @@ test_closing_db_has_no_leaks :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfg_path, err := filepath.join([]string{base, "config.json"}, context.temp_allocator)
-	testing.expect(t, err == nil, "cfgPath should build successfully")
+	testing.expect_value(t, err, nil)
 
 	{
 		cfg := new_config([]string{"fixtures/keys/insecure-test-key"}, cfg_path)
@@ -385,7 +385,7 @@ test_open_existing_db_has_no_leaks :: proc(t: ^testing.T) {
 	defer os.remove_all(base)
 
 	cfg_path, err := filepath.join([]string{base, "config.json"}, context.temp_allocator)
-	testing.expect(t, err == nil, "cfgPath should build successfully")
+	testing.expect_value(t, err, nil)
 
 	{
 		cfg := new_config([]string{"fixtures/keys/insecure-test-key"}, cfg_path)
@@ -422,7 +422,7 @@ test_db_sync_noop :: proc(t: ^testing.T) {
 	env_path := fmt.tprintf("%s/.env", base)
 	content := "KEY=value\n"
 	write_err := os.write_entire_file(env_path, transmute([]u8)content)
-	testing.expect(t, write_err == nil, "should write .env file")
+	testing.expect_value(t, write_err, nil)
 
 	digest := hash.hash_bytes(
 		hash.Algorithm.SHA256,
@@ -441,8 +441,8 @@ test_db_sync_noop :: proc(t: ^testing.T) {
 	db_insert(&db, f)
 
 	result, sync_err := db_sync(&db, &f)
-	testing.expect(t, sync_err == .None, "sync should not error")
+	testing.expect_value(t, sync_err, SyncError.None)
-	testing.expect(t, result == {}, "should be noop")
+	testing.expect_value(t, result, nil)
 }
 
 @(test)
@@ -453,7 +453,7 @@ test_db_sync_backed_up :: proc(t: ^testing.T) {
 	env_path := fmt.tprintf("%s/.env", base)
 	changed_content := "KEY=changed\n"
 	write_err := os.write_entire_file(env_path, transmute([]u8)changed_content)
-	testing.expect(t, write_err == nil, "should write .env file")
+	testing.expect_value(t, write_err, nil)
 
 	db, ok := db_init()
 	testing.expect(t, ok, "failed to create test db")
@@ -464,7 +464,7 @@ test_db_sync_backed_up :: proc(t: ^testing.T) {
 	db_insert(&db, f)
 
 	result, sync_err := db_sync(&db, &f)
-	testing.expect(t, sync_err == .None, "sync should not error")
+	testing.expect_value(t, sync_err, SyncError.None)
 	testing.expect(t, .BackedUp in result, "should be backed up")
 }
 
@@ -485,11 +485,11 @@ test_db_sync_restored :: proc(t: ^testing.T) {
 	db_insert(&db, f)
 
 	result, err := db_sync(&db, &f)
-	testing.expect(t, err == .None, "sync should not error")
+	testing.expect_value(t, err, SyncError.None)
 	testing.expect(t, .Restored in result, "should be restored")
 
 	data, read_err := os.read_entire_file_from_path(env_path, context.temp_allocator)
-	testing.expect(t, read_err == nil, "file should exist after restore")
+	testing.expect_value(t, read_err, nil)
 	if read_err == nil {
 		testing.expect_value(t, string(data), "SECRET=value")
 	}
@@ -522,7 +522,7 @@ test_db_sync_moved :: proc(t: ^testing.T) {
 	config_content := "[remote \"origin\"]\n\turl = git@github.com:user/repo.git\n"
 	config_path := fmt.tprintf("%s/config", git_dir)
 	write_err := os.write_entire_file(config_path, transmute([]u8)config_content)
-	testing.expect(t, write_err == nil, "should write .git/config")
+	testing.expect_value(t, write_err, nil)
 
 	db, ok := db_init()
 	testing.expect(t, ok, "failed to create test db")
@@ -540,7 +540,7 @@ test_db_sync_moved :: proc(t: ^testing.T) {
 	testing.expect(t, db_insert(&db, f), "insert should succeed")
 
 	result, err := db_sync(&db, &f)
-	testing.expect(t, err == .None, "sync should not error")
+	testing.expect_value(t, err, SyncError.None)
 	if err != .None do return
 	testing.expect(t, .DirUpdated in result, "should have DirUpdated flag")
 	testing.expect(t, .Restored in result, "should have Restored flag")

findr/findr_test.odin

@@ -21,9 +21,7 @@ test_basic_gitignored :: proc(t: ^testing.T) {
 	create_file(env, "repo/secrets.env")
 	create_file(env, "repo/normal.txt")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/.env", "repo/secrets.env"})
-		"repo/.env", "repo/secrets.env",
-	})
 }
 
 @(test)
@@ -49,9 +47,7 @@ test_negation_pattern :: proc(t: ^testing.T) {
 	create_file(env, "repo/secrets.env")
 	create_file(env, "repo/prod.env")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/.env", "repo/secrets.env"})
-		"repo/.env", "repo/secrets.env",
-	})
 }
 
 @(test)
@@ -67,9 +63,7 @@ test_multiple_repos :: proc(t: ^testing.T) {
 	create_file(env, "repo2/.gitignore", "*.key\n")
 	create_file(env, "repo2/secret.key")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo1/a.env", "repo2/secret.key"})
-		"repo1/a.env", "repo2/secret.key",
-	})
 }
 
 @(test)
@@ -85,9 +79,7 @@ test_nested_repos :: proc(t: ^testing.T) {
 	create_file(env, "parent/child/.gitignore", "*.key\n")
 	create_file(env, "parent/child/api.key")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"parent/top.env", "parent/child/api.key"})
-		"parent/top.env", "parent/child/api.key",
-	})
 }
 
 @(test)
@@ -102,9 +94,7 @@ test_nested_gitignore_read :: proc(t: ^testing.T) {
 	create_file(env, "repo/sub/secret.txt")
 	create_file(env, "repo/sub/.env")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/sub/secret.txt", "repo/sub/.env"})
-		"repo/sub/secret.txt", "repo/sub/.env",
-	})
 }
 
 @(test)
@@ -119,9 +109,7 @@ test_nested_gitignore_negation :: proc(t: ^testing.T) {
 	create_file(env, "repo/sub/important.log")
 	create_file(env, "repo/sub/debug.log")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/sub/debug.log"})
-		"repo/sub/debug.log",
-	})
 }
 
 @(test)
@@ -136,9 +124,7 @@ test_multisegment_pattern :: proc(t: ^testing.T) {
 	create_file(env, "repo/build/other.txt")
 	create_file(env, "repo/output.txt")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/build/output.txt"})
-		"repo/build/output.txt",
-	})
 }
 
 @(test)
@@ -200,7 +186,7 @@ test_multiple_search_dirs :: proc(t: ^testing.T) {
 		stripped := r
 		if strings.has_prefix(stripped, env.temp_dir) {
 			stripped = stripped[len(env.temp_dir):]
-			if len(stripped) > 0 && stripped[0] == '/' {
+			if len(stripped) > 0 && stripped[0] == os.Path_Separator {
 				stripped = stripped[1:]
 			}
 		}
@@ -234,9 +220,7 @@ test_ignored_dir_descended :: proc(t: ^testing.T) {
 	create_file(env, "repo/secrets/api.key")
 
 	// Ignored dir's contents are emitted AND descended into
-	assert_output(t, env, nil, {}, {
+	assert_output(t, env, nil, {}, {"repo/secrets/", "repo/secrets/.env", "repo/secrets/api.key"})
-		"repo/secrets/", "repo/secrets/.env", "repo/secrets/api.key",
-	})
 }
 
 @(test)
@@ -251,10 +235,13 @@ test_nested_ignored_dir :: proc(t: ^testing.T) {
 	create_file(env, "repo/build/output.txt")
 	create_file(env, "repo/build/sub/deep.env")
 
-	assert_output(t, env, nil, {}, {
+	assert_output(
-		"repo/build/", "repo/build/output.txt",
+		t,
-		"repo/build/sub/", "repo/build/sub/deep.env",
+		env,
-	})
+		nil,
+		{},
+		{"repo/build/", "repo/build/output.txt", "repo/build/sub/", "repo/build/sub/deep.env"},
+	)
 }
 
 // ============================================================================
@@ -272,10 +259,7 @@ test_excludes_prune_dirs :: proc(t: ^testing.T) {
 	create_dir(env, "repo/vendor")
 	create_file(env, "repo/vendor/lib.env")
 
-	assert_output(t, env, nil,
+	assert_output(t, env, nil, {excludes = {"vendor"}}, {"repo/.env"})
-		{excludes = {"vendor"}},
-		{"repo/.env"},
-	)
 }
 
 @(test)
@@ -289,10 +273,7 @@ test_pattern_filters_results :: proc(t: ^testing.T) {
 	create_file(env, "repo/secrets.env")
 	create_file(env, "repo/master.key")
 
-	assert_output(t, env, nil,
+	assert_output(t, env, nil, {pattern = "\\.env$"}, {"repo/.env", "repo/secrets.env"})
-		{pattern = "\\.env$"},
-		{"repo/.env", "repo/secrets.env"},
-	)
 }
 
 // ============================================================================
@@ -313,8 +294,6 @@ test_fifo_emitted :: proc(t: ^testing.T) {
 	defer delete(cpath)
 	linux.mknod(cpath, linux.S_IFIFO | linux.Mode{.IRUSR, .IWUSR}, 0)
 
-	assert_output(t, env, nil,
+	assert_output(t, env, nil, {pattern = "\\.fifo$"}, {"repo/test.fifo"})
-		{pattern = "\\.fifo$"},
-		{"repo/test.fifo"},
-	)
 }
+

findr/repos.odin

@@ -26,7 +26,7 @@ find_repos :: proc(roots: []string, results: ^[dynamic]string, thread_count: int
 	pool.threads = make([]^thread.Thread, thread_count)
 
 	for root in roots {
-		root_clone, _ := strings.clone(root)
+		root_clone := strings.clone(root)
 		append(&pool.queue, root_clone)
 		sync.atomic_sema_post(&pool.queue_sema)
 	}
@@ -97,7 +97,7 @@ process_repo_dir :: proc(pool: ^RepoPool, dir_path: string) {
 	defer linux.close(fd)
 
 	if has_git_dir(fd) {
-		cloned, _ := strings.clone(dir_path)
+		cloned := strings.clone(dir_path)
 		sync.mutex_lock(&pool.results_lock)
 		append(pool.results, cloned)
 		sync.mutex_unlock(&pool.results_lock)

findr/test_env.odin

@@ -37,7 +37,7 @@ create_file :: proc(env: TestEnv, path: string, content: string = "") {
 	full := join_path(env.temp_dir, path)
 	defer delete(full)
 
-	dir_end := strings.last_index(full, "/")
+	dir_end := strings.last_index(full, os.Path_Separator_String)
 	if dir_end >= 0 {
 		dir_path := full[:dir_end]
 		os.mkdir_all(dir_path, os.Permissions_Default_Directory)
@@ -105,12 +105,7 @@ assert_output :: proc(
 	}
 }
 
-assert_output_empty :: proc(
+assert_output_empty :: proc(t: ^testing.T, env: TestEnv, args: []string, opts: WalkOptions) {
-	t: ^testing.T,
-	env: TestEnv,
-	args: []string,
-	opts: WalkOptions,
-) {
 	results := collect_results(env, args, opts)
 	defer {
 		for r in results {delete(r)}
@@ -139,10 +134,10 @@ collect_results :: proc(env: TestEnv, args: []string, opts: WalkOptions) -> [dyn
 		r := results[i]
 		if strings.has_prefix(r, env.temp_dir) {
 			stripped := r[len(env.temp_dir):]
-			if len(stripped) > 0 && stripped[0] == '/' {
+			if len(stripped) > 0 && stripped[0] == os.Path_Separator {
 				stripped = stripped[1:]
 			}
-			new_r, _ := strings.clone(stripped)
+			new_r := strings.clone(stripped)
 			delete(r)
 			results[i] = new_r
 		}
@@ -150,3 +145,4 @@ collect_results :: proc(env: TestEnv, args: []string, opts: WalkOptions) -> [dyn
 
 	return results
 }
+

findr/walker.odin

@@ -189,7 +189,7 @@ flush_buf :: proc(ch: chan.Chan([]u8), local: ^[dynamic]u8) {
 }
 
 append_path :: proc(buf: ^[dynamic]u8, parent, name: string, trailing_slash: bool) {
-	need_sep := len(parent) > 0 && parent[len(parent) - 1] != '/'
+	need_sep := len(parent) > 0 && parent[len(parent) - 1] != os.Path_Separator
 	size := len(parent) + len(name) + 1
 	if need_sep do size += 1
 	if trailing_slash do size += 1
@@ -200,9 +200,9 @@ append_path :: proc(buf: ^[dynamic]u8, parent, name: string, trailing_slash: boo
 
 	pos := old_len
 	pos += copy(buf[pos:], parent)
-	if need_sep {buf[pos] = '/'; pos += 1}
+	if need_sep {buf[pos] = os.Path_Separator; pos += 1}
 	pos += copy(buf[pos:], name)
-	if trailing_slash {buf[pos] = '/'; pos += 1}
+	if trailing_slash {buf[pos] = os.Path_Separator; pos += 1}
 	buf[pos] = '\n'
 }
 
@@ -362,6 +362,7 @@ check_chain :: proc(ctx: ^GIContext, entry_rel: string, is_dir: bool) -> bool {
 	return false
 }
 
+// TODO: Is this a copy of something in the core packages?
 relative_to :: proc(entry_rel, base_rel: string) -> string {
 	if len(base_rel) == 0 do return entry_rel
 	prefix_len := len(base_rel)
@@ -442,14 +443,15 @@ load_ignore_patterns :: proc(dir_path: string, in_repo: bool) -> ^Gitignore {
 	return gi
 }
 
+// TODO: Is this a copy of core package behavior?
 join_path :: proc(parent, child: string) -> string {
-	need_sep := len(parent) == 0 || parent[len(parent) - 1] != '/'
+	need_sep := len(parent) == 0 || parent[len(parent) - 1] != os.Path_Separator
 	total := len(parent) + len(child)
 	if need_sep do total += 1
 	buf := make([]u8, total, context.allocator)
 	pos := copy(buf, parent)
 	if need_sep {
-		buf[pos] = '/'
+		buf[pos] = os.Path_Separator
 		pos += 1
 	}
 	copy(buf[pos:], child)

flags.odin

@@ -0,0 +1,134 @@
+package main
+
+import "base:runtime"
+import "core:reflect"
+import "core:strings"
+
+get_subtag :: proc(tag: string, id: string) -> (value: string, ok: bool) {
+	parts := strings.split(tag, ",", context.temp_allocator)
+	for part in parts {
+		trimmed := strings.trim_space(part)
+		if strings.has_prefix(trimmed, id) && len(trimmed) > len(id) && trimmed[len(id)] == '=' {
+			return trimmed[len(id) + 1:], true
+		}
+		if trimmed == id {
+			return "", true
+		}
+	}
+	return "", false
+}
+
+is_bool_type :: proc(field: reflect.Struct_Field) -> bool {
+	base_ti := runtime.type_info_base(field.type)
+	_, is_bool := base_ti.variant.(runtime.Type_Info_Boolean)
+	return is_bool
+}
+
+set_field :: proc(model: rawptr, field: reflect.Struct_Field, value: string) -> bool {
+	ptr := rawptr(uintptr(model) + field.offset)
+	base_ti := runtime.type_info_base(field.type)
+
+	if _, is_bool := base_ti.variant.(runtime.Type_Info_Boolean); is_bool {
+		(cast(^bool)ptr)^ = true
+		return true
+	}
+
+	if _, is_string := base_ti.variant.(runtime.Type_Info_String); is_string {
+		(cast(^string)ptr)^ = value
+		return true
+	}
+
+	if enum_ti, is_enum := base_ti.variant.(runtime.Type_Info_Enum); is_enum {
+		for name, i in enum_ti.names {
+			if strings.equal_fold(value, name) {
+				v := enum_ti.values[i]
+				switch base_ti.size {
+				case 1: (cast(^u8)ptr)^  = cast(u8)v
+				case 2: (cast(^u16)ptr)^ = cast(u16)v
+				case 4: (cast(^u32)ptr)^ = cast(u32)v
+				case 8: (cast(^u64)ptr)^ = cast(u64)v
+				}
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+parse_flags :: proc(model: ^$T, args: []string) -> (overflow: []string) {
+	field_count := reflect.struct_field_count(T)
+	long_map := make(map[string]reflect.Struct_Field, field_count, context.temp_allocator)
+	short_map := make(map[string]reflect.Struct_Field, field_count, context.temp_allocator)
+
+	for i in 0..<field_count {
+		field := reflect.struct_field_at(T, i)
+
+		name, _ := strings.replace(field.name, "_", "-", -1, context.temp_allocator)
+		args_tag := reflect.struct_tag_get(field.tag, "args")
+		if n, ok := get_subtag(args_tag, "name"); ok {
+			name = n
+		}
+		long_map[name] = field
+
+		if s, ok := get_subtag(args_tag, "short"); ok {
+			short_map[s] = field
+		}
+	}
+
+	overflow_dyn := make([dynamic]string, 0, len(args), context.temp_allocator)
+
+	i := 0
+	for i < len(args) {
+		arg := args[i]
+
+		if strings.starts_with(arg, "--") {
+			key := arg[2:]
+			value := ""
+			has_value := false
+
+			if eq_idx := strings.index(key, "="); eq_idx >= 0 {
+				value = key[eq_idx + 1:]
+				key = key[:eq_idx]
+				has_value = true
+			}
+
+			if field, ok := long_map[key]; ok {
+				if is_bool_type(field) {
+					set_field(model, field, "")
+					i += 1
+				} else if has_value {
+					set_field(model, field, value)
+					i += 1
+				} else if i + 1 < len(args) && !strings.starts_with(args[i + 1], "-") {
+					set_field(model, field, args[i + 1])
+					i += 2
+				} else {
+					i += 1
+				}
+			} else {
+				i += 1
+			}
+		} else if strings.starts_with(arg, "-") && len(arg) == 2 {
+			short := arg[1:2]
+			if field, ok := short_map[short]; ok {
+				if is_bool_type(field) {
+					set_field(model, field, "")
+					i += 1
+				} else if i + 1 < len(args) && !strings.starts_with(args[i + 1], "-") {
+					set_field(model, field, args[i + 1])
+					i += 2
+				} else {
+					i += 1
+				}
+			} else {
+				i += 1
+			}
+		} else {
+			append(&overflow_dyn, arg)
+			i += 1
+		}
+	}
+
+	return overflow_dyn[:]
+}

flake.nix

@@ -75,6 +75,8 @@
             ];
 
             buildInputs = [
+              pkgs.git
+
               pkgs.libsodium
               mysqlite
             ];

scan_test.odin

@@ -83,6 +83,6 @@ test_scan_path_empty_dir :: proc(t: ^testing.T) {
 	results, ok := scan_path(base, cfg)
 	defer delete(results)
 	testing.expect(t, ok, "scan_path should succeed")
-	testing.expect(t, len(results) == 0, fmt.tprintf("expected 0 results, got %d", len(results)))
+	testing.expect_value(t, len(results), 0)
 }
 

sqlite/sqlite.odin

@@ -17,6 +17,12 @@ DESERIALIZE_FLAGS :: bit_set[DESERIALIZE_FLAG]
 DESERIALIZE_FLAG :: enum u32 {
 	FREEONCLOSE = 1,
 	RESIZEABLE  = 2,
+	READONLY    = 4,
+}
+
+SERIALIZE_FLAGS :: bit_set[SERIALIZE_FLAG]
+SERIALIZE_FLAG :: enum u32 {
+	NOCOPY = 1,
 }
 
 foreign lib {
@@ -43,7 +49,7 @@ foreign lib {
 	@(link_name = "sqlite3_changes")
 	changes :: proc(db: Db) -> c.int ---
 	@(link_name = "sqlite3_serialize")
-	serialize :: proc(db: Db, zSchema: cstring, piSize: ^i64, mFlags: u32) -> [^]u8 ---
+	serialize :: proc(db: Db, zSchema: cstring, piSize: ^i64, mFlags: SERIALIZE_FLAGS) -> [^]u8 ---
 	@(link_name = "sqlite3_deserialize")
 	deserialize :: proc(db: Db, zSchema: cstring, pData: [^]u8, szDb: i64, szBuf: i64, mFlags: DESERIALIZE_FLAGS) -> c.int ---
 	@(link_name = "sqlite3_malloc64")

ssh_test.odin

@@ -46,15 +46,7 @@ test_private_key_pub_matches_public_key :: proc(t: ^testing.T) {
 	kp, priv_ok := parse_ssh_private_key(TEST_KEY_DIR + "/test_ed25519")
 	testing.expect(t, priv_ok, "expected private key to parse")
 
-	testing.expect(
+	testing.expect_value(t, pub_from_pub, kp.Public)
-		t,
-		pub_from_pub == kp.Public,
-		fmt.tprintf(
-			"public key mismatch:\n  from .pub: %v\n  from priv: %v",
-			pub_from_pub,
-			kp.Public,
-		),
-	)
 }
 
 @(test)
@@ -64,12 +56,11 @@ test_read_wire_string :: proc(t: ^testing.T) {
 
 	s, ok := read_wire_string(data, &offset)
 	testing.expect(t, ok, "expected read_wire_string to succeed")
-	testing.expect(t, s == "hello", fmt.tprintf("expected 'hello', got %q", s))
+	testing.expect_value(t, s, "hello")
-	testing.expect(t, offset == 9, fmt.tprintf("expected offset 9, got %d", offset))
+	testing.expect_value(t, offset, 9)
 
 	s2, ok2 := read_wire_string(data, &offset)
 	testing.expect(t, ok2, "expected second read to succeed")
-	testing.expect(t, s2 == "", "expected empty string")
+	testing.expect_value(t, s2, "")
 }
 
-

table.odin

@@ -3,7 +3,6 @@ package main
 import "core:fmt"
 import "core:io"
 import "core:text/table"
-import "core:unicode/utf8"
 
 decorations := table.Decorations {
 	"┌",
@@ -19,20 +18,17 @@ decorations := table.Decorations {
 	"─",
 }
 
-// TODO: Optimize ansi_aware_width
+ansi_aware_width :: proc(str: string) -> int #no_bounds_check {
-ansi_aware_width :: proc(str: string) -> int {
+	width := 0
-	buf: [4096]byte
+	for i := 0; i < len(str); {
-	pos := 0
-	i := 0
-	for i < len(str) {
 		if i + 1 < len(str) && str[i] == 0x1b && str[i + 1] == '[' {
 			i += 2
 			for i < len(str) {c := str[i]; i += 1; if c >= 0x40 && c <= 0x7E {break}}
 		} else {
-			buf[pos] = str[i]; pos += 1; i += 1
+			width += 1
+			i += 1
 		}
 	}
-	_, _, width := utf8.grapheme_count(string(buf[:pos]))
 	return width
 }
 

table_test.odin

@@ -21,9 +21,9 @@ test_ansi_aware_width_with_color_codes :: proc(t: ^testing.T) {
 }
 
 @(test)
-test_ansi_aware_width_unicode :: proc(t: ^testing.T) {
+test_ansi_aware_width_multibyte :: proc(t: ^testing.T) {
-	testing.expect_value(t, ansi_aware_width("\u2713 Available"), 11)
+	testing.expect_value(t, ansi_aware_width("\u2713 Available"), 13)
-	testing.expect_value(t, ansi_aware_width("\u2717 Missing"), 9)
+	testing.expect_value(t, ansi_aware_width("\u2717 Missing"), 11)
 }
 
 @(test)