tiny.smg.cli.validation

1pub fn validateQueryNameCommand(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, allowed: []const []const u8, formats: []const []const u8) !bool {2    if (try value.rejectMissingOptionValues(allocator, args, allowed)) return true;3    if (try unexpected.rejectUnexpectedOptionsPlain(allocator, command, signature, args, allowed)) return true;4    if (try value.rejectInvalidChoiceOption(allocator, command, signature, args, "--format", formats)) return true;5    if (list.containsString(allowed, "--depth")) {6        if (try value.rejectInvalidIntegerOption(allocator, command, signature, args, "--depth")) return true;7    }8    if (list.containsString(allowed, "--limit")) {9        if (try value.rejectInvalidIntegerOption(allocator, command, signature, args, "--limit")) return true;10    }11    const pos = try options.positional(allocator, args);12    if (pos.len == 0) {13        try output.writeClickUsageError(allocator, command, signature, "Missing argument 'NAME'.");14        return true;15    }16    if (pos.len > 1) {17        try output.writeClickUsageError(allocator, command, signature, try unexpected.unexpectedArgumentMessage(allocator, pos[1..]));18        return true;19    }20    return false;21}

1pub fn noSuchOptionMessage(allocator: std.mem.Allocator, option: []const u8, candidates: []const []const u8) ![]const u8 {2    const suggestion = nearestOption(option, candidates);3    if (suggestion) |candidate| return try std.fmt.allocPrint(allocator, "No such option: {s} Did you mean {s}?", .{ option, candidate });4    return try std.fmt.allocPrint(allocator, "No such option: {s}", .{option});5}

1pub fn rejectUnexpectedOptions(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, allowed: []const []const u8) !bool {2    for (args) |arg| {3        if (!std.mem.startsWith(u8, arg, "--")) continue;4        const name = options.optionName(arg);5        if (list.containsString(allowed, name)) continue;6        try output.writeClickUsageError(allocator, command, signature, try noSuchOptionMessage(allocator, name, allowed));7        return true;8    }9    return false;10}

1pub fn rejectUnexpectedOptionsPlain(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, allowed: []const []const u8) !bool {2    for (args) |arg| {3        if (!std.mem.startsWith(u8, arg, "--")) continue;4        const name = options.optionName(arg);5        if (list.containsString(allowed, name)) continue;6        try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "No such option: {s}", .{name}));7        return true;8    }9    return false;10}

1pub fn rejectUnexpectedScanOptions(allocator: std.mem.Allocator, args: []const []const u8) !bool {2    const allowed = [_][]const u8{3        "--clean",4        "--changed",5        "--since",6        "--exclude",7        "--format",8        "--full",9        options.max_source_file_bytes_option,10        options.max_fragment_bytes_option,11        options.max_git_file_list_bytes_option,12        options.wal_recovery_limit_bytes_option,13    };14    for (args) |arg| {15        if (!std.mem.startsWith(u8, arg, "--")) continue;16        const name = options.optionName(arg);17        if (list.containsString(&allowed, name)) continue;18        const message = if (std.mem.eql(u8, name, "--json"))19            try std.fmt.allocPrint(allocator, "No such option: {s} (Possible options: --since)", .{name})20        else21            try noSuchOptionMessage(allocator, name, &allowed);22        try output.writeClickUsageError(allocator, "scan", "[OPTIONS] [PATHS]...", message);23        return true;24    }25    return false;26}

1pub fn unexpectedArgumentMessage(allocator: std.mem.Allocator, values: []const []const u8) ![]const u8 {2    if (values.len == 1) return try std.fmt.allocPrint(allocator, "Got unexpected extra argument ({s})", .{values[0]});3    return try std.fmt.allocPrint(allocator, "Got unexpected extra arguments ({s})", .{try list.joinStrings(allocator, values, " ")});4}

1pub fn choiceList(allocator: std.mem.Allocator, choices: []const []const u8) ![]const u8 {2    var out: std.Io.Writer.Allocating = .init(allocator);3    for (choices, 0..) |choice, index| {4        if (index != 0) try out.writer.writeAll(", ");5        try out.writer.print("'{s}'", .{choice});6    }7    return out.written();8}

1pub fn configuredLimitsOrReject(2    allocator: std.mem.Allocator,3    command: []const u8,4    signature: []const u8,5    args: []const []const u8,6    base: smg.Limits,7) !?smg.Limits {8    switch (options.configuredLimits(args, base)) {9        .limits => |limits| return limits,10        .invalid => |failure| {11            const message = switch (failure.reason) {12                .invalid_size => try std.fmt.allocPrint(13                    allocator,14                    "Invalid value for '{s}': '{s}'. Use a positive byte size such as 32MiB.",15                    .{ failure.option, failure.value },16                ),17                .capacity_overflow => try std.fmt.allocPrint(18                    allocator,19                    "Invalid value for '{s}': '{s}' exceeds this platform's capacity.",20                    .{ failure.option, failure.value },21                ),22                .fragment_header => try std.fmt.allocPrint(23                    allocator,24                    "Invalid value for '{s}': '{s}' cannot hold the fragment header.",25                    .{ failure.option, failure.value },26                ),27            };28            try output.writeClickUsageError(allocator, command, signature, message);29            return null;30        },31    }32}

1pub fn optionWithForbiddenValue(args: []const []const u8, forbidden: []const []const u8) ?[]const u8 {2    for (args) |arg| {3        const name = options.optionName(arg);4        if (!list.containsString(forbidden, name)) continue;5        if (options.inlineOptionValue(arg) != null) return name;6    }7    return null;8}

1pub fn rejectForbiddenOptionValues(allocator: std.mem.Allocator, args: []const []const u8, forbidden: []const []const u8) !bool {2    if (optionWithForbiddenValue(args, forbidden)) |option| {3        try output.writeClickBoxError(allocator, try std.fmt.allocPrint(allocator, "Option '{s}' does not take a value.", .{option}));4        return true;5    }6    return false;7}

1pub fn rejectInvalidChoiceOption(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, option: []const u8, choices: []const []const u8) !bool {2    const raw = options.flagValue(args, option) orelse return false;3    if (list.containsString(choices, raw)) return false;4    try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '{s}': '{s}' is not one of {s}.", .{ option, raw, try choiceList(allocator, choices) }));5    return true;6}

1pub fn rejectInvalidFloatOption(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, option: []const u8) !bool {2    const raw = options.flagValue(args, option) orelse return false;3    _ = std.fmt.parseFloat(f64, raw) catch {4        try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '{s}': '{s}' is not a valid float.", .{ option, raw }));5        return true;6    };7    return false;8}

1pub fn rejectInvalidIntegerOption(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, option: []const u8) !bool {2    const raw = options.flagValue(args, option) orelse return false;3    _ = std.fmt.parseInt(i64, raw, 10) catch {4        try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '{s}': '{s}' is not a valid integer.", .{ option, raw }));5        return true;6    };7    return false;8}

1pub fn rejectInvalidIntegerRangeOption(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8, option: []const u8, minimum: i64, maximum: i64) !bool {2    const raw = options.flagValue(args, option) orelse return false;3    const value = std.fmt.parseInt(i64, raw, 10) catch {4        try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '{s}': '{s}' is not a valid integer.", .{ option, raw }));5        return true;6    };7    if (value >= minimum and value <= maximum) return false;8    try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '{s}': {d} is not in the range {d}<=x<={d}.", .{ option, value, minimum, maximum }));9    return true;10}

1pub fn rejectInvalidLine(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, args: []const []const u8) !bool {2    if (options.flagValue(args, "--line")) |raw| {3        _ = std.fmt.parseInt(i64, raw, 10) catch {4            try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '--line': '{s}' is not a valid integer.", .{raw}));5            return true;6        };7    }8    return false;9}

1pub fn rejectInvalidMeta(allocator: std.mem.Allocator, args: []const []const u8) !bool {2    var i: usize = 0;3    while (i + 1 < args.len) : (i += 1) {4        if (!std.mem.eql(u8, args[i], "--meta")) continue;5        const raw = args[i + 1];6        if (std.mem.indexOfScalar(u8, raw, '=') == null) {7            try output.writeErrFmt(allocator, "Error: --meta must be KEY=VALUE, got '{s}'\n", .{raw});8            return true;9        }10        i += 1;11    }12    return false;13}

1pub fn rejectMissingOptionValues(allocator: std.mem.Allocator, args: []const []const u8, allowed: []const []const u8) !bool {2    var i: usize = 0;3    while (i < args.len) : (i += 1) {4        const arg = args[i];5        if (!list.containsString(allowed, options.optionName(arg))) continue;6        if (options.inlineOptionValue(arg) != null) continue;7        if (i + 1 == args.len or std.mem.startsWith(u8, args[i + 1], "--")) {8            try output.writeClickBoxError(allocator, try std.fmt.allocPrint(allocator, "Option '{s}' requires an argument.", .{options.optionName(arg)}));9            return true;10        }11        i += 1;12    }13    return false;14}

1pub fn rejectMissingPaths(allocator: std.mem.Allocator, command: []const u8, signature: []const u8, paths: []const []const u8) !bool {2    for (paths) |path| {3        if (sys.fs.exists(path)) continue;4        try output.writeClickUsageError(allocator, command, signature, try std.fmt.allocPrint(allocator, "Invalid value for '[PATHS]...': Path '{s}' does not exist.", .{path}));5        return true;6    }7    return false;8}

1pub const validation = @import("validation/root.zig");

1const query = @import("query.zig");2const unexpected = @import("unexpected.zig");3const value = @import("value.zig");45pub const choiceList = value.choiceList;6pub const configuredLimitsOrReject = value.configuredLimitsOrReject;7pub const noSuchOptionMessage = unexpected.noSuchOptionMessage;8pub const optionWithForbiddenValue = value.optionWithForbiddenValue;9pub const rejectForbiddenOptionValues = value.rejectForbiddenOptionValues;10pub const rejectInvalidChoiceOption = value.rejectInvalidChoiceOption;11pub const rejectInvalidFloatOption = value.rejectInvalidFloatOption;12pub const rejectInvalidIntegerOption = value.rejectInvalidIntegerOption;13pub const rejectInvalidIntegerRangeOption = value.rejectInvalidIntegerRangeOption;14pub const rejectInvalidLine = value.rejectInvalidLine;15pub const rejectInvalidMeta = value.rejectInvalidMeta;16pub const rejectMissingOptionValues = value.rejectMissingOptionValues;17pub const rejectMissingPaths = value.rejectMissingPaths;18pub const rejectUnexpectedOptions = unexpected.rejectUnexpectedOptions;19pub const rejectUnexpectedOptionsPlain = unexpected.rejectUnexpectedOptionsPlain;20pub const rejectUnexpectedScanOptions = unexpected.rejectUnexpectedScanOptions;21pub const unexpectedArgumentMessage = unexpected.unexpectedArgumentMessage;22pub const validateQueryNameCommand = query.validateQueryNameCommand;