lib/tracy/src/cli/args/timeline.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

  1 const std = @import("std");
  2 const tracy = @import("../../root.zig");
  3 const scalar = @import("scalar.zig");
  4 const types = @import("types.zig");
  5 
  6 pub fn parse(args: []const []const u8) !types.TimelineArgs {
  7     if (args.len == 0) return error.InvalidArguments;
  8     var parsed = types.TimelineArgs{ .path = args[0] };
  9     var around_ns: ?u64 = null;
 10     var window_ns: ?u64 = null;
 11     var index: usize = 1;
 12     while (index < args.len) : (index += 1) {
 13         if (std.mem.eql(u8, args[index], "--format")) {
 14             index += 1;
 15             if (index >= args.len) return error.InvalidArguments;
 16             if (std.mem.eql(u8, args[index], "text")) {
 17                 parsed.format = .text;
 18             } else if (std.mem.eql(u8, args[index], "jsonl")) {
 19                 parsed.format = .jsonl;
 20             } else {
 21                 return error.UnsupportedFormat;
 22             }
 23         } else if (std.mem.eql(u8, args[index], "--top")) {
 24             index += 1;
 25             if (index >= args.len) return error.InvalidArguments;
 26             parsed.options.top = try scalar.parsePositiveUsize(args[index]);
 27         } else if (std.mem.eql(u8, args[index], "--kind")) {
 28             index += 1;
 29             if (index >= args.len) return error.InvalidArguments;
 30             parsed.options.kind = tracy.timeline.Kind.fromName(args[index]) orelse return error.UnsupportedKind;
 31         } else if (std.mem.eql(u8, args[index], "--sort")) {
 32             index += 1;
 33             if (index >= args.len) return error.InvalidArguments;
 34             parsed.options.sort = tracy.timeline.Sort.fromName(args[index]) orelse return error.UnsupportedSort;
 35         } else if (std.mem.eql(u8, args[index], "--thread")) {
 36             index += 1;
 37             if (index >= args.len) return error.InvalidArguments;
 38             parsed.options.thread = try scalar.parseU64(args[index]);
 39         } else if (std.mem.eql(u8, args[index], "--since-ns")) {
 40             index += 1;
 41             if (index >= args.len) return error.InvalidArguments;
 42             parsed.options.since_ns = try scalar.parseU64(args[index]);
 43         } else if (std.mem.eql(u8, args[index], "--until-ns")) {
 44             index += 1;
 45             if (index >= args.len) return error.InvalidArguments;
 46             parsed.options.until_ns = try scalar.parseU64(args[index]);
 47         } else if (std.mem.eql(u8, args[index], "--around-ns")) {
 48             index += 1;
 49             if (index >= args.len) return error.InvalidArguments;
 50             around_ns = try scalar.parseU64(args[index]);
 51         } else if (std.mem.eql(u8, args[index], "--window-ns")) {
 52             index += 1;
 53             if (index >= args.len) return error.InvalidArguments;
 54             window_ns = try scalar.parseU64(args[index]);
 55         } else if (std.mem.eql(u8, args[index], "--min-duration-ns")) {
 56             index += 1;
 57             if (index >= args.len) return error.InvalidArguments;
 58             parsed.options.min_duration_ns = try scalar.parseU64(args[index]);
 59         } else if (std.mem.eql(u8, args[index], "--match")) {
 60             index += 1;
 61             if (index >= args.len) return error.InvalidArguments;
 62             parsed.options.match = args[index];
 63         } else {
 64             return error.UnknownArgument;
 65         }
 66     }
 67     if (around_ns) |center| {
 68         if (parsed.options.since_ns != null or parsed.options.until_ns != null) return error.InvalidArguments;
 69         const width = window_ns orelse 1_000_000;
 70         const half = width / 2;
 71         parsed.options.since_ns = if (center > half) center - half else 0;
 72         parsed.options.until_ns = center +| (width - half);
 73     } else if (window_ns != null) {
 74         return error.InvalidArguments;
 75     }
 76     if (parsed.options.since_ns != null and parsed.options.until_ns != null and parsed.options.since_ns.? > parsed.options.until_ns.?) {
 77         return error.InvalidArguments;
 78     }
 79     return parsed;
 80 }
 81 
 82 test "timeline args parse filters window and format" {
 83     const parsed = try parse(&.{
 84         "events.jsonl",
 85         "--format",
 86         "jsonl",
 87         "--top",
 88         "12",
 89         "--kind",
 90         "zone",
 91         "--sort",
 92         "duration",
 93         "--thread",
 94         "7",
 95         "--around-ns",
 96         "1000",
 97         "--window-ns",
 98         "200",
 99         "--min-duration-ns",
100         "50",
101         "--match",
102         "phase",
103     });
104     try std.testing.expectEqualStrings("events.jsonl", parsed.path);
105     try std.testing.expectEqual(types.Format.jsonl, parsed.format);
106     try std.testing.expectEqual(@as(usize, 12), parsed.options.top);
107     try std.testing.expectEqual(tracy.timeline.Kind.zone, parsed.options.kind);
108     try std.testing.expectEqual(tracy.timeline.Sort.duration, parsed.options.sort);
109     try std.testing.expectEqual(@as(?u64, 7), parsed.options.thread);
110     try std.testing.expectEqual(@as(?u64, 900), parsed.options.since_ns);
111     try std.testing.expectEqual(@as(?u64, 1100), parsed.options.until_ns);
112     try std.testing.expectEqual(@as(u64, 50), parsed.options.min_duration_ns);
113     try std.testing.expectEqualStrings("phase", parsed.options.match.?);
114 }