Gnyblast / tase / #24

Committed 31 Dec 2025 02:39PM UTC coverage: 76.798% (-0.9%) from 77.692%

Build # #24

Build Type

push

Committed by

Commit Message

Update readme and adding version print argument

Run Details

0 of 14 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

801 of 1043 relevant lines covered (76.8%)

1.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main.zig

const std = @import("std");
const argsParser = @import("args");
const timezones = @import("datetime").timezones;

const configs = @import("./app/config.zig");
const utils = @import("./utils/helper.zig");
const app = @import("./app/tase.zig");
const logger = @import("./utils/logger.zig");

const Allocator = std.mem.Allocator;

pub const std_options: std.Options = .{ .logFn = logFn, .log_level = .debug };

var log_level = std.log.default_level;
pub var log_path: []const u8 = ""; //? The logic for default log dir is in logger.zig getLogFilePath()
pub var is_agent: bool = false;
pub var timezone: []const u8 = "UTC";

fn logFn(
    comptime message_level: std.log.Level,
    comptime scope: @TypeOf(.enum_literal),
    comptime format: []const u8,
    args: anytype,
) void {
    if (@intFromEnum(message_level) <= @intFromEnum(log_level)) {
        const tz = timezones.getByName(timezone) catch timezones.UTC;
        logger.log(
            message_level,
            scope,
            format,
            log_path,
            is_agent,
            args,
            tz,
            log_level,
        );
    }
}

pub fn main() void {
    var da: std.heap.DebugAllocator(.{}) = .init;
    defer {
        const leaks = da.deinit();
        std.debug.assert(leaks == .ok);
    }

    const allocator = da.allocator();
    const cli_args = parseCLIOrExit(allocator);
    defer cli_args.deinit();

    var tase = app.Tase.init(allocator, &cli_args.options) catch |err| {
        return utils.printErrorExit(allocator, err, cli_args.options, .yaml, "Could not create application: {s}");
    };
    defer tase.deinit();
    timezone = tase.yaml_cfg.server.time_zone.?;

    tase.run() catch |err| {
        return utils.printErrorExit(allocator, err, tase.cli_args.*, .default, "Could not start application: {s}");
    };
}

fn parseCLIOrExit(allocator: Allocator) argsParser.ParseArgsResult(configs.argOpts, null) {
    const cli_args = argsParser.parseForCurrentProcess(configs.argOpts, allocator, .print) catch |err| {
        std.debug.print("Error parsing CLI arguments: {any}", .{err});
        std.process.exit(1);
    };
    //? Do not log anything into std.log before below lines.
    log_level = cli_args.options.@"log-level";
    log_path = cli_args.options.@"log-dir";
    is_agent = cli_args.options.agent;

    if (cli_args.options.version) {
        var stdout_buffer: [1024]u8 = undefined;
        var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
        const stdout = &stdout_writer.interface;
        stdout.print("Tase Version: v{s}\n", .{app.VERSION}) catch |err| {
            std.log.err("Could not print help: {any}", .{err});
        };
        stdout.flush() catch |err| {
            std.log.err("Could not print help: {any}", .{err});
        };

        std.process.exit(0);
    }

    if (cli_args.options.help) {
        var stdout_buffer: [1024]u8 = undefined;
        var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
        const stdout = &stdout_writer.interface;
        argsParser.printHelp(configs.argOpts, "Tase", stdout) catch |err| {
            std.log.err("Could not print help: {any}", .{err});
        };
        stdout.flush() catch |err| {
            std.log.err("Could not print help: {any}", .{err});
        };
        std.process.exit(0);
    }

    std.log.debug("parsed options:", .{});
    inline for (std.meta.fields(@TypeOf(cli_args.options))) |fld| {
        std.log.debug("\t\t{s} = {any}", .{
            fld.name,
            @field(cli_args.options, fld.name),
        });
    }

    return cli_args;
}

1	const std = @import("std");
2	const argsParser = @import("args");
3	const timezones = @import("datetime").timezones;
4
5	const configs = @import("./app/config.zig");
6	const utils = @import("./utils/helper.zig");
7	const app = @import("./app/tase.zig");
8	const logger = @import("./utils/logger.zig");
9
10	const Allocator = std.mem.Allocator;
11
12	pub const std_options: std.Options = .{ .logFn = logFn, .log_level = .debug };
13
14	var log_level = std.log.default_level;
15	pub var log_path: []const u8 = ""; //? The logic for default log dir is in logger.zig getLogFilePath()
16	pub var is_agent: bool = false;
17	pub var timezone: []const u8 = "UTC";
18
19	fn logFn(
20	comptime message_level: std.log.Level,
21	comptime scope: @TypeOf(.enum_literal),
22	comptime format: []const u8,
23	args: anytype,
24	) void {
25	if (@intFromEnum(message_level) <= @intFromEnum(log_level)) {
26	const tz = timezones.getByName(timezone) catch timezones.UTC;
27	logger.log(
28	message_level,
29	scope,
30	format,
31	log_path,
32	is_agent,
33	args,
34	tz,
35	log_level,
36	);
37	}
38	}
39
40	pub fn main() void {	×
41	var da: std.heap.DebugAllocator(.{}) = .init;	×
42	defer {
43	const leaks = da.deinit();	×
44	std.debug.assert(leaks == .ok);	×
45	}
46
47	const allocator = da.allocator();	×
48	const cli_args = parseCLIOrExit(allocator);	×
49	defer cli_args.deinit();	×
50
51	var tase = app.Tase.init(allocator, &cli_args.options) catch \|err\| {	×
52	return utils.printErrorExit(allocator, err, cli_args.options, .yaml, "Could not create application: {s}");	×
53	};
54	defer tase.deinit();	×
55	timezone = tase.yaml_cfg.server.time_zone.?;	×
56
57	tase.run() catch \|err\| {	×
58	return utils.printErrorExit(allocator, err, tase.cli_args.*, .default, "Could not start application: {s}");	×
59	};
60	}
61
62	fn parseCLIOrExit(allocator: Allocator) argsParser.ParseArgsResult(configs.argOpts, null) {	×
63	const cli_args = argsParser.parseForCurrentProcess(configs.argOpts, allocator, .print) catch \|err\| {	×
64	std.debug.print("Error parsing CLI arguments: {any}", .{err});	×
65	std.process.exit(1);	×
66	};
67	//? Do not log anything into std.log before below lines.
68	log_level = cli_args.options.@"log-level";	×
69	log_path = cli_args.options.@"log-dir";	×
70	is_agent = cli_args.options.agent;	×
71
NEW 72	if (cli_args.options.version) {	×
NEW 73	var stdout_buffer: [1024]u8 = undefined;	×
NEW 74	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);	×
NEW 75	const stdout = &stdout_writer.interface;	×
NEW 76	stdout.print("Tase Version: v{s}\n", .{app.VERSION}) catch \|err\| {	×
NEW 77	std.log.err("Could not print help: {any}", .{err});	×
78	};
NEW 79	stdout.flush() catch \|err\| {	×
NEW 80	std.log.err("Could not print help: {any}", .{err});	×
81	};
82
NEW 83	std.process.exit(0);	×
84	}
85
86	if (cli_args.options.help) {	×
87	var stdout_buffer: [1024]u8 = undefined;	×
NEW 88	var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);	×
NEW 89	const stdout = &stdout_writer.interface;	×
NEW 90	argsParser.printHelp(configs.argOpts, "Tase", stdout) catch \|err\| {	×
NEW 91	std.log.err("Could not print help: {any}", .{err});	×
92	};
NEW 93	stdout.flush() catch \|err\| {	×
UNCOV 94	std.log.err("Could not print help: {any}", .{err});	×
95	};
96	std.process.exit(0);	×
97	}
98
99	std.log.debug("parsed options:", .{});	×
100	inline for (std.meta.fields(@TypeOf(cli_args.options))) \|fld\| {
101	std.log.debug("\t\t{s} = {any}", .{	×
102	fld.name,
103	@field(cli_args.options, fld.name),	×
104	});
105	}
106
107	return cli_args;	×
108	}

Gnyblast / tase / #24

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous