@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/parser/generic/filterFn.spec.js

@@ -1,47 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.filterFn();
-  return parser;
-}
-
-function parseQuery(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.filterFn({ allowQueryExpression: true });
-  return parser;
-}
-
-describe("filterFn", () => {
-  it("filterFn accept valid filter", () => {
-    const parser = parse(`|add:2`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterFn accept valid chained filter", () => {
-    const parser = parse(`|add:2|divide:1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterFn rejected non-existing filter", () => {
-    const parser = parse(`|add:2|divider:1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("filterFn accept valid query filter with allowQueryExpression", () => {
-    const parser = parseQuery(`|between:18:65`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("filterFn reject invalid query filter with allowQueryExpression", () => {
-    const parser = parseQuery(`|in:[1,2,3]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/generic/functionAttrReq.spec.js

@@ -1,353 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { Identifier } from "../../lexer/tokens.js";
-import { parser } from "../test_parser.js";
-
-export function parserExtension() {
-  // this rule requires a foo field to be defined
-  this.functionAttrReq_test_required = this.RULE(
-    "functionAttrReq_test_required",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, { ARGS: [name, ["foo"]] });
-    }
-  );
-
-  // this rule has no required fields and two optional fields
-  this.functionAttrReq_test_optionals = this.RULE(
-    "functionAttrReq_test_optionals",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, { ARGS: [name, [], ["foo", "bar"]] });
-    }
-  );
-
-  // this rule has one required and one optional field
-  this.functionAttrReq_test_optional_and_required = this.RULE(
-    "functionAttrReq_test_optional_and_required",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, ["required"], ["option"]],
-      });
-    }
-  );
-
-  this.functionAttrReq_test_allow_disabled_keys = this.RULE(
-    "functionAttrReq_test_allow_disabled_keys",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, ["value", "other"], [], { allowDisabledKeys: true }],
-      });
-    }
-  );
-
-  // this rule allows duplicates for the "arg" field
-  this.functionAttrReq_test_allow_duplicates = this.RULE(
-    "functionAttrReq_test_allow_duplicates",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, [], ["arg"], { allowDuplicates: ["arg"] }],
-      });
-    }
-  );
-
-  // this rule allows an objectf for the "data" field
-  this.functionAttrReq_test_allow_object = this.RULE(
-    "functionAttrReq_test_allow_object",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, [], ["data"], { allowObject: ["data"] }],
-      });
-    }
-  );
-
-  // this rule allows an objectf for the "data" field
-  this.functionAttrReq_test_enforce_object = this.RULE(
-    "functionAttrReq_test_enforce_object",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, [], ["data"], { enforceObject: ["data"] }],
-      });
-    }
-  );
-
-  // this rule allows an objectf for the "data" field
-  this.functionAttrReq_test_allow_array = this.RULE(
-    "functionAttrReq_test_allow_array",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, [], ["data"], { allowArray: ["data"] }],
-      });
-    }
-  );
-
-  // this rule allows an objectf for the "data" field
-  this.functionAttrReq_test_allow_array_object = this.RULE(
-    "functionAttrReq_test_allow_array_object",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [
-          name,
-          [],
-          ["obj", "arr"],
-          { allowArray: ["arr"], allowObject: ["obj"] },
-        ],
-      });
-    }
-  );
-
-  this.functionAttrReq_test_mocks = this.RULE(
-    "functionAttrReq_test_mocks",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, [], ["mock", "value"]],
-      });
-    }
-  );
-
-  this.functionAttrReq_test_mocks_with_required_arg = this.RULE(
-    "functionAttrReq_test_mocks_with_required_arg",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, ["value", "mock"], []],
-      });
-    }
-  );
-
-  this.functionAttrReq_test_mock_not_allowed = this.RULE(
-    "functionAttrReq_test_mock_not_allowed",
-    () => {
-      const name = this.CONSUME(Identifier);
-      this.SUBRULE(this.functionAttrReq, {
-        ARGS: [name, ["value"], []],
-      });
-    }
-  );
-}
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  return parser;
-}
-
-describe("functionAttrReq", () => {
-  it("functionAttrReq matched requirements", () => {
-    parse(`something { 
-      foo = "bar" 
-    }`).functionAttrReq_test_required();
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq accept another variable reference", () => {
-    parse(`something { 
-      foo = $response.foo.baz 
-    }`).functionAttrReq_test_required();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq can be on a single line when there is only one attribute", () => {
-    parse(`something { foo = "bar" }`).functionAttrReq_test_required();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq discover missing requirements", () => {
-    parse(`something { 
-      foot = "bar" 
-    }`).functionAttrReq_test_required();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq discover optional requirements", () => {
-    // should allow one optional requirement
-    parse(`something { 
-      foo = "bar" 
-    }`).functionAttrReq_test_optionals();
-
-    expect(parser.errors).to.be.empty;
-
-    // should allow one optional requirement
-    parse(`something { 
-      bar = "foo" 
-    }`).functionAttrReq_test_optionals();
-
-    expect(parser.errors).to.be.empty;
-
-    // should allow all optional requirements
-    parse(`something { 
-      bar = "foo" 
-      foo = "bar" 
-    }`).functionAttrReq_test_optionals();
-
-    expect(parser.errors).to.be.empty;
-
-    // should allow no optional requirements defined
-    parse(`something { 
-    }`).functionAttrReq_test_optionals();
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq allows object fields", () => {
-    parse(`something { 
-      data = { foo: "bar" }
-    }`).functionAttrReq_test_allow_object();
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq allows array fields", () => {
-    parse(`something { 
-      data = [1,2, 3]
-    }`).functionAttrReq_test_allow_array();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq allows array fields", () => {
-    parse(`something { 
-      arr = [1,2, 3]
-      obj = { foo: "bar", bar: "foo" }
-    }`).functionAttrReq_test_allow_array_object();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq allows disabled keys", () => {
-    parse(`something { 
-      value = {
-        !i_am_disabled: "bar" 
-        i_am_enabled: "foo"
-      }
-      other = {
-        i_am_enabled: "foo"
-      }
-    }`).functionAttrReq_test_allow_disabled_keys();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq allows specific duplicates", () => {
-    // foo is defined twice
-    parse(`something { 
-      arg = "fizz" 
-      arg = "buzz" 
-    }`).functionAttrReq_test_allow_duplicates();
-
-    expect(parser.errors).to.be.empty;
-
-    // foo is defined twice
-    parse(`something { 
-      arg = "fizz" 
-      arg = "buzz" 
-      foo = "bar"
-      foo = "baz"
-    }`).functionAttrReq_test_allow_duplicates();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq detects duplicates", () => {
-    // foo is defined twice
-    parse(`something { 
-      foo = "fizz" 
-      foo = "buzz" 
-    }`).functionAttrReq_test_required();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq enforces optional requirements", () => {
-    // foot is not an optional requirement
-    parse(`something { 
-      foot = "bar" 
-    }`).functionAttrReq_test_optionals();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq enforces optional and required fields", () => {
-    // all optional and required fields are present
-    parse(`something {
-      option = "bar"
-      required = "bar"
-    }`).functionAttrReq_test_optional_and_required();
-    expect(parser.errors).to.be.empty;
-
-    // optional field is missing (all good)
-    parse(`something {
-      required = "bar"
-    }`).functionAttrReq_test_optional_and_required();
-
-    expect(parser.errors).to.be.empty;
-
-    // required field is missing (not good)
-    parse(`something { 
-      option = "bar" 
-    }`).functionAttrReq_test_optional_and_required();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq enforces mock attributes as optional", () => {
-    parse(`something { 
-      mock = {
-        "should add numbers": 5
-      }
-    }`).functionAttrReq_test_mocks();
-
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("functionAttrReq enforces mock attributes as required", () => {
-    parse(`something { 
-      value = 5
-    }`).functionAttrReq_test_mocks_with_required_arg();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq enforces mock attributes as not allowed", () => {
-    parse(`something { 
-      mock "should add numbers" {
-        value = 5
-      }
-    }`).functionAttrReq_test_mock_not_allowed();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq prevents multiple mock attributes with duplicate names", () => {
-    parse(`something { 
-      mock "should add numbers" {
-        value = 5
-      }
-      mock "should add numbers" {
-        value = 3
-      }
-    }`).functionAttrReq_test_mocks();
-
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("functionAttrReq allows multiple mock attributes with different names", () => {
-    parse(`something { 
-      mock = {
-        "should add numbers": 5
-        "should subtract numbers": 3
-      }
-    }`).functionAttrReq_test_mocks();
-
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/longFormVariable.spec.js

@@ -1,25 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.longFormVariable();
-  return parser;
-}
-
-describe("longFormVariable", () => {
-  it("longFormVariable accepts a property", () => {
-    const parser = parse(`$var.property`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("longFormVariable accepts a hash as a property", () => {
-    let parser = parse(`$var.["property"]`);
-    expect(parser.errors).to.be.empty;
-
-    parser = parse(`$var["property"]`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/minimalFnBody.spec.js

@@ -1,47 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.minimalFnBody();
-  return parser;
-}
-
-describe("minimalFnBody", () => {
-  it("minimalFnBody does not accept a value", () => {
-    const parser = parse(`{
-      value = "text"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("minimalFnBody accepts a description", () => {
-    const parser = parse(`{
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("minimalFnBody can be disabled", () => {
-    const parser = parse(`{
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("minimalFnBody can be disabled and have a description", () => {
-    const parser = parse(`{
-      disabled = true
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("minimalFnBody does not requires a description or disable statement", () => {
-    const parser = parse(`{
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/mockAttribute.spec.js

@@ -1,57 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.mockAttribute();
-  return parser;
-}
-
-describe("mock", () => {
-  it("mock accepts name and payload", () => {
-    const parser = parse(`mock = {
-      "should add numbers": 5
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mock requires an object", () => {
-    const parser = parse(`mock = 5`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("mock name doesn't need quotes", () => {
-    const parser = parse(`mock = {
-      foo: 5
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mock allows single line", () => {
-    const parser = parse(`mock = { "should add numbers": 5 }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mock allows an expression as a value", () => {
-    const parser = parse(`mock = {
-      "should add numbers": 5 + 10
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mock allows a filtered value", () => {
-    const parser = parse(`mock = {
-      "should add numbers": 5|add:10
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("mock allows an object as a value", () => {
-    const parser = parse(`mock = {
-      "should add numbers": { "foo": 5, "bar": 10 }
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/multilineFilterFn.spec.js

@@ -1,51 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.multilineFilterFn();
-  return parser;
-}
-
-function parseQuery(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  parser.multilineFilterFn({ allowQueryExpression: true });
-  return parser;
-}
-
-describe("multilineFilterFn", () => {
-  it("multilineFilterFn accept valid single line filter", () => {
-    const parser = parse(`|add:2`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("multilineFilterFn accept valid multiline filter", () => {
-    const parser = parse(`|add:2
-      |divide:1`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("multilineFilterFn rejected non-existing filter", () => {
-    const parser = parse(`|add:2
-      |divider:1`);
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("multilineFilterFn accept valid query filter with allowQueryExpression", () => {
-    const parser = parseQuery(`|between:18:65
-      |round`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("multilineFilterFn reject invalid query filter with allowQueryExpression", () => {
-    const parser = parseQuery(`|sub:10
-      |in:[1,2,3]`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});