@@ -1,197 +0,0 @@
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-}