chore: trying to get to the bottom of an issue

Author: deevus

src/Document.zig

@@ -9,22 +9,27 @@ root: Node = .{
     .value = .document,
 },
 
+pub const Options = struct {
+    tokenizer_options: ?tokenizer.Options = null,
+    parser_options: ?parser.Options = null,
+};
+
 /// Parses BBCode text and builds the internal tree structure.
 ///
 /// Takes a BBCode string and parses it into a tree of nodes
 /// that can be traversed using the document's methods or Walker.
 ///
 /// Args:
 ///   bbcode: BBCode string to parse
-pub fn load(allocator: Allocator, reader: std.io.AnyReader) !Document {
-    var tokens = try tokenizer.tokenize(allocator, reader);
+pub fn load(allocator: Allocator, reader: std.io.AnyReader, options: Options) !Document {
+    var tokens = try tokenizer.tokenize(allocator, reader, options.tokenizer_options orelse .{});
     defer tokens.deinit(allocator);
-    return try parser.parse(allocator, tokens);
+    return try parser.parse(allocator, tokens, options.parser_options orelse .{});
 }
 
-pub fn loadFromBuffer(allocator: Allocator, bbcode: []const u8) !Document {
+pub fn loadFromBuffer(allocator: Allocator, bbcode: []const u8, options: Options) !Document {
     var fbs = std.io.fixedBufferStream(bbcode);
-    return try load(allocator, fbs.reader().any());
+    return try load(allocator, fbs.reader().any(), options);
 }
 
 /// Frees resources associated with the document.

src/Node.zig

@@ -59,7 +59,7 @@ pub fn getName(self: Node) ![]const u8 {
     switch (self.value) {
         .element => |v| return v.name,
         .text => |v| return v,
-        else => return error.InvalidNodeType,
+        .document => return "document",
     }
 }
 

src/formatters/markdown.zig

@@ -184,7 +184,7 @@ test render {
         \\[list][*]one[*]two[*]three[/list]
     ;
 
-    var document = try Document.loadFromBuffer(testing.allocator, bbcode_document);
+    var document = try Document.loadFromBuffer(testing.allocator, bbcode_document, .{});
     defer document.deinit();
 
     var out_buffer = std.ArrayListUnmanaged(u8){};

src/parser.zig

@@ -1,4 +1,8 @@
-pub fn parse(allocator: std.mem.Allocator, tokens: TokenResult) !Document {
+pub const Options = struct {};
+
+pub fn parse(allocator: std.mem.Allocator, tokens: TokenResult, options: Options) !Document {
+    _ = options;
+
     var doc = Document{
         .arena = std.heap.ArenaAllocator.init(allocator),
     };
@@ -41,13 +45,19 @@ pub fn parse(allocator: std.mem.Allocator, tokens: TokenResult) !Document {
             },
             .closingElement => {
                 const item = stack.getLastOrNull() orelse {
+                    logger.err("Tried to pop from an empty stack.\nDocument: {s}\nCurrent: {s}\nToken: {s} {s}\nInput: {s}", .{ doc, try current.getName(), token.name, token.value orelse "", tokens });
                     return error.UnexpectedClosingElement;
                 };
 
                 if (std.mem.eql(u8, item, try current.getName())) {
                     _ = stack.pop();
                     current = current.parent orelse break;
                 } else {
+                    logger.err("Unexpected closing element in document.\nDocument: {s}\nCurrent: {s}\nExpected: {s}", .{
+                        doc,
+                        try current.getName(),
+                        item,
+                    });
                     return error.UnexpectedClosingElement;
                 }
             },
@@ -81,9 +91,46 @@ pub fn parse(allocator: std.mem.Allocator, tokens: TokenResult) !Document {
 //     }
 // }
 
+test "complex parsing" {
+    const bbcode =
+        \\Converts one or more arguments of any type to string in the best way possible and prints them to the console.
+        \\The following BBCode tags are supported: [code]b[/code], [code]i[/code], [code]u[/code], [code]s[/code], [code]indent[/code], [code]code[/code], [code]url[/code], [code]center[/code], [code]right[/code], [code]color[/code], [code]bgcolor[/code], [code]fgcolor[/code].
+        \\URL tags only support URLs wrapped by a URL tag, not URLs with a different title.
+        \\When printing to standard output, the supported subset of BBCode is converted to ANSI escape codes for the terminal emulator to display. Support for ANSI escape codes varies across terminal emulators, especially for italic and strikethrough. In standard output, [code]code[/code] is represented with faint text but without any font change. Unsupported tags are left as-is in standard output.
+        \\[codeblocks]
+        // \\[gdscript skip-lint]
+        // \\print_rich("[color=green][b]Hello world![/b][/color]") # Prints "Hello world!", in green with a bold font.
+        // \\[/gdscript]
+        // \\[csharp skip-lint]
+        // \\GD.PrintRich("[color=green][b]Hello world![/b][/color]"); // Prints "Hello world!", in green with a bold font.
+        // \\[/csharp]
+        \\[/codeblocks]
+        \\[b]Note:[/b] Consider using [method push_error] and [method push_warning] to print error and warning messages instead of [method print] or [method print_rich]. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.
+        \\[b]Note:[/b] On Windows, only Windows 10 and later correctly displays ANSI escape codes in standard output.
+        \\[b]Note:[/b] Output displayed in the editor supports clickable [code skip-lint][url=address]text[/url][/code] tags. The [code skip-lint][url][/code] tag's [code]address[/code] value is handled by [method OS.shell_open] when clicked.
+    ;
+
+    var fbs = std.io.fixedBufferStream(bbcode);
+
+    var tokens = try tokenizer.tokenize(testing.allocator, fbs.reader().any(), .{
+        .equals_required_in_parameters = false,
+    });
+    defer tokens.deinit(testing.allocator);
+
+    std.debug.print("Tokens: {s}\n", .{tokens});
+
+    var document = try parse(testing.allocator, tokens, .{});
+    defer document.deinit();
+
+    // std.debug.print("Document: {s}\n", .{document});
+}
+
+const testing = std.testing;
+const logger = std.log.scoped(.parser);
+const ArrayList = std.ArrayListUnmanaged;
+const TokenResult = tokenizer.TokenResult;
+
 const std = @import("std");
 const tokenizer = @import("tokenizer.zig");
-const TokenResult = tokenizer.TokenResult;
 const Document = @import("Document.zig");
-const ArrayList = std.ArrayListUnmanaged;
 const Node = @import("Node.zig");