Initial commit0.1.0

1 files changed, 101 insertions, 0 deletions

diff --git a/src/install.zig b/src/install.zig
new file mode 100644
index 0000000..7a52d44
--- /dev/null
+++ b/src/install.zig
@@ -0,0 +1,101 @@
+const libarchive = @import("libarchive");
+const curl = @import("curl");
+const std = @import("std");
+const xdg = @import("xdg");
+const zup = @import("zup");
+
+const Allocator = std.mem.Allocator;
+const ArchiveRead = libarchive.Read;
+const Installation = zup.Installation;
+const Installations = zup.Installations;
+
+pub const params =
+    \\-f, --force  Install over existing installations
+    \\<NAME>
+;
+pub const description = "Installs a Zig version.  Run `zup list -i` to see installed <NAME>s.";
+pub const min_args = 1;
+pub const max_args = 1;
+
+pub fn main(comptime Result: type, allocator: Allocator, res: Result) !void {
+    var available = try Installation.getAvailableList(allocator);
+    defer Installation.deinitMap(allocator, &available);
+
+    return perform(allocator, res.positionals[0], res.args.force, available);
+}
+
+pub fn perform(allocator: Allocator, name: []const u8, force: bool, available: Installations) !void {
+    if (!force and try Installation.isInstalled(allocator, name)) {
+        std.log.err("{s} already installed, not overwriting without --force!", .{name});
+        return error.AlreadyInstalled;
+    }
+
+    const installation = available.get(name) orelse {
+        std.log.err("Installation by name {s} not available!", .{name});
+        return error.InstallationNotFound;
+    };
+
+    if (installation.url == null) {
+        std.log.err("No tarball URL for {s} found!", .{name});
+    }
+
+    const installation_dir = blk: {
+        const data_home = try xdg.getDataHome(allocator, "zup");
+        defer allocator.free(data_home);
+
+        break :blk try std.fs.path.join(allocator, &.{ data_home, name });
+    };
+    defer allocator.free(installation_dir);
+
+    std.log.info("Installing {s}, version {}", .{ name, installation.version });
+    const filename = std.fs.path.basename(installation.url.?);
+
+    // TODO: Platform-agnostic tempfile creation
+    var tmpname = try std.fmt.allocPrintZ(allocator, "/tmp/{s}", .{filename});
+    defer allocator.free(tmpname);
+
+    var tmpdir = try std.fs.openDirAbsolute(std.fs.path.dirname(tmpname).?, .{});
+    defer tmpdir.close();
+
+    var tmpfile = try tmpdir.createFile(filename, .{});
+    defer {
+        tmpfile.close();
+        std.log.info("Deleting /tmp/{s}...", .{filename});
+        tmpdir.deleteFile(filename) catch |err| {
+            std.log.warn("Failed to delete /tmp/{s}: {}", .{ filename, err });
+        };
+    }
+
+    std.log.info("Downloading to /tmp/{s}...", .{filename});
+    try curl.easyDownloadToFile(&tmpfile, installation.url.?);
+
+    std.log.info("Extracting...", .{});
+    var archive = try ArchiveRead.init();
+    defer archive.deinit();
+
+    try archive.supportFilter(.all);
+    try archive.supportFormat(.all);
+    try archive.openFilename(tmpname, 10240);
+
+    while (try archive.nextHeader()) |*entry| {
+        const source = entry.pathname();
+        const dest = try preparePathname(allocator, installation_dir, source);
+        defer allocator.free(dest);
+
+        entry.setPathname(dest);
+        try archive.extract(entry.*, 0);
+    }
+
+    std.log.info("Installed to {s}", .{installation_dir});
+    // TODO: Check if it is already active
+    std.log.info("If you want to use this installation, run `zup switch {s}`", .{name});
+}
+
+fn preparePathname(allocator: Allocator, installation_dir: []const u8, source: []const u8) ![:0]u8 {
+    const stripped = if (std.mem.indexOfScalar(u8, source, '/')) |idx|
+        source[idx + 1 ..]
+    else
+        "";
+
+    return std.fs.path.joinZ(allocator, &.{ installation_dir, stripped });
+}