@@ -0,0 +1,197 @@
1+const std = @import("std");
2+const Io = std.Io;
3+const Value = std.json.Value;
4+
5+const skill =
6+ \\dot-compose renders dotfile templates with machine-specific values.
7+ \\
8+ \\Layout:
9+ \\ tmpl/ mirrors $HOME. tmpl/.config/nvim/init.lua renders to ~/.config/nvim/init.lua
10+ \\ values/ one JSON file per machine/profile, e.g. values/mac.json
11+ \\
12+ \\Template syntax:
13+ \\ {{ key }} insert a value from the JSON file
14+ \\ {{ nested.key }} walk into nested JSON objects with dots
15+ \\ Everything else is copied verbatim.
16+ \\
17+ \\Values may be strings, numbers or booleans. null renders as empty text.
18+ \\
19+ \\Your task, given an existing dotfiles tree:
20+ \\ 1. Move each config file to tmpl/<its path relative to $HOME>.
21+ \\ 2. Replace every machine-specific literal with a {{ }} slot.
22+ \\ Machine-specific means it differs across machines: fonts, themes,
23+ \\ usernames, hosts, paths, secrets, tools present on only some machines.
24+ \\ 3. Collect those literals into values/<profile>.json. Group related keys
25+ \\ in nested objects, e.g. {"font": {"family": "Lilex Nerd Font Mono"}}.
26+ \\ 4. Put secrets in values/secrets.json and gitignore it.
27+ \\ 5. Leave anything identical on every machine as plain text.
28+ \\
29+;
30+
31+pub fn main(init: std.process.Init) !void {
32+ run(init) catch |e| {
33+ if (e == error.Message) std.process.exit(1);
34+ return e;
35+ };
36+}
37+
38+fn run(init: std.process.Init) !void {
39+ const arena = init.arena.allocator();
40+ const io = init.io;
41+ const args = try init.minimal.args.toSlice(arena);
42+
43+ var tmpl_path: ?[]const u8 = null;
44+ var values_path: ?[]const u8 = null;
45+
46+ var i: usize = 1;
47+ while (i < args.len) : (i += 1) {
48+ const a = args[i];
49+ if (std.mem.eql(u8, a, "--skill")) return stdout(io, skill);
50+ if (std.mem.eql(u8, a, "--tmpl")) {
51+ i += 1;
52+ tmpl_path = try arg(args, i, "--tmpl");
53+ } else if (std.mem.eql(u8, a, "--values")) {
54+ i += 1;
55+ values_path = try arg(args, i, "--values");
56+ } else {
57+ return fail("unknown argument: {s}", .{a});
58+ }
59+ }
60+
61+ const tmpl = tmpl_path orelse return fail("missing --tmpl", .{});
62+ const values = values_path orelse return fail("missing --values", .{});
63+
64+ const home = init.environ_map.get("HOME") orelse return fail("HOME is not set", .{});
65+
66+ const source = Io.Dir.cwd().readFileAlloc(io, tmpl, arena, .unlimited) catch |e|
67+ return fail("cannot read template {s}: {t}", .{ tmpl, e });
68+ const values_json = Io.Dir.cwd().readFileAlloc(io, values, arena, .unlimited) catch |e|
69+ return fail("cannot read values {s}: {t}", .{ values, e });
70+
71+ var parsed = std.json.parseFromSliceLeaky(Value, arena, values_json, .{}) catch |e|
72+ return fail("cannot parse {s}: {t}", .{ values, e });
73+
74+ // Merge a sibling `secrets.json`, if present, so templates can use secret keys directly.
75+ if (secretsPath(arena, values)) |secrets_path| {
76+ if (Io.Dir.cwd().readFileAlloc(io, secrets_path, arena, .unlimited) catch null) |secrets_json| {
77+ const secrets = std.json.parseFromSliceLeaky(Value, arena, secrets_json, .{}) catch |e|
78+ return fail("cannot parse {s}: {t}", .{ secrets_path, e });
79+ parsed = try merge(arena, parsed, secrets);
80+ }
81+ }
82+
83+ const rendered = try render(arena, source, parsed);
84+
85+ const rel = tmplRelPath(arena, tmpl) catch
86+ return fail("template path must live under a 'tmpl' directory: {s}", .{tmpl});
87+ const dest = try std.fs.path.join(arena, &.{ home, rel });
88+
89+ var af = Io.Dir.cwd().createFileAtomic(io, dest, .{ .make_path = true, .replace = true }) catch |e|
90+ return fail("cannot create {s}: {t}", .{ dest, e });
91+ defer af.deinit(io);
92+ try af.file.writeStreamingAll(io, rendered);
93+ try af.replace(io);
94+}
95+
96+fn arg(args: []const []const u8, i: usize, flag: []const u8) ![]const u8 {
97+ if (i >= args.len) return fail("{s} needs a path", .{flag});
98+ return args[i];
99+}
100+
101+// Everything after the `tmpl` path component, relative to $HOME.
102+fn tmplRelPath(arena: std.mem.Allocator, tmpl: []const u8) ![]const u8 {
103+ var it = std.mem.tokenizeScalar(u8, tmpl, '/');
104+ var found = false;
105+ var out: std.ArrayList(u8) = .empty;
106+ while (it.next()) |part| {
107+ if (!found) {
108+ found = std.mem.eql(u8, part, "tmpl");
109+ continue;
110+ }
111+ if (out.items.len != 0) try out.append(arena, '/');
112+ try out.appendSlice(arena, part);
113+ }
114+ if (!found or out.items.len == 0) return error.NotATemplate;
115+ return out.items;
116+}
117+
118+// Path to a sibling `secrets.json` next to the values file, or null when not wanted.
119+fn secretsPath(arena: std.mem.Allocator, values: []const u8) ?[]const u8 {
120+ if (std.mem.eql(u8, std.fs.path.basename(values), "secrets.json")) return null;
121+ const dir = std.fs.path.dirname(values) orelse ".";
122+ return std.fs.path.join(arena, &.{ dir, "secrets.json" }) catch null;
123+}
124+
125+// Shallow merge of two JSON objects; `over` wins on key collisions.
126+fn merge(arena: std.mem.Allocator, base: Value, over: Value) !Value {
127+ const base_obj = switch (base) {
128+ .object => |o| o,
129+ else => return base,
130+ };
131+ const over_obj = switch (over) {
132+ .object => |o| o,
133+ else => return base,
134+ };
135+ var map: std.json.ObjectMap = .empty;
136+ var it = base_obj.iterator();
137+ while (it.next()) |e| try map.put(arena, e.key_ptr.*, e.value_ptr.*);
138+ var it2 = over_obj.iterator();
139+ while (it2.next()) |e| try map.put(arena, e.key_ptr.*, e.value_ptr.*);
140+ return .{ .object = map };
141+}
142+
143+fn render(arena: std.mem.Allocator, tmpl: []const u8, root: Value) ![]const u8 {
144+ var out: std.ArrayList(u8) = .empty;
145+ var i: usize = 0;
146+ while (i < tmpl.len) {
147+ if (tmpl[i] == '{' and i + 1 < tmpl.len and tmpl[i + 1] == '{') {
148+ const close = std.mem.indexOfPos(u8, tmpl, i + 2, "}}") orelse
149+ return fail("unclosed '{{{{' at byte {d}", .{i});
150+ const key = std.mem.trim(u8, tmpl[i + 2 .. close], " \t\r\n");
151+ const v = lookup(root, key) orelse
152+ return fail("no value for '{s}'", .{key});
153+ try emit(arena, &out, key, v);
154+ i = close + 2;
155+ } else {
156+ try out.append(arena, tmpl[i]);
157+ i += 1;
158+ }
159+ }
160+ return out.items;
161+}
162+
163+fn lookup(root: Value, key: []const u8) ?Value {
164+ if (key.len == 0) return null;
165+ var cur = root;
166+ var it = std.mem.splitScalar(u8, key, '.');
167+ while (it.next()) |part| {
168+ cur = switch (cur) {
169+ .object => |o| o.get(part) orelse return null,
170+ else => return null,
171+ };
172+ }
173+ return cur;
174+}
175+
176+fn emit(arena: std.mem.Allocator, out: *std.ArrayList(u8), key: []const u8, v: Value) !void {
177+ switch (v) {
178+ .string => |s| try out.appendSlice(arena, s),
179+ .integer => |n| try out.print(arena, "{d}", .{n}),
180+ .float => |n| try out.print(arena, "{d}", .{n}),
181+ .bool => |b| try out.appendSlice(arena, if (b) "true" else "false"),
182+ .null => {},
183+ else => return fail("value for '{s}' is not a scalar", .{key}),
184+ }
185+}
186+
187+fn stdout(io: Io, text: []const u8) void {
188+ var buf: [4096]u8 = undefined;
189+ var w: Io.File.Writer = .init(.stdout(), io, &buf);
190+ w.interface.writeAll(text) catch {};
191+ w.interface.flush() catch {};
192+}
193+
194+fn fail(comptime fmt: []const u8, args: anytype) error{Message} {
195+ std.debug.print("dot-compose: " ++ fmt ++ "\n", args);
196+ return error.Message;
197+}