lib/tracy/src/cli/args/source.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.SourceArgs {
  7     if (args.len == 0) return error.InvalidArguments;
  8     var parsed = types.SourceArgs{ .path = args[0] };
  9     var index: usize = 1;
 10     while (index < args.len) : (index += 1) {
 11         if (std.mem.eql(u8, args[index], "--format")) {
 12             index += 1;
 13             if (index >= args.len) return error.InvalidArguments;
 14             if (std.mem.eql(u8, args[index], "text")) {
 15                 parsed.format = .text;
 16             } else if (std.mem.eql(u8, args[index], "jsonl")) {
 17                 parsed.format = .jsonl;
 18             } else {
 19                 return error.UnsupportedFormat;
 20             }
 21         } else if (std.mem.eql(u8, args[index], "--top")) {
 22             index += 1;
 23             if (index >= args.len) return error.InvalidArguments;
 24             parsed.options.top = try scalar.parsePositiveUsize(args[index]);
 25         } else if (std.mem.eql(u8, args[index], "--sort")) {
 26             index += 1;
 27             if (index >= args.len) return error.InvalidArguments;
 28             parsed.options.sort = tracy.source.Sort.fromName(args[index]) orelse return error.UnsupportedSort;
 29         } else if (std.mem.eql(u8, args[index], "--min-total-ns")) {
 30             index += 1;
 31             if (index >= args.len) return error.InvalidArguments;
 32             parsed.options.min_total_ns = try scalar.parseU64(args[index]);
 33         } else if (std.mem.eql(u8, args[index], "--min-self-ns")) {
 34             index += 1;
 35             if (index >= args.len) return error.InvalidArguments;
 36             parsed.options.min_self_ns = try scalar.parseU64(args[index]);
 37         } else if (std.mem.eql(u8, args[index], "--thread")) {
 38             index += 1;
 39             if (index >= args.len) return error.InvalidArguments;
 40             parsed.options.thread = try scalar.parseU64(args[index]);
 41         } else if (std.mem.eql(u8, args[index], "--match")) {
 42             index += 1;
 43             if (index >= args.len) return error.InvalidArguments;
 44             parsed.options.match = args[index];
 45         } else if (std.mem.eql(u8, args[index], "--root")) {
 46             index += 1;
 47             if (index >= args.len) return error.InvalidArguments;
 48             parsed.options.root = args[index];
 49         } else if (std.mem.eql(u8, args[index], "--context")) {
 50             index += 1;
 51             if (index >= args.len) return error.InvalidArguments;
 52             parsed.options.context = try scalar.parseUsize(args[index]);
 53         } else if (std.mem.eql(u8, args[index], "--context-back")) {
 54             index += 1;
 55             if (index >= args.len) return error.InvalidArguments;
 56             parsed.options.context_back = try scalar.parseUsize(args[index]);
 57         } else if (std.mem.eql(u8, args[index], "--ignore-case")) {
 58             parsed.options.ignore_case = true;
 59         } else {
 60             return error.UnknownArgument;
 61         }
 62     }
 63     return parsed;
 64 }
 65 
 66 test "source args parse filters and local context" {
 67     const parsed = try parse(&.{
 68         "events.jsonl",
 69         "--format",
 70         "jsonl",
 71         "--top",
 72         "12",
 73         "--sort",
 74         "file",
 75         "--min-total-ns",
 76         "100",
 77         "--min-self-ns",
 78         "20",
 79         "--thread",
 80         "7",
 81         "--match",
 82         "parse",
 83         "--root",
 84         "/tmp/project",
 85         "--context",
 86         "4",
 87         "--context-back",
 88         "1",
 89         "--ignore-case",
 90     });
 91     try std.testing.expectEqualStrings("events.jsonl", parsed.path);
 92     try std.testing.expectEqual(types.Format.jsonl, parsed.format);
 93     try std.testing.expectEqual(@as(usize, 12), parsed.options.top);
 94     try std.testing.expectEqual(tracy.source.Sort.file, parsed.options.sort);
 95     try std.testing.expectEqual(@as(u64, 100), parsed.options.min_total_ns);
 96     try std.testing.expectEqual(@as(u64, 20), parsed.options.min_self_ns);
 97     try std.testing.expectEqual(@as(?u64, 7), parsed.options.thread);
 98     try std.testing.expectEqualStrings("parse", parsed.options.match.?);
 99     try std.testing.expectEqualStrings("/tmp/project", parsed.options.root.?);
100     try std.testing.expectEqual(@as(usize, 4), parsed.options.context);
101     try std.testing.expectEqual(@as(usize, 1), parsed.options.context_back);
102     try std.testing.expect(parsed.options.ignore_case);
103 }