Initial commit0.1.0

1 files changed, 196 insertions, 0 deletions

diff --git a/src/Installation.zig b/src/Installation.zig
new file mode 100644
index 0000000..3b0382a
--- /dev/null
+++ b/src/Installation.zig
@@ -0,0 +1,196 @@
+const builtin = @import("builtin");
+const curl = @import("curl");
+const std = @import("std");
+const xdg = @import("xdg");
+
+const Allocator = std.mem.Allocator;
+const ChildProcess = std.ChildProcess;
+const JsonValue = std.json.Value;
+const SemanticVersion = std.SemanticVersion;
+const StringHashMap = std.StringHashMap;
+
+const Installation = @This();
+
+pub const Installations = StringHashMap(Installation);
+
+allocator: Allocator,
+ver_str: []u8,
+version: SemanticVersion,
+url: ?[:0]u8,
+
+pub fn deinit(self: *Installation) void {
+    self.allocator.free(self.ver_str);
+    if (self.url) |url| self.allocator.free(url);
+
+    self.* = undefined;
+}
+
+pub fn deinitMap(allocator: Allocator, installations: *Installations) void {
+    var it = installations.iterator();
+    while (it.next()) |kv| {
+        allocator.free(kv.key_ptr.*);
+        kv.value_ptr.deinit();
+    }
+
+    installations.deinit();
+
+    installations.* = undefined;
+}
+
+pub fn getActiveName(allocator: Allocator) !?[]u8 {
+    var bin_home = try xdg.openBinHome(allocator);
+    defer bin_home.close();
+
+    var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+    const linkname = bin_home.readLink("zig", &buf) catch |err| {
+        if (err == error.NotLink or err == error.FileNotFound) {
+            return null;
+        } else {
+            return err;
+        }
+    };
+
+    var linkpath = try bin_home.realpathAlloc(allocator, linkname);
+    defer allocator.free(linkpath);
+
+    var zup_dir = try xdg.getDataHome(allocator, "zup");
+    defer allocator.free(zup_dir);
+
+    const rel_path = try std.fs.path.relative(allocator, zup_dir, linkpath);
+    defer allocator.free(rel_path);
+
+    return try allocator.dupe(u8, std.fs.path.dirname(rel_path).?);
+}
+
+pub fn isInstalled(allocator: Allocator, name: []const u8) !bool {
+    var zup_data = try xdg.openDataHome(allocator, "zup");
+    defer zup_data.close();
+
+    zup_data.access(name, .{}) catch return false;
+    return true;
+}
+
+pub fn getInstalledList(allocator: Allocator) !Installations {
+    var zup_data = try xdg.openDataHome(allocator, "zup");
+    defer zup_data.close();
+
+    var installations = Installations.init(allocator);
+    errdefer Installation.deinitMap(allocator, &installations);
+
+    var it = zup_data.iterate();
+    while (try it.next()) |item| {
+        if (item.kind != .Directory) {
+            continue;
+        }
+
+        var inst_dir = try zup_data.openDir(item.name, .{});
+        defer inst_dir.close();
+
+        var zig_exe = inst_dir.realpathAlloc(allocator, "zig") catch |err| {
+            if (err == error.FileNotFound) {
+                continue;
+            }
+            return err;
+        };
+        defer allocator.free(zig_exe);
+
+        const res = try ChildProcess.exec(.{ .allocator = allocator, .argv = &.{ zig_exe, "version" } });
+        errdefer allocator.free(res.stdout);
+        allocator.free(res.stderr);
+
+        if (res.term != .Exited or res.term.Exited != 0) {
+            std.log.warn("Failed to execute '{s} version'", .{zig_exe});
+            allocator.free(res.stdout);
+            continue;
+        }
+
+        const trimmed_ver_str = std.mem.trim(u8, res.stdout, &std.ascii.spaces);
+        const version = try SemanticVersion.parse(trimmed_ver_str);
+        const name = try allocator.dupe(u8, item.name);
+
+        try installations.putNoClobber(name, Installation{
+            .allocator = allocator,
+            .ver_str = res.stdout,
+            .version = version,
+            .url = null,
+        });
+    }
+
+    return installations;
+}
+
+pub fn getAvailableList(allocator: Allocator) !Installations {
+    var json_str = try curl.easyDownload(allocator, "https://ziglang.org/download/index.json");
+    defer allocator.free(json_str);
+
+    var parser = std.json.Parser.init(allocator, false);
+    defer parser.deinit();
+
+    var vt = try parser.parse(json_str);
+    defer vt.deinit();
+
+    if (vt.root != .Object) {
+        return error.JsonSchema;
+    }
+
+    var installations = Installations.init(allocator);
+    errdefer Installation.deinitMap(allocator, &installations);
+
+    var it = vt.root.Object.iterator();
+    while (it.next()) |kv| {
+        if (try parseInstallation(allocator, kv.key_ptr.*, kv.value_ptr.*)) |*installation| {
+            errdefer installation.deinit();
+
+            var name = try allocator.dupe(u8, kv.key_ptr.*);
+            errdefer allocator.free(name);
+
+            try installations.putNoClobber(name, installation.*);
+        }
+    }
+
+    return installations;
+}
+
+fn parseInstallation(allocator: Allocator, name: []const u8, value: JsonValue) !?Installation {
+    if (value != .Object) {
+        return error.JsonSchema;
+    }
+    const map = value.Object;
+
+    const triple = @tagName(builtin.target.cpu.arch) ++ "-" ++ @tagName(builtin.target.os.tag);
+
+    const url_root = map.get(triple) orelse {
+        return null;
+    };
+    if (url_root != .Object) {
+        return error.JsonSchema;
+    }
+    const url_src = url_root.Object.get("tarball") orelse {
+        return error.JsonSchema;
+    };
+    if (url_src != .String) {
+        return error.JsonSchema;
+    }
+    var url = try allocator.dupeZ(u8, url_src.String);
+    errdefer allocator.free(url);
+
+    const version_src = if (map.get("version")) |ver| blk: {
+        if (ver != .String) {
+            return error.JsonSchema;
+        } else {
+            break :blk ver.String;
+        }
+    } else blk: {
+        break :blk name;
+    };
+    var ver_str = try allocator.dupe(u8, version_src);
+    errdefer allocator.free(ver_str);
+    const version = try SemanticVersion.parse(ver_str);
+
+    return Installation{
+        .allocator = allocator,
+        .ver_str = ver_str,
+        .version = version,
+        .url = url,
+    };
+}