feat: better directive parsing

Author: virtual-designer

src/framework/typescript/directives/Directive.ts

@@ -5,15 +5,16 @@ export type ParserState = {
     output: string;
     input: string;
     data: Record<string, unknown>;
+    currentArgument: string | undefined;
 };
 
-abstract class Directive {
+abstract class Directive<T = unknown> {
     public abstract readonly name: string;
 
     public abstract apply(
         parser: DirectiveParser,
         parserState: ParserState,
-        arg: string
+        arg: T
     ): Awaitable<void>;
 }
 

src/framework/typescript/directives/DirectiveParser.ts

@@ -1,6 +1,8 @@
 import type Directive from "@framework/directives/Directive";
 import type { Class } from "@framework/types/Utils";
 import { isAlpha } from "@framework/utils/string";
+import DirectiveParseError from "@framework/directives/DirectiveParseError";
+import JSON5 from "json5";
 
 class DirectiveParser {
     private readonly availableDirectives: Array<Directive> = [];
@@ -13,47 +15,104 @@ class DirectiveParser {
         this.availableDirectives.push(new directive());
     }
 
-    public async parse(input: string) {
-        const lines = input.trim().split(/\s*\n\s*/);
+    public async parse(input: string, silent = true) {
         const state = {
-            lines,
             input,
             output: input,
-            data: {} as Record<string, unknown>
+            data: {} as Record<string, unknown>,
+            currentArgument: undefined as string | undefined
         };
 
-        for (const line of lines) {
-            if (!line.startsWith("@")) {
+        for (let i = 0; i < input.length; i++) {
+            if (input[i] !== "@") {
                 continue;
             }
 
             let name = "";
 
-            while (isAlpha(line[name.length + 1])) {
-                name += line[name.length + 1];
+            while (isAlpha(input[i + name.length + 1])) {
+                name += input[i + name.length + 1];
             }
 
             if (!name) {
                 continue;
             }
 
-            if (!line.endsWith(")")) {
+            const sliced = input.slice(i + name.length + 1).trim();
+            const directive = this.availableDirectives.find(d => d.name === name);
+
+            if (!directive) {
                 continue;
             }
 
-            const sliced = line.slice(name.length + 1).trim();
-            const arg = sliced.slice(1, sliced.length - 1);
-            const directive = this.availableDirectives.find(d => d.name === name);
+            let arg;
+            let length = 0;
+
+            try {
+                const { json, length: computedLength, str } = this.getNextJSON5Literal(sliced, name);
+                arg = json;
+                length = computedLength;
+                state.currentArgument = str;
+            }
+            catch (error) {
+                if (!silent) {
+                    throw error;
+                }
 
-            if (!directive) {
                 continue;
             }
 
             await directive.apply(this, state, arg);
+            i += name.length + 1 + length - 1;
+            state.currentArgument = undefined;
         }
 
         return state;
     }
+
+    public getNextJSON5Literal(input: string, directiveName: string) {
+        const start = input.indexOf("{");
+        let end = start + 1;
+        let depth = 1;
+
+        while (depth > 0) {
+            if (input[end] === "{") {
+                depth++;
+            } else if (input[end] === "}") {
+                depth--;
+            }
+            else if (input[end] === undefined) {
+                throw new DirectiveParseError("Unexpected end of input");
+            }
+            else if (input[end] === "\"") {
+                end = input.indexOf("\"", end + 1);
+            }
+            else if (input[end] === "'") {
+                end = input.indexOf("'", end + 1);
+            }
+
+            if (end === -1) {
+                throw new DirectiveParseError("Unexpected end of input");
+            }
+
+            end++;
+        }
+
+        const str = input.slice(start, end);
+
+        try {
+            return {
+                json: JSON5.parse(str),
+                length: str.length,
+                str
+            };
+        }
+        catch (error) {
+            throw new DirectiveParseError("Failed to parse JSON5 literal in directive: " + directiveName, {
+                cause: error
+            });
+        }
+    }
 }
 
 export default DirectiveParser;

src/framework/typescript/utils/utils.ts

@@ -17,6 +17,10 @@
  * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
  */
 
+export function escapeRegex(string: string) {
+    return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
 export function requireNonNull<T>(value: T | null | undefined, message?: string): T {
     if (value === null || value === undefined) {
         throw new Error(message ?? "Value cannot be null or undefined");

src/main/typescript/directives/EmbedDirective.ts

@@ -3,10 +3,10 @@ import Directive from "@framework/directives/Directive";
 import DirectiveParseError from "@framework/directives/DirectiveParseError";
 import type DirectiveParser from "@framework/directives/DirectiveParser";
 import type { APIEmbed } from "discord.js";
-import JSON5 from "json5";
 import { z } from "zod";
+import { escapeRegex } from "@framework/utils/utils";
 
-class EmbedDirective extends Directive {
+class EmbedDirective extends Directive<APIEmbed> {
     public override readonly name = "embed";
     public static readonly discordApiEmbedSchema = z.object({
         title: z.string().optional(),
@@ -56,18 +56,8 @@ class EmbedDirective extends Directive {
             .optional()
     });
 
-    public override async apply(parser: DirectiveParser, state: ParserState, arg: string) {
-        let parsed;
-
-        try {
-            parsed = JSON5.parse(arg);
-        } catch (error) {
-            throw new DirectiveParseError("Invalid argument: must be valid JSON5", {
-                cause: error
-            });
-        }
-
-        const embed = EmbedDirective.discordApiEmbedSchema.safeParse(parsed);
+    public override async apply(parser: DirectiveParser, state: ParserState, arg: APIEmbed) {
+        const embed = EmbedDirective.discordApiEmbedSchema.safeParse(arg);
 
         if (!embed.success) {
             throw new DirectiveParseError(
@@ -82,7 +72,10 @@ class EmbedDirective extends Directive {
             state.output += "\n";
         }
 
-        state.output = state.output.replace(/@embed\s*\([^\n]+\)\n/gi, "");
+        if (state.currentArgument) {
+            state.output = state.output.replace(new RegExp(`@embed(\\s*)\\((\\s*)${escapeRegex(state.currentArgument)}(\\s*)\\)`), "");
+        }
+
         state.data.embeds ??= [];
         (state.data.embeds as Array<APIEmbed>)!.push(embed.data);
     }