-- Leo's gemini proxy
-- Connecting to git.thebackupbox.net:1965...
-- Connected
-- Sending request
-- Meta line: 20 text/gemini
repo: hackvr-turbo action: commit revision: path_from: revision_from: e51ab0742d28ed52f5a8716f4bf5f38c8371b7f5: path_to: revision_to:
commit e51ab0742d28ed52f5a8716f4bf5f38c8371b7f5
Author: Felix (xq) Queißner <git@mq32.de>
Date: Thu Jun 25 20:24:47 2020 +0200
More event parsing.
diff --git a/lib/hackvr/parser.zig b/lib/hackvr/parser.zig
--- a/lib/hackvr/parser.zig
+++ b/lib/hackvr/parser.zig
@@ -49,21 +49,91 @@ pub const Parser = struct {
0 => return null,
1 => {
if (std.mem.eql(u8, "help", items.buffer[0])) {
- return Event{
- .event_type = .help,
- };
+ return Event{ .help = {} };
} else if (std.mem.eql(u8, "version", items.buffer[0])) {
- return Event{
- .event_type = .version,
- };
+ return Event{ .version = {} };
} else {
return error.UnknownCommand;
}
},
else => {
- return Event{
- .event_type = .not_implemented_yet,
+ const selector = Selector{
+ .groups = items.buffer[0],
};
+ const cmd = items.buffer[1];
+ const args = items.span()[2..];
+
+ if (std.mem.eql(u8, cmd, "status")) {
+ return Event{ .status = selector };
+ } else if (std.mem.eql(u8, cmd, "dump")) {
+ return Event{ .dump = selector };
+ } else if (std.mem.eql(u8, cmd, "quit")) {
+ return Event{ .quit = selector };
+ } else if (std.mem.eql(u8, cmd, "set")) {
+ return Event{ .set = selector };
+ } else if (std.mem.eql(u8, cmd, "physics")) {
+ return Event{ .physics = selector };
+ } else if (std.mem.eql(u8, cmd, "periodic")) {
+ return Event{ .periodic = selector };
+ } else if (std.mem.eql(u8, cmd, "flatten")) {
+ return Event{ .flatten = selector };
+ } else if (std.mem.eql(u8, cmd, "deleteallexcept")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .delete_all_except = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ } else if (std.mem.eql(u8, cmd, "deletegroup")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .delete_group = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ } else if (std.mem.eql(u8, cmd, "assimilate")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .assimilate = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ } else if (std.mem.eql(u8, cmd, "renamegroup")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .rename_group = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ } else if (std.mem.eql(u8, cmd, "export")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .@"export" = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ } else if (std.mem.eql(u8, cmd, "control")) {
+ if (args.len != 1)
+ return error.ArgumentMismatch;
+ return Event{
+ .control = GroupArgSelector{
+ .selector = selector,
+ .groups = args[0],
+ },
+ };
+ }
+
+ return error.UnknownCommand;
},
}
}
@@ -156,15 +226,59 @@ pub const PushResult = union(enum) {
},
};
-pub const Event = struct {
- const Type = enum {
- help,
- version,
+pub const EventType = enum {
+ help,
+ version,
+ status,
+ dump,
+ quit,
+ set,
+ physics,
+ control,
+ addshape,
+ @"export",
+ ping,
+ scale,
+ rotate,
+ periodic,
+ flatten,
+ move,
+ delete_group,
+ assimilate,
+ rename_group,
+ delete_all_except,
+};
- not_implemented_yet,
- };
+pub const Selector = struct {
+ groups: []const u8,
+};
+
+pub const GroupArgSelector = struct {
+ selector: Selector,
+ groups: []const u8,
+};
- event_type: Type,
+pub const Event = union(EventType) {
+ delete_group: GroupArgSelector,
+ assimilate: GroupArgSelector,
+ rename_group: GroupArgSelector,
+ delete_all_except: GroupArgSelector,
+ help,
+ version,
+ status: Selector,
+ dump: Selector,
+ quit: Selector,
+ set: Selector,
+ physics: Selector,
+ control: GroupArgSelector,
+ addshape,
+ @"export": GroupArgSelector,
+ ping,
+ scale,
+ rotate,
+ periodic: Selector,
+ flatten: Selector,
+ move,
};
test "parser: invalid encoding" {
@@ -209,15 +323,109 @@ test "parser: ParseResult.rest/event" {
}
test "parser: parse line" {
- _ = try Parser.parseLine(" a bb cccc ");
+ _ = Parser.parseLine(" a bb cccc ") catch |err| {
+ std.testing.expect(err == error.UnknownCommand);
+ return;
+ };
+ unreachable;
}
test "parser: cmd help" {
const result = (try Parser.parseLine("help")) orelse return error.ExpectedEvent;
- std.testing.expect(result.event_type == .help);
+ std.testing.expect(result == .help);
}
test "parser: cmd version" {
const result = (try Parser.parseLine("version")) orelse return error.ExpectedEvent;
- std.testing.expect(result.event_type == .version);
+ std.testing.expect(result == .version);
+}
+
+test "parser: cmd status" {
+ const result = (try Parser.parseLine("foobar status")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .status);
+ std.testing.expectEqualStrings("foobar", result.status.groups);
+}
+
+test "parser: cmd dump" {
+ const result = (try Parser.parseLine("foobar dump")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .dump);
+ std.testing.expectEqualStrings("foobar", result.dump.groups);
+}
+
+test "parser: cmd quit" {
+ const result = (try Parser.parseLine("foobar quit")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .quit);
+ std.testing.expectEqualStrings("foobar", result.quit.groups);
+}
+
+test "parser: cmd set" {
+ const result = (try Parser.parseLine("foobar set")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .set);
+ std.testing.expectEqualStrings("foobar", result.set.groups);
+}
+
+test "parser: cmd physics" {
+ const result = (try Parser.parseLine("foobar physics")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .physics);
+ std.testing.expectEqualStrings("foobar", result.physics.groups);
+}
+
+test "parser: cmd periodic" {
+ const result = (try Parser.parseLine("foobar periodic")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .periodic);
+ std.testing.expectEqualStrings("foobar", result.periodic.groups);
+}
+
+test "parser: cmd flatten" {
+ const result = (try Parser.parseLine("foobar flatten")) orelse return error.ExpectedEvent;
+ std.testing.expect(result == .flatten);
+ std.testing.expectEqualStrings("foobar", result.flatten.groups);
+}
+
+test "parser: cmd deleteallexcept" {
+ const result = (try Parser.parseLine("foobar deleteallexcept groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .delete_all_except);
+ std.testing.expectEqualStrings("foobar", result.delete_all_except.selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.delete_all_except.groups);
+}
+
+test "parser: cmd delete_group" {
+ const result = (try Parser.parseLine("foobar deletegroup groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .delete_group);
+ std.testing.expectEqualStrings("foobar", result.delete_group.selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.delete_group.groups);
+}
+
+test "parser: cmd delete_group" {
+ const result = (try Parser.parseLine("foobar renamegroup groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .rename_group);
+ std.testing.expectEqualStrings("foobar", result.rename_group.selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.rename_group.groups);
+}
+
+test "parser: cmd delete_group" {
+ const result = (try Parser.parseLine("foobar assimilate groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .assimilate);
+ std.testing.expectEqualStrings("foobar", result.assimilate.selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.assimilate.groups);
+}
+
+test "parser: cmd control" {
+ const result = (try Parser.parseLine("foobar control groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .control);
+ std.testing.expectEqualStrings("foobar", result.control.selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.control.groups);
+}
+
+test "parser: cmd export" {
+ const result = (try Parser.parseLine("foobar export groupsel")) orelse return error.ExpectedEvent;
+
+ std.testing.expect(result == .@"export");
+ std.testing.expectEqualStrings("foobar", result.@"export".selector.groups);
+ std.testing.expectEqualStrings("groupsel", result.@"export".groups);
}
-----END OF PAGE-----
-- Response ended
-- Page fetched on Sun Jun 2 18:30:54 2024