add the sum command

Author: nektro

README.md

@@ -64,6 +64,14 @@ zigmod fetch
 - This command takes no parameters and will generate a `deps.zig` in the root of your project.
 - `deps.zig` should not be checked into your source control.
 
+### `sum` command
+```
+zigmod sum
+```
+
+- This will generate a `zig.sum` file with the blake3 hashes of your modules.
+- Place that hash in the `hash: blake3:<hash>` property of a dependency to be able to check it with `verify`.
+
 ### Adding `deps.zig` to `build.zig`
 ```diff
 const Builder = @import("std").build.Builder;

src/cmd_sum.zig

@@ -0,0 +1,42 @@
+const std = @import("std");
+const gpa = std.heap.c_allocator;
+
+const known_folders = @import("known-folders");
+const u = @import("./util/index.zig");
+const common = @import("./common.zig");
+
+//
+//
+
+pub fn execute(args: [][]u8) !void {
+    //
+    const home = try known_folders.getPath(gpa, .home);
+    const dir = try std.fmt.allocPrint(gpa, "{}{}", .{home, "/.cache/zigmod"});
+    const top_module = try common.collect_deps(dir, "./zig.mod");
+    
+    //
+    const f = try std.fs.cwd().createFile("./zig.sum", .{});
+    defer f.close();
+    const w = f.writer();
+
+    //
+    const module_list = &std.ArrayList(u.Module).init(gpa);
+    try dedupe_mod_list(module_list, top_module);
+
+    for (module_list.items) |m| {
+        const hash = try m.get_hash(dir);
+        try w.print("{} {}\n", .{m.clean_path, hash});
+    }
+}
+
+fn dedupe_mod_list(list: *std.ArrayList(u.Module), module: u.Module) anyerror!void {
+    if (u.list_contains_gen(u.Module, list, module)) {
+        return;
+    }
+    if (module.clean_path.len > 0) {
+        try list.append(module);
+    }
+    for (module.deps) |m| {
+        try dedupe_mod_list(list, m);
+    }
+}

src/main.zig

@@ -10,6 +10,7 @@ const commands = struct {
     const init = @import("./cmd_init.zig");
     // const add = @import("./cmd_add.zig");
     const fetch = @import("./cmd_fetch.zig");
+    const sum = @import("./cmd_sum.zig");
 };
 
 pub fn main() !void {

src/util/module.zig

@@ -1,10 +1,15 @@
 const std = @import("std");
+const gpa = std.heap.c_allocator;
 
 const u = @import("index.zig");
 
 //
 //
 
+const b = 1;
+const kb = b * 1024;
+const mb = kb * 1024;
+
 pub const Module = struct {
     name: []const u8,
     main: []const u8,
@@ -26,4 +31,40 @@ pub const Module = struct {
             .clean_path = try dep.clean_path(),
         };
     }
+
+    pub fn eql(self: Module, another: Module) bool {
+        return std.mem.eql(u8, self.clean_path, another.clean_path);
+    }
+
+    pub fn get_hash(self: Module, cdpath: []const u8) ![]const u8 {
+        const file_list_1 = &std.ArrayList([]const u8).init(gpa);
+        try u.file_list(try u.concat(&[_][]const u8{cdpath, "/", self.clean_path}), file_list_1);
+
+        const file_list_2 = &std.ArrayList([]const u8).init(gpa);
+        for (file_list_1.items) |item| {
+            const _a = u.trim_prefix(item, cdpath)[1..];
+            const _b = u.trim_prefix(_a, self.clean_path)[1..];
+            if (_b[0] == '.') continue;
+            try file_list_2.append(_b);
+        }
+
+        std.sort.sort([]const u8, file_list_2.items, void{}, struct {
+            pub fn lt(context: void, lhs: []const u8, rhs: []const u8) bool {
+                return std.mem.lessThan(u8, lhs, rhs);
+            }
+        }.lt);
+
+        const h = &std.crypto.hash.Blake3.init(.{});
+        for (file_list_2.items) |item| {
+            const abs_path = try u.concat(&[_][]const u8{cdpath, "/", self.clean_path, "/", item});
+            const file = try std.fs.openFileAbsolute(abs_path, .{});
+            defer file.close();
+            const input = try file.reader().readAllAlloc(gpa, mb);
+            h.update(input);
+        }
+        var out: [32]u8 = undefined;
+        h.final(&out);
+        const hex = try std.fmt.allocPrint(gpa, "{x}", .{out});
+        return hex;
+    }
 };