dep-hash: add dep-hash cli tool

Author: dweiller

lib/compiler/dep-hash.zig

@@ -0,0 +1,219 @@
+const usage_dep_hash =
+    \\Usage: zig dep-hash [--list] [dep-name]
+    \\
+    \\   List the hashes of packages in the build.zig.zon manifest.
+    \\
+    \\Options:
+    \\  --list                    List all package hashes
+    \\  --build-root [path]       Set package root directory
+    \\  --global-cache-dir [path] Override the global cache directory
+    \\  -h, --help                Print this help and exit
+    \\
+    \\
+;
+
+pub fn main() !void {
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+    const gpa = arena;
+
+    const args = try std.process.argsAlloc(arena);
+    const color: std.zig.Color = .auto;
+    var list = false;
+    var package_opt: ?[]const u8 = null;
+    var build_root_path: ?[]const u8 = null;
+    var override_global_cache_dir: ?[]const u8 = try std.zig.EnvVar.ZIG_GLOBAL_CACHE_DIR.get(arena);
+
+    assert(args.len > 0);
+
+    {
+        var i: usize = 1;
+        while (i < args.len) : (i += 1) {
+            const arg = args[i];
+            if (arg[0] == '-') {
+                if (std.mem.eql(u8, arg, "-h") or std.mem.eql(u8, arg, "--help")) {
+                    const stdout = std.io.getStdOut();
+                    try stdout.writeAll(usage_dep_hash);
+                    return std.process.cleanExit();
+                } else if (std.mem.eql(u8, arg, "--list")) {
+                    list = true;
+                } else if (std.mem.eql(u8, arg, "--build-root")) {
+                    i += 1;
+                    if (i >= args.len) fatal("build root expected after --build-root", .{});
+                    build_root_path = args[i];
+                } else if (std.mem.eql(u8, arg, "--global-cache-dir")) {
+                    i += 1;
+                    if (i >= args.len) fatal("cache directory expected after --global-cache-dir", .{});
+                    override_global_cache_dir = args[i];
+                } else {
+                    fatal("unrecognized parameter: '{s}'", .{arg});
+                }
+            } else if (package_opt != null) {
+                fatal("unexpected extra parameter: '{s}'", .{arg});
+            } else {
+                package_opt = arg;
+            }
+        }
+    }
+
+    var build_root = try std.zig.findBuildRoot(arena, .{
+        .cwd_path = build_root_path,
+        .hint = build_root_path == null,
+    });
+    defer build_root.deinit();
+
+    var global_cache_package_directory: std.fs.Dir = l: {
+        const p = try std.fs.path.join(arena, &.{
+            override_global_cache_dir orelse try std.zig.introspect.resolveGlobalCacheDir(arena),
+            "p",
+        });
+
+        break :l try std.fs.cwd().makeOpenPath(p, .{});
+    };
+    defer global_cache_package_directory.close();
+
+    var manifest, var ast = std.zig.loadManifest(gpa, arena, .{
+        .root_name = null,
+        .dir = build_root.directory.handle,
+        .color = color,
+    }) catch |err| switch (err) {
+        error.FileNotFound => fatal("no manifest found in build root", .{}),
+        else => |e| return e,
+    };
+    defer {
+        manifest.deinit(gpa);
+        ast.deinit(gpa);
+    }
+
+    if (package_opt) |package| {
+        if (package.len == 0) {
+            fatal("package name must not be empty", .{});
+        }
+        const dep: std.zig.Manifest.Dependency = dep: {
+            var iter = std.mem.tokenizeScalar(u8, package, '.');
+
+            var dep = manifest.dependencies.get(iter.next().?) orelse {
+                fatal("there is no dependency named '{s}' in the manifest\n", .{package});
+            };
+
+            var dep_name = iter.buffer[0 .. iter.index - 1];
+
+            while (iter.next()) |p| {
+                if (dep.hash) |hash| {
+                    var package_dir = global_cache_package_directory.openDir(hash, .{}) catch |e| switch (e) {
+                        error.FileNotFound => fatal("{s} is not in the global cache (hash: {s})", .{
+                            dep_name, hash,
+                        }),
+                        else => |err| return err,
+                    };
+                    defer package_dir.close();
+
+                    const sub_manifest, _ = try std.zig.loadManifest(arena, arena, .{
+                        .root_name = null,
+                        .dir = package_dir,
+                        .color = color,
+                    });
+
+                    dep = sub_manifest.dependencies.get(p) orelse {
+                        fatal("{s} has no dependency named '{s}' in its manifest", .{ dep_name, package });
+                    };
+                    dep_name = iter.buffer[0 .. iter.index - 1];
+                } else switch (dep.location) {
+                    .url => fatal("the hash for {s} is missing from the manifest.\n", .{
+                        dep_name,
+                    }),
+                    .path => |path| fatal("{s} is a local dependency located at {s}\n", .{
+                        dep_name, path,
+                    }),
+                }
+            }
+
+            break :dep dep;
+        };
+
+        const stdout = std.io.getStdOut().writer();
+
+        if (dep.hash) |hash| {
+            if (list) {
+                var package_dir = global_cache_package_directory.openDir(hash, .{}) catch |e| switch (e) {
+                    error.FileNotFound => fatal("{s} is not in the global cache (hash: {s})", .{
+                        package, hash,
+                    }),
+                    else => |err| return err,
+                };
+                defer package_dir.close();
+
+                var sub_manifest, var sub_ast = std.zig.loadManifest(gpa, arena, .{
+                    .root_name = null,
+                    .dir = package_dir,
+                    .color = color,
+                }) catch |err| switch (err) {
+                    error.FileNotFound => fatal("no manifest found in build root", .{}),
+                    else => |e| return e,
+                };
+                defer {
+                    sub_manifest.deinit(gpa);
+                    sub_ast.deinit(gpa);
+                }
+
+                const prefix = prefix: {
+                    const buffer = try arena.alloc(u8, package.len + 1);
+                    @memcpy(buffer[0..package.len], package);
+                    buffer[buffer.len - 1] = '.';
+                    break :prefix buffer;
+                };
+
+                try listDepHashes(prefix, sub_manifest);
+            } else {
+                try stdout.print("{s}\n", .{hash});
+            }
+        } else switch (dep.location) {
+            .url => fatal("the hash for {s} is missing from the manifest.\n", .{package}),
+            .path => |path| fatal("{s} is a local dependency located at {s}\n", .{ package, path }),
+        }
+    } else {
+        try listDepHashes("", manifest);
+    }
+}
+
+fn listDepHashes(parent_prefix: []const u8, manifest: std.zig.Manifest) !void {
+    assert(parent_prefix.len != 1);
+    if (manifest.dependencies.count() == 0) {
+        const name = if (parent_prefix.len > 0)
+            parent_prefix[0 .. parent_prefix.len - 1]
+        else
+            manifest.name;
+
+        const stdout = std.io.getStdOut().writer();
+        try stdout.print("{s} has no dependencies\n", .{name});
+        return;
+    }
+
+    var deps = manifest.dependencies.iterator();
+    while (deps.next()) |entry| {
+        const stdout = std.io.getStdOut().writer();
+        const name = entry.key_ptr.*;
+        if (entry.value_ptr.hash) |hash| {
+            try stdout.print("{s}{s}    {s}\n", .{ parent_prefix, name, hash });
+        } else {
+            switch (entry.value_ptr.location) {
+                .url => try stdout.print("{s}{s}    {s}\n", .{
+                    parent_prefix, name, "(missing)",
+                }),
+                .path => |p| try stdout.print("{s}{s}    {s} (local)\n", .{
+                    parent_prefix, name, p,
+                }),
+            }
+        }
+    }
+}
+
+fn fatal(comptime format: []const u8, args: anytype) noreturn {
+    std.log.err(format, args);
+    std.process.exit(1);
+}
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;

src/main.zig

@@ -319,6 +319,11 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             .cmd_name = "objcopy",
             .root_src_path = "objcopy.zig",
         });
+    } else if (mem.eql(u8, cmd, "dep-hash")) {
+        return jitCmd(gpa, arena, cmd_args, .{
+            .cmd_name = "dep-hash",
+            .root_src_path = "dep-hash.zig",
+        });
     } else if (mem.eql(u8, cmd, "fetch")) {
         return cmdFetch(gpa, arena, cmd_args);
     } else if (mem.eql(u8, cmd, "libc")) {