feat(formatters): add a tagged union to handle formatters with different signatures

src/formatters.zig

@@ -3,7 +3,12 @@ const std = @import("std");
 const ascii = @import("ascii.zig");
 const detection = @import("detection.zig").os_module;
 
-pub const formatters = [_]*const fn (allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) anyerror![]u8{
+const Result = union(enum) {
+    string: []u8,
+    string_arraylist: std.ArrayList([]u8),
+};
+
+pub const formatters = [_]*const fn (allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) anyerror!Result{
     &getFormattedOsInfo,
     &getFormattedKernelInfo,
     &getFormattedUptimeInfo,
@@ -14,11 +19,12 @@ pub const formatters = [_]*const fn (allocator: std.mem.Allocator, key: []const
     &getFormattedRamInfo,
     &getFormattedSwapInfo,
     &getFormattedDiskInfo,
+    &getFormattedNetInfo,
     &getFormattedTerminalNameInfo,
     &getFormattedLocaleInfo,
 };
 
-pub const default_formatters = [_]*const fn (allocator: std.mem.Allocator) anyerror![]u8{
+pub const default_formatters = [_]*const fn (allocator: std.mem.Allocator) anyerror!Result{
     &getDefaultFormattedOsInfo,
     &getDefaultFormattedKernelInfo,
     &getDefaultFormattedUptimeInfo,
@@ -29,141 +35,159 @@ pub const default_formatters = [_]*const fn (allocator: std.mem.Allocator) anyer
     &getDefaultFormattedRamInfo,
     &getDefaultFormattedSwapInfo,
     &getDefaultFormattedDiskInfo,
+    &getDefaultFormattedNetInfo,
     &getDefaultFormattedTerminalNameInfo,
     &getDefaultFormattedLocaleInfo,
 };
 
-pub fn getDefaultFormattedKernelInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedKernelInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedKernelInfo(allocator, "Kernel", ascii.Yellow);
 }
 
-pub fn getFormattedKernelInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedKernelInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const kernel_info = try detection.system.getKernelInfo(allocator);
     defer allocator.free(kernel_info.kernel_name);
     defer allocator.free(kernel_info.kernel_release);
 
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} {s}", .{ key_color, key, ascii.Reset, kernel_info.kernel_name, kernel_info.kernel_release });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} {s}", .{ key_color, key, ascii.Reset, kernel_info.kernel_name, kernel_info.kernel_release }) };
 }
 
-pub fn getDefaultFormattedOsInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedOsInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedOsInfo(allocator, "OS", ascii.Yellow);
 }
 
-pub fn getFormattedOsInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedOsInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const os_info = try detection.system.getOsInfo(allocator);
     defer allocator.free(os_info);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, os_info });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, os_info }) };
 }
 
-pub fn getDefaultFormattedLocaleInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedLocaleInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedLocaleInfo(allocator, "Locale", ascii.Yellow);
 }
 
-pub fn getFormattedLocaleInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedLocaleInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const locale = try detection.system.getLocale(allocator);
     defer allocator.free(locale);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, locale });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, locale }) };
 }
 
-pub fn getDefaultFormattedUptimeInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedUptimeInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedUptimeInfo(allocator, "Uptime", ascii.Yellow);
 }
 
-pub fn getFormattedUptimeInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedUptimeInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const uptime = try detection.system.getSystemUptime();
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {} days, {} hours, {} minutes ", .{ key_color, key, ascii.Reset, uptime.days, uptime.hours, uptime.minutes });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {} days, {} hours, {} minutes ", .{ key_color, key, ascii.Reset, uptime.days, uptime.hours, uptime.minutes }) };
 }
 
-pub fn getDefaultFormattedPackagesInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedPackagesInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedPackagesInfo(allocator, "Packages", ascii.Yellow);
 }
 
-pub fn getFormattedPackagesInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedPackagesInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     if (builtin.os.tag == .macos) {
         const packages_info = try detection.packages.getPackagesInfo(allocator);
         defer allocator.free(packages_info);
-        return try std.fmt.allocPrint(allocator, "{s}{s}:{s}{s}", .{ key_color, key, ascii.Reset, packages_info });
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s}{s}", .{ key_color, key, ascii.Reset, packages_info }) };
     } else if (builtin.os.tag == .linux) {
-        return try std.fmt.allocPrint(allocator, "{s}{s}:{s} WIP", .{ key_color, key, ascii.Reset });
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} WIP", .{ key_color, key, ascii.Reset }) };
     }
 }
 
-pub fn getDefaultFormattedShellInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedShellInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedShellInfo(allocator, "Shell", ascii.Yellow);
 }
 
-pub fn getFormattedShellInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedShellInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const shell = try detection.user.getShell(allocator);
     defer allocator.free(shell);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, shell[0..(shell.len - 1)] });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, shell[0..(shell.len - 1)] }) };
 }
 
-pub fn getDefaultFormattedCpuInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedCpuInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedCpuInfo(allocator, "Cpu", ascii.Yellow);
 }
 
-pub fn getFormattedCpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedCpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const cpu_info = try detection.hardware.getCpuInfo(allocator);
     defer allocator.free(cpu_info.cpu_name);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, cpu_info.cpu_name, cpu_info.cpu_cores, cpu_info.cpu_max_freq });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, cpu_info.cpu_name, cpu_info.cpu_cores, cpu_info.cpu_max_freq }) };
 }
 
-pub fn getDefaultFormattedGpuInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedGpuInfo(allocator: std.mem.Allocator) !Result {
+    if (builtin.os.tag == .macos) {
+        return try getFormattedGpuInfo(allocator, "Gpu", ascii.Yellow);
+    } else if (builtin.os.tag == .linux) {
         return try getFormattedGpuInfo(allocator, "Gpu", ascii.Yellow);
     }
-
-pub fn getFormattedGpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
-    const gpu_info = try detection.hardware.getGpuInfo(allocator);
-    defer allocator.free(gpu_info.gpu_name);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, gpu_info.gpu_name, gpu_info.gpu_cores, gpu_info.gpu_freq });
 }
 
-pub fn getDefaultFormattedRamInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getFormattedGpuInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
+    var formatted_gpu_info = std.ArrayList([]u8).init(allocator);
+
+    if (builtin.os.tag == .macos) {
+        const gpu_info = try detection.hardware.getGpuInfo(allocator);
+        defer allocator.free(gpu_info.gpu_name);
+        return try Result{ .string = std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, gpu_info.gpu_name, gpu_info.gpu_cores, gpu_info.gpu_freq }) };
+    } else if (builtin.os.tag == .linux) {
+        const gpu_info_list = try detection.hardware.getGpuInfo(allocator);
+        for (gpu_info_list.items) |g| {
+            try formatted_gpu_info.append(try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s} ({}) @ {d:.2} GHz", .{ key_color, key, ascii.Reset, g.gpu_name, g.gpu_cores, g.gpu_freq }));
+            allocator.free(g.gpu_name);
+        }
+        gpu_info_list.deinit();
+
+        return Result{ .string_arraylist = formatted_gpu_info };
+    }
+}
+
+pub fn getDefaultFormattedRamInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedRamInfo(allocator, "Ram", ascii.Yellow);
 }
 
-pub fn getFormattedRamInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedRamInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const ram_info = if (builtin.os.tag == .macos) try detection.hardware.getRamInfo() else if (builtin.os.tag == .linux) try detection.hardware.getRamInfo(allocator);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, ram_info.ram_usage, ram_info.ram_size, ram_info.ram_usage_percentage });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, ram_info.ram_usage, ram_info.ram_size, ram_info.ram_usage_percentage }) };
 }
 
-pub fn getDefaultFormattedSwapInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedSwapInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedSwapInfo(allocator, "Swap", ascii.Yellow);
 }
 
-pub fn getFormattedSwapInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedSwapInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const swap_info = if (builtin.os.tag == .macos) try detection.hardware.getSwapInfo() else if (builtin.os.tag == .linux) try detection.hardware.getSwapInfo(allocator);
     if (swap_info) |s| {
-        return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, s.swap_usage, s.swap_size, s.swap_usage_percentage });
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {d:.2} / {d:.2} GiB ({}%)", .{ key_color, key, ascii.Reset, s.swap_usage, s.swap_size, s.swap_usage_percentage }) };
     } else {
-        return try std.fmt.allocPrint(allocator, "{s}{s}:{s} Disabled", .{ key_color, key, ascii.Reset });
+        return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} Disabled", .{ key_color, key, ascii.Reset }) };
     }
 }
 
-pub fn getDefaultFormattedDiskInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedDiskInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedDiskInfo(allocator, "Disk", ascii.Yellow);
 }
 
-pub fn getFormattedDiskInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedDiskInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const disk_info = try detection.hardware.getDiskSize("/");
-    return try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {d:.2} / {d:.2} GB ({}%)", .{ key_color, key, disk_info.disk_path, ascii.Reset, disk_info.disk_usage, disk_info.disk_size, disk_info.disk_usage_percentage });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s} ({s}):{s} {d:.2} / {d:.2} GB ({}%)", .{ key_color, key, disk_info.disk_path, ascii.Reset, disk_info.disk_usage, disk_info.disk_size, disk_info.disk_usage_percentage }) };
 }
 
-pub fn getDefaultFormattedTerminalNameInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedTerminalNameInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedTerminalNameInfo(allocator, "Terminal", ascii.Yellow);
 }
 
-pub fn getFormattedTerminalNameInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) ![]u8 {
+pub fn getFormattedTerminalNameInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     const terminal_name = try detection.user.getTerminalName(allocator);
     defer allocator.free(terminal_name);
-    return try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, terminal_name });
+    return Result{ .string = try std.fmt.allocPrint(allocator, "{s}{s}:{s} {s}", .{ key_color, key, ascii.Reset, terminal_name }) };
 }
 
-pub fn getDefaultFormattedNetInfo(allocator: std.mem.Allocator) ![]u8 {
+pub fn getDefaultFormattedNetInfo(allocator: std.mem.Allocator) !Result {
     return try getFormattedNetInfo(allocator, "Local IP", ascii.Yellow);
 }
 
-pub fn getFormattedNetInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !std.ArrayList([]u8) {
+pub fn getFormattedNetInfo(allocator: std.mem.Allocator, key: []const u8, key_color: []const u8) !Result {
     var formatted_net_info_list = std.ArrayList([]u8).init(allocator);
 
     var net_info_list = try detection.network.getNetInfo(allocator);
@@ -174,5 +198,5 @@ pub fn getFormattedNetInfo(allocator: std.mem.Allocator, key: []const u8, key_co
     }
     net_info_list.deinit();
 
-    return formatted_net_info_list;
+    return Result{ .string_arraylist = formatted_net_info_list };
 }

src/main.zig

@@ -43,8 +43,15 @@ pub fn main() !void {
     try sys_info_list.append(separtor_buffer);
 
     if (modules_types.items.len == 0) {
-        inline for (0..formatters.formatters.len) |i| {
+        inline for (0..formatters.default_formatters.len) |i| {
-            try sys_info_list.append(try formatters.default_formatters[i](allocator));
+            const result = try formatters.default_formatters[i](allocator);
+            switch (result) {
+                .string => |r| try sys_info_list.append(r),
+                .string_arraylist => |r| {
+                    defer r.deinit();
+                    try sys_info_list.appendSlice(r.items);
+                },
+            }
         }
     } else if (conf) |c| {
         for (modules_types.items, c.value.modules) |module_type, module| {
@@ -52,16 +59,14 @@ pub fn main() !void {
             const rgb = try ascii.hexColorToRgb(module.key_color);
             const key_color = try std.fmt.bufPrint(&buf, "\x1b[38;2;{d};{d};{d}m", .{ rgb.r, rgb.g, rgb.b });
 
-            if (module_type == config.ModuleType.net) {
+            const result = try formatters.formatters[@intFromEnum(module_type)](allocator, module.key, key_color);
-                var formatted_net_info_list = try formatters.getFormattedNetInfo(allocator, module.key, key_color);
+            switch (result) {
-                defer formatted_net_info_list.deinit();
+                .string => |r| try sys_info_list.append(r),
-
+                .string_arraylist => |r| {
-                try sys_info_list.appendSlice(formatted_net_info_list.items);
+                    defer r.deinit();
-
+                    try sys_info_list.appendSlice(r.items);
-                continue;
+                },
             }
-
-            try sys_info_list.append(try formatters.formatters[@intFromEnum(module_type)](allocator, module.key, key_color));
         }
     }