Update for newest zig

8 files changed, 74 insertions, 58 deletions

diff --git a/src/Config.zig b/src/Config.zig
index 4eb58cc..e559cad 100644
--- a/src/Config.zig
+++ b/src/Config.zig
@@ -3,6 +3,7 @@ const std = @import("std");
 const xdg = @import("xdg");
 
 const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
 const ArrayList = std.ArrayList;
 const Config = @This();
 const CrossTarget = std.zig.CrossTarget;
@@ -55,38 +56,49 @@ pub fn deinit(self: *Config) void {
 }
 
 fn readConfig(self: *Config, file: File) !void {
-    const allocator = self.allocator;
-    const reader = file.reader();
+    var arena = ArenaAllocator.init(self.allocator);
+    defer arena.deinit();
 
-    var json_str = try reader.readAllAlloc(allocator, std.math.maxInt(u64));
-    defer allocator.free(json_str);
+    const allocator = arena.allocator();
 
-    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) {
-        std.log.warn("Failed at reading config, root isn't object.", .{});
-        return;
-    }
+    const ConfigJson = struct {
+        supported_targets: [][]u8,
+    };
 
-    if (vt.root.Object.get("supported_targets")) |supported_targets| blk: {
-        if (supported_targets != .Array) {
-            break :blk;
-        }
+    var reader = std.json.reader(allocator, file.reader());
+    defer reader.deinit();
+
+    const parsed = try std.json.parseFromTokenSourceLeaky(
+        ConfigJson,
+        allocator,
+        &reader,
+        .{
+            .duplicate_field_behavior = .use_last,
+            .ignore_unknown_fields = true,
+        },
+    );
+
+    try self.supported_targets.ensureUnusedCapacity(parsed.supported_targets.len);
+
+    for (parsed.supported_targets) |target| {
+        const ct = CrossTarget.parse(.{
+            .arch_os_abi = target,
+        }) catch |e| {
+            std.log.warn(
+                "Failed to parse '{s}' as a target string: {}",
+                .{ target, e },
+            );
+            continue;
+        };
 
-        for (supported_targets.Array.items) |supported_target| {
-            if (supported_target != .String) {
-                continue;
-            }
+        const nti = NativeTargetInfo.detect(ct) catch |e| {
+            std.log.warn(
+                "Failed to detect NativeTargetInfo from '{s}': {}",
+                .{ target, e },
+            );
+            continue;
+        };
 
-            const cross_target = try CrossTarget.parse(.{
-                .arch_os_abi = supported_target.String,
-            });
-            const native_target_info = try NativeTargetInfo.detect(cross_target);
-            try self.supported_targets.append(native_target_info.target);
-        }
+        self.supported_targets.appendAssumeCapacity(nti.target);
     }
 }
diff --git a/src/Installation.zig b/src/Installation.zig
index 3ff65ea..54b870c 100644
--- a/src/Installation.zig
+++ b/src/Installation.zig
@@ -4,6 +4,7 @@ const xdg = @import("xdg");
 const zup = @import("root");
 
 const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
 const Config = zup.Config;
 const ChildProcess = std.ChildProcess;
 const JsonValue = std.json.Value;
@@ -84,7 +85,7 @@ pub fn getInstalledList(allocator: Allocator) !Installations {
 
     var it = zup_data_iterable.iterate();
     while (try it.next()) |item| {
-        if (item.kind != .Directory) {
+        if (item.kind != .directory) {
             continue;
         }
 
@@ -133,32 +134,35 @@ pub fn isInstalled(allocator: Allocator, name: []const u8) !bool {
 }
 
 pub fn getAvailableList(config: Config) !Installations {
-    const allocator = config.allocator;
+    var arena = ArenaAllocator.init(config.allocator);
+    defer arena.deinit();
 
-    var json_str = try curl.easyDownload(allocator, "https://ziglang.org/download/index.json");
-    defer allocator.free(json_str);
+    const allocator = arena.allocator();
 
-    var parser = std.json.Parser.init(allocator, false);
-    defer parser.deinit();
+    const json_str = try curl.easyDownload(allocator, "https://ziglang.org/download/index.json");
 
-    var vt = try parser.parse(json_str);
-    defer vt.deinit();
+    const parsed = try std.json.parseFromSliceLeaky(
+        JsonValue,
+        allocator,
+        json_str,
+        .{},
+    );
 
-    if (vt.root != .Object) {
+    if (parsed != .object) {
         return error.JsonSchema;
     }
 
-    var installations = Installations.init(allocator);
-    errdefer Installation.deinitMap(allocator, &installations);
+    var installations = Installations.init(config.allocator);
+    errdefer Installation.deinitMap(config.allocator, &installations);
 
-    var it = vt.root.Object.iterator();
+    var it = parsed.object.iterator();
     while (it.next()) |kv| {
         var installation_opt = try parseInstallation(config, kv.key_ptr.*, kv.value_ptr.*);
         if (installation_opt) |*installation| {
             errdefer installation.deinit();
 
-            var name = try allocator.dupe(u8, kv.key_ptr.*);
-            errdefer allocator.free(name);
+            var name = try config.allocator.dupe(u8, kv.key_ptr.*);
+            errdefer config.allocator.free(name);
 
             try installations.putNoClobber(name, installation.*);
         }
@@ -170,10 +174,10 @@ pub fn getAvailableList(config: Config) !Installations {
 fn parseInstallation(config: Config, name: []const u8, value: JsonValue) !?Installation {
     const allocator = config.allocator;
 
-    if (value != .Object) {
+    if (value != .object) {
         return error.JsonSchema;
     }
-    const map = value.Object;
+    const map = value.object;
 
     const url_root = url_root: {
         for (config.supported_targets.items) |target| {
@@ -190,23 +194,23 @@ fn parseInstallation(config: Config, name: []const u8, value: JsonValue) !?Insta
 
         return null;
     };
-    if (url_root != .Object) {
+    if (url_root != .object) {
         return error.JsonSchema;
     }
-    const url_src = url_root.Object.get("tarball") orelse {
+    const url_src = url_root.object.get("tarball") orelse {
         return error.JsonSchema;
     };
-    if (url_src != .String) {
+    if (url_src != .string) {
         return error.JsonSchema;
     }
-    var url = try allocator.dupeZ(u8, url_src.String);
+    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) {
+        if (ver != .string) {
             return error.JsonSchema;
         } else {
-            break :blk ver.String;
+            break :blk ver.string;
         }
     } else blk: {
         break :blk name;
diff --git a/src/list.zig b/src/list.zig
index 0a0fee9..9ff26c2 100644
--- a/src/list.zig
+++ b/src/list.zig
@@ -19,7 +19,7 @@ pub const max_args = 0;
 
 pub fn main(comptime Result: type, config: Config, res: Result) !void {
     const allocator = config.allocator;
-    
+
     var list_active = res.args.active != 0;
     var list_available = res.args.available != 0;
     var list_installed = res.args.installed != 0;
@@ -96,7 +96,7 @@ fn printList(allocator: Allocator, installations: Installations) !void {
         list.appendAssumeCapacity(.{ .name = kv.key_ptr.*, .installation = kv.value_ptr.* });
     }
 
-    std.sort.sort(InstallationAndName, list.items, {}, InstallationAndName.lessThan);
+    std.mem.sort(InstallationAndName, list.items, {}, InstallationAndName.lessThan);
 
     const writer = std.io.getStdOut().writer();
     for (list.items) |item| {
diff --git a/src/main.zig b/src/main.zig
index 93356d6..93cd5d4 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -60,7 +60,7 @@ const CommandMap = blk: {
     map_data[1] = .{ "--version", .version };
     var idx: usize = 2;
     inline for (commands) |command| {
-        map_data[idx] = .{ command.name, @intToEnum(Command, command.value) };
+        map_data[idx] = .{ command.name, @as(Command, @enumFromInt(command.value)) };
         idx += 1;
     }
 
@@ -78,7 +78,7 @@ fn dispatch(
     const cmd_enum = CommandMap.get(cmd) orelse return @call(.auto, default_fn, args);
     const commands = @typeInfo(Command).Enum.fields;
     inline for (commands) |command| {
-        if (@enumToInt(cmd_enum) == command.value) {
+        if (@intFromEnum(cmd_enum) == command.value) {
             const fun = @field(@field(@This(), command.name), fn_name);
             return @call(.auto, fun, args);
         }
diff --git a/src/remove.zig b/src/remove.zig
index 2d868fb..bc5b06a 100644
--- a/src/remove.zig
+++ b/src/remove.zig
@@ -15,7 +15,7 @@ pub const max_args = 1;
 
 pub fn main(comptime Result: type, config: Config, res: Result) !void {
     const allocator = config.allocator;
-    
+
     const name = res.positionals[0];
 
     if (!try Installation.isInstalled(allocator, name)) {
diff --git a/src/subcommand.zig b/src/subcommand.zig
index 09f1b4f..8fde170 100644
--- a/src/subcommand.zig
+++ b/src/subcommand.zig
@@ -37,7 +37,7 @@ pub fn SubCommand(comptime template: type) type {
 
         pub fn main(name: []const u8, config: Config, args: *ArgIterator) !void {
             const allocator = config.allocator;
-            
+
             var diag = clap.Diagnostic{};
             var res = clap.parseEx(clap.Help, &params, parsers, args, .{
                 .allocator = allocator,
diff --git a/src/switch.zig b/src/switch.zig
index f90f7d7..3323332 100644
--- a/src/switch.zig
+++ b/src/switch.zig
@@ -12,7 +12,7 @@ pub const max_args = 1;
 
 pub fn main(comptime Result: type, config: Config, res: Result) !void {
     const allocator = config.allocator;
-    
+
     const name = res.positionals[0];
     if (!try Installation.isInstalled(allocator, name)) {
         std.log.err(
diff --git a/src/update.zig b/src/update.zig
index 55e6847..fc1ab51 100644
--- a/src/update.zig
+++ b/src/update.zig
@@ -13,7 +13,7 @@ pub const max_args = 0;
 
 pub fn main(comptime Result: type, config: Config, _: Result) !void {
     const allocator = config.allocator;
-    
+
     var installed = try Installation.getInstalledList(allocator);
     defer Installation.deinitMap(allocator, &installed);