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 version: bool = false,18 dry: bool = false,19 check: bool = false,20 no_apply: bool = false,21 all: bool = false,22 json: bool = false,23 last: u32 = 50,24};2526pub fn main(startup: std.process.Init) !void {27 const arena = startup.arena.allocator();28 const gpa = startup.gpa;29 const io = startup.io;3031 32 var stdout_buf: [16384]u8 = undefined;33 var stdout_fw: Io.File.Writer = .init(.stdout(), io, &stdout_buf);34 output.init(&stdout_fw.interface, io, startup.environ_map, true);35 defer output.flush();3637 const argv = try startup.minimal.args.toSlice(arena);38 const args = try parseArgs(arena, argv);3940 if (args.version) {41 output.version();42 return;43 }4445 46 if (args.command.len == 0 or std.mem.eql(u8, args.command, "help")) {47 output.help();48 return;49 }5051 52 if (std.mem.eql(u8, args.command, "setup") or std.mem.eql(u8, args.command, "update")) {53 const dummy_machine: types.Machine = .{ .name = "local", .local = true };54 const dummy_cfg: types.NinaConfig = .{};55 const pre_ctx = commands.Ctx{56 .gpa = gpa,57 .io = io,58 .environ = startup.environ_map,59 .machine = dummy_machine,60 .cfg = dummy_cfg,61 .args = args.rest,62 .sub = args.sub,63 .dry = args.dry,64 .check = args.check,65 .no_apply = args.no_apply,66 .all = args.all,67 .last = args.last,68 .json = args.json,69 };70 if (std.mem.eql(u8, args.command, "setup")) {71 commands.setup(gpa, io, startup.environ_map) catch |err| {72 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);73 const detail = errors.error_info.getDetail();74 const suggestion = errors.error_info.getSuggestion();75 output.printError(msg, detail, suggestion);76 output.flush();77 std.process.exit(1);78 };79 } else {80 dispatch(pre_ctx, args.command) catch |err| {81 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);82 const detail = errors.error_info.getDetail();83 const suggestion = errors.error_info.getSuggestion();84 output.printError(msg, detail, suggestion);85 output.flush();86 std.process.exit(1);87 };88 }89 return;90 }9192 93 const cfg = config.load(arena, io, startup.environ_map) catch |err| {94 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);95 const detail = errors.error_info.getDetail();96 const suggestion = errors.error_info.getSuggestion();97 output.printError(msg, detail, suggestion);98 output.flush();99 std.process.exit(1);100 };101102 output.setTeach(cfg.teach);103104 const machine = config.resolveMachine(&cfg, args.machine) catch |err| {105 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);106 const detail = errors.error_info.getDetail();107 const suggestion = errors.error_info.getSuggestion();108 output.printError(msg, detail, suggestion);109 output.flush();110 std.process.exit(1);111 };112113 const ctx = commands.Ctx{114 .gpa = gpa,115 .io = io,116 .environ = startup.environ_map,117 .machine = machine,118 .cfg = cfg,119 .args = args.rest,120 .sub = args.sub,121 .dry = args.dry,122 .check = args.check,123 .no_apply = args.no_apply,124 .all = args.all,125 .last = args.last,126 .json = args.json,127 };128129 dispatch(ctx, args.command) catch |err| {130 const msg = errors.error_info.getMessage() orelse errors.staticMessage(err);131 const detail = errors.error_info.getDetail();132 const suggestion = errors.error_info.getSuggestion();133 output.printError(msg, detail, suggestion);134 output.flush();135 std.process.exit(1);136 };137}138139fn dispatch(ctx: commands.Ctx, cmd: []const u8) !void {140 if (std.mem.eql(u8, cmd, "apply")) return commands.apply(ctx);141 if (std.mem.eql(u8, cmd, "check")) return commands.check(ctx);142 if (std.mem.eql(u8, cmd, "back")) return commands.back(ctx);143 if (std.mem.eql(u8, cmd, "go")) return commands.go(ctx);144 if (std.mem.eql(u8, cmd, "history")) return commands.history(ctx);145 if (std.mem.eql(u8, cmd, "gen")) return commands.genCmd(ctx);146 if (std.mem.eql(u8, cmd, "clean")) return commands.clean(ctx);147 if (std.mem.eql(u8, cmd, "status")) return commands.statusCmd(ctx);148 if (std.mem.eql(u8, cmd, "diff")) return commands.diff(ctx);149 if (std.mem.eql(u8, cmd, "doctor")) return commands.doctor(ctx);150 if (std.mem.eql(u8, cmd, "update")) return commands.update(ctx);151 if (std.mem.eql(u8, cmd, "upgrade")) return commands.upgrade(ctx);152 if (std.mem.eql(u8, cmd, "log")) return commands.log(ctx);153 if (std.mem.eql(u8, cmd, "edit")) return commands.edit(ctx);154 if (std.mem.eql(u8, cmd, "fmt")) return commands.fmt(ctx);155 if (std.mem.eql(u8, cmd, "repl")) return commands.repl(ctx);156 if (std.mem.eql(u8, cmd, "develop")) return commands.develop(ctx);157 if (std.mem.eql(u8, cmd, "info")) return commands.info(ctx);158 if (std.mem.eql(u8, cmd, "boot")) return commands.boot(ctx);159 if (std.mem.eql(u8, cmd, "search")) return commands.searchCmd(ctx);160 if (std.mem.eql(u8, cmd, "option")) return commands.optionCmd(ctx);161 if (std.mem.eql(u8, cmd, "install")) return commands.install(ctx);162 if (std.mem.eql(u8, cmd, "remove")) return commands.remove(ctx);163 if (std.mem.eql(u8, cmd, "list")) return commands.list(ctx);164 if (std.mem.eql(u8, cmd, "try")) return commands.tryCmd(ctx);165 if (std.mem.eql(u8, cmd, "service")) return commands.service(ctx);166 if (std.mem.eql(u8, cmd, "flake")) return commands.flake(ctx);167 if (std.mem.eql(u8, cmd, "store")) return commands.store(ctx);168 if (std.mem.eql(u8, cmd, "channel")) return commands.channel(ctx);169 if (std.mem.eql(u8, cmd, "profile")) return commands.profile(ctx);170 if (std.mem.eql(u8, cmd, "pkg")) return commands.pkg(ctx);171 if (std.mem.eql(u8, cmd, "pin")) return commands.pin(ctx);172 if (std.mem.eql(u8, cmd, "unpin")) return commands.unpin(ctx);173 if (std.mem.eql(u8, cmd, "hash")) return commands.hash(ctx);174 if (std.mem.eql(u8, cmd, "fetch")) return commands.fetch(ctx);175 if (std.mem.eql(u8, cmd, "build")) return commands.build(ctx);176 if (std.mem.eql(u8, cmd, "run")) return commands.runCmd(ctx);177 if (std.mem.eql(u8, cmd, "goodbye")) return commands.goodbye(ctx);178 if (std.mem.eql(u8, cmd, "hello")) return commands.hello(ctx);179 if (std.mem.eql(u8, cmd, "help")) { output.help(); return; }180181 errors.error_info.setMessage("unknown command: {s}", .{cmd});182 errors.error_info.setSuggestion("nina help", .{});183 return error.Internal;184}185186fn parseArgs(arena: std.mem.Allocator, argv: []const [:0]const u8) !Args {187 var result = Args{};188 var rest: std.ArrayList([]const u8) = .empty;189 var i: usize = 1; 190191 192 if (i < argv.len and argv[i][0] != '-') {193 result.command = argv[i];194 i += 1;195 }196197 198 if (i < argv.len and argv[i][0] != '-') {199 const multi_word = isMultiWord(result.command);200 if (multi_word) {201 result.sub = argv[i];202 i += 1;203 }204 }205206 while (i < argv.len) : (i += 1) {207 const a = argv[i];208 if (std.mem.eql(u8, a, "--on") or std.mem.eql(u8, a, "-on")) {209 i += 1;210 if (i < argv.len) result.machine = argv[i];211 } else if (std.mem.eql(u8, a, "--dry")) {212 result.dry = true;213 } else if (std.mem.eql(u8, a, "--check")) {214 result.check = true;215 } else if (std.mem.eql(u8, a, "--version")) {216 result.version = true;217 } else if (std.mem.eql(u8, a, "--no-apply")) {218 result.no_apply = true;219 } else if (std.mem.eql(u8, a, "--all")) {220 result.all = true;221 } else if (std.mem.eql(u8, a, "--json")) {222 result.json = true;223 } else if (std.mem.eql(u8, a, "--last")) {224 i += 1;225 if (i < argv.len) result.last = std.fmt.parseInt(u32, argv[i], 10) catch 50;226 } else if (std.mem.eql(u8, a, "-f")) {227 228 try rest.append(arena, "-f");229 } else if (a.len > 0 and a[0] != '-') {230 try rest.append(arena, a);231 }232 233 }234235 result.rest = try rest.toOwnedSlice(arena);236 return result;237}238239fn isMultiWord(cmd: []const u8) bool {240 const multi = [_][]const u8{ "service", "flake", "store", "channel", "profile", "pkg", "gen", "develop", "edit" };241 for (multi) |m| {242 if (std.mem.eql(u8, cmd, m)) return true;243 }244 return false;245}246247test "parse args basic" {248 const gpa = std.testing.allocator;249 const argv = [_][:0]const u8{ "nina", "apply", "--dry" };250 const args = try parseArgs(gpa, &argv);251 defer gpa.free(args.rest);252 try std.testing.expectEqualStrings("apply", args.command);253 try std.testing.expect(args.dry);254}255256test "parse args with machine" {257 const gpa = std.testing.allocator;258 const argv = [_][:0]const u8{ "nina", "status", "--on", "build-server" };259 const args = try parseArgs(gpa, &argv);260 defer gpa.free(args.rest);261 try std.testing.expectEqualStrings("status", args.command);262 try std.testing.expectEqualStrings("build-server", args.machine.?);263}264265test "parse subcommand" {266 const gpa = std.testing.allocator;267 const argv = [_][:0]const u8{ "nina", "service", "list" };268 const args = try parseArgs(gpa, &argv);269 defer gpa.free(args.rest);270 try std.testing.expectEqualStrings("service", args.command);271 try std.testing.expectEqualStrings("list", args.sub);272}273274test "parse version flag" {275 const gpa = std.testing.allocator;276 const argv = [_][:0]const u8{ "nina", "--version" };277 const args = try parseArgs(gpa, &argv);278 defer gpa.free(args.rest);279 try std.testing.expect(args.version);280}