lens

main.zig (8772B)

---

 const std = @import("std");
 const builtin = @import("builtin");
 
 const options = @import("options");
 const ziggy = @import("ziggy");
 
 const environment = @import("environment.zig");
 const stats = @import("stats.zig");
 const sys_info = @import("sys_info.zig");
 
 const padding: u8 = 9;
 
 const Widgets = enum {
     distro,
     uptime,
     kernel,
     desktop,
     shell,
     memory,
     battery,
     cpu,
     disk,
 };
 
 const Config = struct {
     widgets: []const Widgets,
 };
 
 const Options = struct {
     help: bool = false,
     version: bool = false,
 
     fn optKind(a: []const u8) enum { short, long, positional } {
         if (std.mem.startsWith(u8, a, "--")) return .long;
         if (std.mem.startsWith(u8, a, "-")) return .short;
         return .positional;
     }
 };
 
 const CONFIG_NAME = "config.ziggy";
 const HOME_DIR_NAME = ".lens";
 const XDG_CONFIG_HOME_DIR_NAME = "lens";
 const default_config = Config{
     .widgets = &[_]Widgets{
         .distro,
         .uptime,
         .kernel,
         .desktop,
         .shell,
         .memory,
         .battery,
         .cpu,
         .disk,
     },
 };
 const help_menu =
     \\Usage: lens
     \\
     \\a minimal posix system fetch tool
     \\
     \\Flags:
     \\  -h, --help                     Show help information and exit.
     \\  -v, --version                  Print version information and exit.
     \\
 ;
 
 pub fn main(init: std.process.Init) !void {
     const gpa = init.gpa;
     const io = init.io;
 
     var stdout_buffer: [1024]u8 = undefined;
     var stdout_file_writer: std.Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
     const stdout_writer = &stdout_file_writer.interface;
 
     var opts = Options{};
     var args = init.minimal.args.iterate();
     _ = args.skip();
     while (args.next()) |arg| {
         switch (Options.optKind(arg)) {
             .short => {
                 const str = arg[1..];
                 for (str) |b| {
                     switch (b) {
                         'v' => opts.version = true,
                         'h' => opts.help = true,
                         else => {
                             std.log.err("Invalid option: '{c}'", .{b});
                             std.process.exit(1);
                         },
                     }
                 }
             },
             .long => {
                 var split = std.mem.splitScalar(u8, arg[2..], '=');
                 const opt = split.first();
                 if (std.mem.eql(u8, opt, "version")) {
                     opts.version = true;
                 } else if (std.mem.eql(u8, opt, "help")) {
                     opts.help = true;
                 }
             },
             .positional => {
                 std.log.err("Invalid opt: '{s}'. lens does not take positional arguments.", .{arg});
                 std.process.exit(1);
             },
         }
     }
 
     if (opts.help) {
         try stdout_writer.writeAll(help_menu);
         try stdout_writer.flush();
         return;
     }
 
     if (opts.version) {
         try stdout_writer.print("lens v{f}\n", .{options.version});
         try stdout_writer.flush();
         return;
     }
 
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer _ = arena.deinit();
     var allocator = arena.allocator();
 
     // Read config
     const config = lbl: {
         var config_dir = dir: {
             var dir_env: struct { dir: std.Io.Dir, name: []const u8 } = env: {
                 if (try environment.getXdgConfigHomeDir(io, init.environ_map)) |home_dir| {
                     break :env .{ .dir = home_dir, .name = XDG_CONFIG_HOME_DIR_NAME };
                 }
 
                 if (try environment.getHomeDir(io, init.environ_map)) |home_dir| {
                     break :env .{ .dir = home_dir, .name = HOME_DIR_NAME };
                 }
 
                 break :lbl default_config;
             };
             defer dir_env.dir.close(io);
 
             if (!environment.dirExists(dir_env.dir, io, dir_env.name)) {
                 break :lbl default_config;
             }
 
             const dir = try dir_env.dir.openDir(io, dir_env.name, .{ .iterate = true });
             if (!environment.fileExists(dir, io, CONFIG_NAME)) {
                 break :lbl default_config;
             }
 
             break :dir dir;
         };
 
         const contents = config_dir.readFileAlloc(io, CONFIG_NAME, allocator, .limited(4096)) catch break :lbl default_config;
         defer allocator.free(contents);
         const contentsZ = try allocator.dupeZ(u8, contents);
         defer allocator.free(contentsZ);
 
         var meta: ziggy.Deserializer.Meta = undefined;
         break :lbl ziggy.deserializeLeaky(Config, allocator, contentsZ, &meta, .{}) catch default_config;
     };
 
     // Print header
     const user_env = try sys_info.getUser(allocator, init.environ_map);
     defer allocator.free(user_env);
     const distro_id = try sys_info.getDistroId(io, allocator);
     defer allocator.free(distro_id);
 
     var header_buf: [1024]u8 = undefined;
     const header = try std.fmt.bufPrint(&header_buf, "{s}@{s}\n", .{ user_env, distro_id });
 
     try stdout_writer.writeAll(header);
     try stdout_writer.print("{[str]s:-<[count]}\n", .{ .str = "-", .count = header.len + 1 });
 
     // Print widgets
     for (config.widgets) |widget| {
         switch (widget) {
             .distro => {
                 const distro = sys_info.getDistro(io, allocator) catch continue;
                 defer allocator.free(distro);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "distro", .stat = distro, .padding = padding },
                 );
             },
             .uptime => {
                 const uptime = stats.getUptime() catch continue;
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[days]d}d {[hours]d}h {[minutes]d}m\n",
                     .{
                         .header = "uptime",
                         .days = uptime.days,
                         .hours = uptime.hours,
                         .minutes = uptime.minutes,
                         .padding = padding,
                     },
                 );
             },
             .kernel => {
                 const utsname = std.posix.uname();
                 const release = std.mem.sliceTo(&utsname.release, 0);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "kernel", .stat = release, .padding = padding },
                 );
             },
             .desktop => {
                 const desktop = try sys_info.getDesktop(allocator, init.environ_map);
                 defer allocator.free(desktop);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "desktop", .stat = desktop, .padding = padding },
                 );
             },
             .shell => {
                 const shell = sys_info.getShell(io, allocator, init.environ_map) catch continue;
                 defer allocator.free(shell);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "shell", .stat = shell, .padding = padding },
                 );
             },
             .memory => {
                 const mem = stats.getMemory(io, allocator, .{ .mb = true }) catch continue;
                 defer allocator.free(mem);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "memory", .stat = mem, .padding = padding },
                 );
             },
             .battery => {
                 const battery = stats.getBattery(io, allocator) catch continue;
                 defer allocator.free(battery);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "battery", .stat = battery, .padding = padding },
                 );
             },
             .cpu => {
                 const cpu = sys_info.getCpu(io, allocator) catch continue;
                 defer allocator.free(cpu);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "cpu", .stat = cpu, .padding = padding },
                 );
             },
             .disk => {
                 const disk = sys_info.getDisk(io, allocator) catch continue;
                 defer allocator.free(disk);
 
                 try stdout_writer.print(
                     "{[header]s: <[padding]}{[stat]s}\n",
                     .{ .header = "disk", .stat = disk, .padding = padding },
                 );
             },
         }
     }
 
     try stdout_writer.flush();
 }