@xano/xanoscript-language-server 11.12.1 → 11.12.2

package/lexer/regexp.spec.js

@@ -0,0 +1,84 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { lexDocument } from "./lexer.js";
+
+function getTokenTypes(text) {
+  const result = lexDocument(text);
+  return {
+    tokens: result.tokens.map((t) => ({
+      type: t.tokenType.name,
+      image: t.image,
+    })),
+    errors: result.errors,
+  };
+}
+
+describe("RegExpToken lexer", () => {
+  it("should not lex a standalone regex without preceding colon", () => {
+    const { tokens } = getTokenTypes("/[^213]*/");
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex a regex after a colon", () => {
+    const { tokens, errors } = getTokenTypes("pattern:/[^213]*/");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(1);
+    expect(regexpTokens[0].image).to.equal("/[^213]*/");
+  });
+
+  it("should lex / as divide after an identifier", () => {
+    const { tokens } = getTokenTypes("var_rel/55");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex / as divide after a number", () => {
+    const { tokens } = getTokenTypes("55/2");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+  });
+
+  it("should lex / as divide after closing paren", () => {
+    const { tokens } = getTokenTypes("(1+2)/3");
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should not capture division as regex in complex expressions", () => {
+    const { tokens, errors } = getTokenTypes("$SomeVar.0.var_rel/55");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide with spaces around it", () => {
+    const { tokens, errors } = getTokenTypes("$var /64");
+    expect(errors).to.be.empty;
+    const regexpTokens = tokens.filter((t) => t.type === "RegExpToken");
+    expect(regexpTokens).to.have.length(0);
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide with space only before it", () => {
+    const { tokens, errors } = getTokenTypes("$var/ 64");
+    expect(errors).to.be.empty;
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(1);
+  });
+
+  it("should lex / as divide when no spaces around a value", () => {
+    const { tokens, errors } = getTokenTypes("$var /64/ 34");
+    expect(errors).to.be.empty;
+    const divideTokens = tokens.filter((t) => t.type === "Divide");
+    expect(divideTokens).to.have.length(2);
+  });
+});

package/lexer/tokens.js

@@ -1,4 +1,4 @@
-import { Lexer } from "chevrotain";
+import { createToken as chevrotainCreateToken, Lexer } from "chevrotain";
 import { Identifier } from "./identifier.js";
 import {
   createTokenByName,
@@ -150,10 +150,29 @@ export const NullToken = createTokenByName("null", {
 });
 
 // regular expression (regexp) pattern
-export const RegExpToken = createToken({
+// A regexp literal only appears after a colon (e.g., filter:pattern:/[^abc]*/)
+const regexpPattern = /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//y;
+function matchRegExp(text, startOffset, tokens) {
+  if (
+    tokens.length === 0 ||
+    tokens[tokens.length - 1].tokenType.name !== "ColonToken"
+  ) {
+    return null;
+  }
+  regexpPattern.lastIndex = startOffset;
+  const result = regexpPattern.exec(text);
+  if (result) {
+    return [result[0]];
+  }
+  return null;
+}
+
+export const RegExpToken = chevrotainCreateToken({
   name: "RegExpToken",
   label: "regexp",
-  pattern: /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//,
+  pattern: { exec: matchRegExp },
+  line_breaks: false,
+  start_chars_hint: ["/"],
 });
 
 export const WhiteSpace = createToken({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.12.1",
+  "version": "11.12.2",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/functions/controls/functionRunFn.spec.js

@@ -26,6 +26,16 @@ describe("functionRunFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("functionRunFn accepts complex expression as input", () => {
+    const parser = parse(`function.run "my_complex_function" {
+      input = {
+        Snumber     : (($SomeVar.0.var_rel/55) > 0 ? ($SomeVar.0.var_rel1/61) : 6)+(($My_Var_S2.0.elo/ 60) > 7 ? ($My_Var_S2.0.elo/62) : 9)+(($Optional_var2.0.det/63) > 4 ? ($Optional_var2.0.det /64) : 2)+(($PtSgeS_sge.0.elo/65) > 1 ? ($PtSgeS_sge.0.elo/66) : 3)
+        NumberObject: []
+      }
+    } as $Var_Round`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("functionRunFn accepts a string for function name", () => {
     const parser = parse(`function.run "my/function" {
       input = {a: $input.a, b: $b}

package/parser/tests/multidoc/multidoc_parser.spec.js

@@ -1,55 +0,0 @@
-import { expect } from "chai";
-import { readdirSync, readFileSync } from "fs";
-import { truncate } from "lodash-es";
-import { describe, it } from "mocha";
-import { dirname, join } from "path";
-import { multidocParser } from "../../multidoc.js";
-
-describe("Xanoscript multidoc Parser", () => {
-  it("parses all the valid sources", () => {
-    const errors = [];
-    const files = readdirSync(
-      join(dirname("./"), "parser/tests/multidoc/valid_sources"),
-    );
-
-    files.forEach((file) => {
-      const source = readFileSync(
-        join(dirname("./"), "parser/tests/multidoc/valid_sources", file),
-        "utf8",
-      );
-      const parser = multidocParser(source);
-
-      if (parser.errors.length > 0) {
-        parser.errors.forEach((error) => {
-          errors.push({
-            previous: error.previousToken
-              ? `${error.previousToken.tokenTypeName} (${truncate(
-                  error.previousToken.image,
-                  {
-                    length: 20,
-                  },
-                )})`
-              : "N/A",
-            file: error.token
-              ? `parser/tests/multidoc/valid_sources/${file}:${error.token.startLine}:${error.token.startColumn}`
-              : `parser/tests/multidoc/valid_sources/${file}`,
-            stack:
-              parser.sectionStack?.[parser.sectionStack.length - 1] ?? "N/A",
-            message: truncate(error.message, { length: 50 }),
-            token: error.token
-              ? `${error.token.tokenTypeName} (${truncate(error.token.image, {
-                  length: 20,
-                })})`
-              : "N/A",
-          });
-        });
-      }
-    });
-
-    if (errors.length > 0) {
-      console.table(errors);
-    }
-
-    expect(errors).to.be.empty;
-  });
-});