123const std = @import("std");4const Io = std.Io;56const types = @import("types.zig");7const errors = @import("errors.zig");8const config = @import("config.zig");9const commands = @import("commands.zig");10const output = @import("output.zig");1112const Args = struct {13 command: []const u8 = "",14 sub: []const u8 = "",15 rest: []const []const u8 = &.{},16 machine: ?[]const u8 = null,17 dry: bool = false,18 check: bool = false,19 no_apply: bool = false,20 all: bool = false,21 json: bool = false,22 last: u32 = 50,23};2425pub fn main(startup: std.process.Init) !void {26 const arena = startup.arena.allocator();27 const gpa = startup.gpa;28 const io = startup.io;2930 31 var stdout_buf: [16384]u8 = undefined;32 var stdout_fw: Io.File.Writer = .init(.stdout(), io, &stdout_buf);33 output.init(&stdout_fw.interface, startup.environ_map, true);34 defer output.flush();3536 const argv = try startup.minimal.args.toSlice(arena);37 const args = try parseArgs(arena, argv);3839 40 if (args.command.len == 0 or std.mem.eql(u8, args.command, "help")) {41 output.help();42 return;43 }4445 46 if (std.mem.eql(u8, args.command, "setup") or std.mem.eql(u8, args.command, "update")) {47 const dummy_machine: types.Machine = .{ .name = "local", .local = true };48 const dummy_cfg: types.NinaConfig = .{};49 const pre_ctx = commands.Ctx{50 .gpa = gpa,51 .io = io,52 .environ = startup.environ_map,53 .machine = dummy_machine,54 .cfg = dummy_cfg,55 .args = args.rest,56 .sub = args.sub,57 .dry = args.dry,58 .check = args.check,59 .no_apply = args.no_apply,60 .all = args.all,61 .last = args.last,62 .json = args.json,63 };64 if (std.mem.eql(u8, args.command, "setup")) {65 commands.setup(gpa, io, startup.environ_map) catch |err| {66 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);67 const detail = errors.error_info.getDetail();68 const suggestion = errors.error_info.getSuggestion();69 output.printError(msg, detail, suggestion);70 output.flush();71 std.process.exit(1);72 };73 } else {74 dispatch(pre_ctx, args.command) catch |err| {75 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);76 const detail = errors.error_info.getDetail();77 const suggestion = errors.error_info.getSuggestion();78 output.printError(msg, detail, suggestion);79 output.flush();80 std.process.exit(1);81 };82 }83 return;84 }8586 87 const cfg = config.load(arena, io, startup.environ_map) catch |err| {88 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);89 const detail = errors.error_info.getDetail();90 const suggestion = errors.error_info.getSuggestion();91 output.printError(msg, detail, suggestion);92 output.flush();93 std.process.exit(1);94 };9596 output.setTeach(cfg.teach);9798 const machine = config.resolveMachine(&cfg, args.machine) catch |err| {99 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);100 const detail = errors.error_info.getDetail();101 const suggestion = errors.error_info.getSuggestion();102 output.printError(msg, detail, suggestion);103 output.flush();104 std.process.exit(1);105 };106107 const ctx = commands.Ctx{108 .gpa = gpa,109 .io = io,110 .environ = startup.environ_map,111 .machine = machine,112 .cfg = cfg,113 .args = args.rest,114 .sub = args.sub,115 .dry = args.dry,116 .check = args.check,117 .no_apply = args.no_apply,118 .all = args.all,119 .last = args.last,120 .json = args.json,121 };122123 dispatch(ctx, args.command) catch |err| {124 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);125 const detail = errors.error_info.getDetail();126 const suggestion = errors.error_info.getSuggestion();127 output.printError(msg, detail, suggestion);128 output.flush();129 std.process.exit(1);130 };131}132133fn dispatch(ctx: commands.Ctx, cmd: []const u8) !void {134 if (std.mem.eql(u8, cmd, "apply")) return commands.apply(ctx);135 if (std.mem.eql(u8, cmd, "check")) return commands.check(ctx);136 if (std.mem.eql(u8, cmd, "back")) return commands.back(ctx);137 if (std.mem.eql(u8, cmd, "go")) return commands.go(ctx);138 if (std.mem.eql(u8, cmd, "history")) return commands.history(ctx);139 if (std.mem.eql(u8, cmd, "gen")) return commands.genCmd(ctx);140 if (std.mem.eql(u8, cmd, "clean")) return commands.clean(ctx);141 if (std.mem.eql(u8, cmd, "status")) return commands.statusCmd(ctx);142 if (std.mem.eql(u8, cmd, "diff")) return commands.diff(ctx);143 if (std.mem.eql(u8, cmd, "doctor")) return commands.doctor(ctx);144 if (std.mem.eql(u8, cmd, "update")) return commands.update(ctx);145 if (std.mem.eql(u8, cmd, "upgrade")) return commands.upgrade(ctx);146 if (std.mem.eql(u8, cmd, "log")) return commands.log(ctx);147 if (std.mem.eql(u8, cmd, "edit")) return commands.edit(ctx);148 if (std.mem.eql(u8, cmd, "fmt")) return commands.fmt(ctx);149 if (std.mem.eql(u8, cmd, "repl")) return commands.repl(ctx);150 if (std.mem.eql(u8, cmd, "develop")) return commands.develop(ctx);151 if (std.mem.eql(u8, cmd, "info")) return commands.info(ctx);152 if (std.mem.eql(u8, cmd, "boot")) return commands.boot(ctx);153 if (std.mem.eql(u8, cmd, "search")) return commands.searchCmd(ctx);154 if (std.mem.eql(u8, cmd, "option")) return commands.optionCmd(ctx);155 if (std.mem.eql(u8, cmd, "install")) return commands.install(ctx);156 if (std.mem.eql(u8, cmd, "remove")) return commands.remove(ctx);157 if (std.mem.eql(u8, cmd, "list")) return commands.list(ctx);158 if (std.mem.eql(u8, cmd, "try")) return commands.tryCmd(ctx);159 if (std.mem.eql(u8, cmd, "service")) return commands.service(ctx);160 if (std.mem.eql(u8, cmd, "flake")) return commands.flake(ctx);161 if (std.mem.eql(u8, cmd, "store")) return commands.store(ctx);162 if (std.mem.eql(u8, cmd, "channel")) return commands.channel(ctx);163 if (std.mem.eql(u8, cmd, "profile")) return commands.profile(ctx);164 if (std.mem.eql(u8, cmd, "pkg")) return commands.pkg(ctx);165 if (std.mem.eql(u8, cmd, "pin")) return commands.pin(ctx);166 if (std.mem.eql(u8, cmd, "unpin")) return commands.unpin(ctx);167 if (std.mem.eql(u8, cmd, "hash")) return commands.hash(ctx);168 if (std.mem.eql(u8, cmd, "fetch")) return commands.fetch(ctx);169 if (std.mem.eql(u8, cmd, "build")) return commands.build(ctx);170 if (std.mem.eql(u8, cmd, "run")) return commands.runCmd(ctx);171 if (std.mem.eql(u8, cmd, "hello")) return commands.hello(ctx);172 if (std.mem.eql(u8, cmd, "help")) { output.help(); return; }173174 errors.error_info.setMessage("unknown command: {s}", .{cmd});175 errors.error_info.setSuggestion("nina help", .{});176 return error.Internal;177}178179fn parseArgs(arena: std.mem.Allocator, argv: []const [:0]const u8) !Args {180 var result = Args{};181 var rest: std.ArrayList([]const u8) = .empty;182 var i: usize = 1; 183184 185 if (i < argv.len and argv[i][0] != '-') {186 result.command = argv[i];187 i += 1;188 }189190 191 if (i < argv.len and argv[i][0] != '-') {192 const multi_word = isMultiWord(result.command);193 if (multi_word) {194 result.sub = argv[i];195 i += 1;196 }197 }198199 while (i < argv.len) : (i += 1) {200 const a = argv[i];201 if (std.mem.eql(u8, a, "--on") or std.mem.eql(u8, a, "-on")) {202 i += 1;203 if (i < argv.len) result.machine = argv[i];204 } else if (std.mem.eql(u8, a, "--dry")) {205 result.dry = true;206 } else if (std.mem.eql(u8, a, "--check")) {207 result.check = true;208 } else if (std.mem.eql(u8, a, "--no-apply")) {209 result.no_apply = true;210 } else if (std.mem.eql(u8, a, "--all")) {211 result.all = true;212 } else if (std.mem.eql(u8, a, "--json")) {213 result.json = true;214 } else if (std.mem.eql(u8, a, "--last")) {215 i += 1;216 if (i < argv.len) result.last = std.fmt.parseInt(u32, argv[i], 10) catch 50;217 } else if (std.mem.eql(u8, a, "-f")) {218 219 try rest.append(arena, "-f");220 } else if (a.len > 0 and a[0] != '-') {221 try rest.append(arena, a);222 }223 224 }225226 result.rest = try rest.toOwnedSlice(arena);227 return result;228}229230fn isMultiWord(cmd: []const u8) bool {231 const multi = [_][]const u8{ "service", "flake", "store", "channel", "profile", "pkg", "gen", "develop", "edit" };232 for (multi) |m| {233 if (std.mem.eql(u8, cmd, m)) return true;234 }235 return false;236}237238test "parse args basic" {239 const gpa = std.testing.allocator;240 const argv = [_][:0]const u8{ "nina", "apply", "--dry" };241 const args = try parseArgs(gpa, &argv);242 defer gpa.free(args.rest);243 try std.testing.expectEqualStrings("apply", args.command);244 try std.testing.expect(args.dry);245}246247test "parse args with machine" {248 const gpa = std.testing.allocator;249 const argv = [_][:0]const u8{ "nina", "status", "--on", "build-server" };250 const args = try parseArgs(gpa, &argv);251 defer gpa.free(args.rest);252 try std.testing.expectEqualStrings("status", args.command);253 try std.testing.expectEqualStrings("build-server", args.machine.?);254}255256test "parse subcommand" {257 const gpa = std.testing.allocator;258 const argv = [_][:0]const u8{ "nina", "service", "list" };259 const args = try parseArgs(gpa, &argv);260 defer gpa.free(args.rest);261 try std.testing.expectEqualStrings("service", args.command);262 try std.testing.expectEqualStrings("list", args.sub);263}