Added support for config files

1 files changed, 92 insertions, 0 deletions

diff --git a/src/Config.zig b/src/Config.zig
new file mode 100644
index 0000000..a7affa0
--- /dev/null
+++ b/src/Config.zig
@@ -0,0 +1,92 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const xdg = @import("xdg");
+
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
+const Config = @This();
+const CrossTarget = std.zig.CrossTarget;
+const File = std.fs.File;
+const NativeTargetInfo = std.zig.system.NativeTargetInfo;
+const Target = std.Target;
+
+allocator: Allocator,
+/// Earlier in the list means more preferred.
+supported_targets: ArrayList(Target),
+
+pub fn init(allocator: Allocator) !Config {
+    var self = Config{
+        .allocator = allocator,
+        .supported_targets = ArrayList(Target).init(allocator),
+    };
+    errdefer self.deinit();
+
+    // Native target is always supported and at highest priority
+    try self.supported_targets.append(builtin.target);
+
+    const config_dirs = try xdg.getAllConfigDirs(allocator, "zup");
+    defer {
+        for (config_dirs) |s| allocator.free(s);
+        allocator.free(config_dirs);
+    }
+
+    for (config_dirs) |config_dir| {
+        const file_name = try std.fs.path.join(allocator, &.{ config_dir, "zup.json" });
+        defer allocator.free(file_name);
+        var file = std.fs.openFileAbsolute(file_name, .{}) catch |err| {
+            if (err == error.FileNotFound) {
+                continue;
+            } else {
+                return err;
+            }
+        };
+        defer file.close();
+
+        try self.readConfig(file);
+    }
+    
+    return self;
+}
+
+pub fn deinit(self: *Config) void {
+    self.supported_targets.deinit();
+    
+    self.* = undefined;
+}
+
+fn readConfig(self: *Config, file: File) !void {
+    const allocator = self.allocator;
+    const reader = file.reader();
+
+    var json_str = try reader.readAllAlloc(allocator, std.math.maxInt(u64));
+    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) {
+        std.log.warn("Failed at reading config, root isn't object.", .{});
+        return;
+    }
+
+    if (vt.root.Object.get("supported_targets")) |supported_targets| blk: {
+        if (supported_targets != .Array) {
+            break :blk;
+        }
+
+        for (supported_targets.Array.items) |supported_target| {
+            if (supported_target != .String) {
+                continue;
+            }
+
+            const cross_target = try CrossTarget.parse(.{
+                .arch_os_abi = supported_target.String,
+            });
+            const native_target_info = try NativeTargetInfo.detect(allocator, cross_target);
+            try self.supported_targets.append(native_target_info.target);
+        }
+    }
+}