@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/parser/generic/objectWithAttributes.spec.js

@@ -1,147 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { lexDocument } from "../../lexer/lexer.js";
-import { parser } from "../test_parser.js";
-
-export function parserExtension() {
-  // this rule has no required fields and two optional fields
-  this.objectWithAttributes_test_object_query = this.RULE(
-    "objectWithAttributes_test_test_object_with_attr_query",
-    () => {
-      this.SUBRULE(this.objectWithAttributes, {
-        ARGS: [{ allowQueryExpression: true }],
-      });
-    }
-  );
-
-  this.objectWithAttributes_basic = this.RULE(
-    "objectWithAttributes_test_object_with_attr",
-    () => {
-      this.SUBRULE(this.objectWithAttributes);
-    }
-  );
-
-  this.objectWithAttributes_disabledKeys = this.RULE(
-    "objectWithAttributes_disabledKeys",
-    () => {
-      this.SUBRULE(this.objectWithAttributes, {
-        ARGS: [{ allowDisabledKeys: true }],
-      });
-    }
-  );
-}
-
-function parse(inputText) {
-  parser.reset();
-  const lexResult = lexDocument(inputText);
-  parser.input = lexResult.tokens;
-  return parser;
-}
-describe("objectWithAttributes", () => {
-  it("objectWithAttributes accepts an object with attributes", () => {
-    parse(`{ value: "test"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes enforces unique keys", () => {
-    parse(`{ value: "test", value: "test2"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("objectWithAttributes passes options to its children", () => {
-    parse(`{ value: "test", value: "test2"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.not.be.empty;
-  });
-  it("objectWithAttributes accepts an object with object as a value", () => {
-    parse(`{ value: { name: "john"}}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts a boolean value", () => {
-    parse(`{ value: false}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts null value", () => {
-    parse(`{ value: null}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts multiple values", () => {
-    parse(`{ value: null, other: "test"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes reject multiple values without a separator", () => {
-    parse(`{ value: null other: "test"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("objectWithAttributes accepts a trailing commas", () => {
-    parse(`{ value: null, other: "test",}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes can be on a new line", () => {
-    parse(`{ 
-      value: null, other: "test",
-    }`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts an empty object", () => {
-    parse(`{ }`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts a query object", () => {
-    parse(`{ 
-      foo: $db.order.foo
-      bar: $db.book.bar|concat:"test"
-    }`).objectWithAttributes_test_object_query();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes reject non query filters object", () => {
-    parse(`{ 
-      foo: [12,3]|pop
-      bar: $db.book.bar
-    }`).objectWithAttributes_test_object_query();
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("objectWithAttributes accepts multiple line object separated with new lines", () => {
-    parse(`{
-      value: null
-      other: "test"
-    }`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts multiple line object separated with new lines", () => {
-    parse(`{
-      value: null
-      !other: "test"
-    }`).objectWithAttributes_disabledKeys();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts combined single and multiple line object separated with commas", () => {
-    parse(`{
-      value: null, other: "test",
-      something: "test", 
-      "another value": 12
-
-
-      someone: "test", and: $var.Blah
-
-
-      foo: "bar"}`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("objectWithAttributes accepts an array as value ", () => {
-    parse(`{ values: [1, 2, 3] }`).objectWithAttributes_basic();
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/requiredValueFnBody.spec.js

@@ -1,56 +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.requiredValueFnBody();
-  return parser;
-}
-
-describe("requiredValueFnBody", () => {
-  it("requiredValueFnBody accepts a value", () => {
-    const parser = parse(`{
-      value = "text"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("requiredValueFnBody accepts a description", () => {
-    const parser = parse(`{
-      value = "text"
-      description = "foo"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("requiredValueFnBody can be disabled", () => {
-    const parser = parse(`{
-      value = "text"
-      disabled = true
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("requiredValueFnBody accepts a long form variable", () => {
-    const parser = parse(`{
-      value = $var.x1
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("requiredValueFnBody accepts a long form variable with property", () => {
-    const parser = parse(`{
-      value = $var.x1[0].foo
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("requiredValueFnBody requires a value", () => {
-    const parser = parse(`{
-      description = "foo"
-    }`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/generic/shortFormVariable.spec.js

@@ -1,27 +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.shortFormVariable();
-  return parser;
-}
-
-describe("shortFormVariable", () => {
-  it("shortFormVariable accept an identifier", () => {
-    const parser = parse("$value");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("shortFormVariable can be a double $$", () => {
-    const parser = parse("$$");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("shortFormVariable cannot start with a number", () => {
-    const parser = parse("$1");
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/generic/stringArray.spec.js

@@ -1,55 +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.stringArray();
-  return parser;
-}
-
-describe("stringArray", () => {
-  it("stringArray accepts a single string literal", () => {
-    const parser = parse('[ "some string" ]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("stringArray can be compact", () => {
-    const parser = parse('["some string"]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("stringArray can be empty", () => {
-    const parser = parse("[]");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("stringArray accepts multiple string literal", () => {
-    const parser = parse('["some string", "another string"]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("stringArray rejects digits", () => {
-    const parser = parse("[123.32]");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("stringArray rejects boolean", () => {
-    const parser = parse("[true]");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("stringArray rejects identifier", () => {
-    const parser = parse("[someString]");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("stringArray accepts a multi-line array", () => {
-    const parser = parse(`[
-      "some string",
-      "another string"
-    ]`);
-    expect(parser.errors).to.be.empty;
-  });
-});

package/parser/generic/tagsAttribute.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.tagsAttribute();
-  return parser;
-}
-
-describe("tags", () => {
-  it("tags accepts a single string literal", () => {
-    const parser = parse('tags = [ "some string" ]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tags can be compact", () => {
-    const parser = parse('tags=["some string"]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tags can be empty", () => {
-    const parser = parse("tags = []");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tags accepts multiple string literal", () => {
-    const parser = parse('tags = ["some tag", "another tag"]');
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("tags rejects digits", () => {
-    const parser = parse("tags = [123.32]");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("tags rejects boolean", () => {
-    const parser = parse("tags = [true]");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("tags rejects identifier", () => {
-    const parser = parse("tags = [$someString]");
-    expect(parser.errors).to.not.be.empty;
-  });
-});

package/parser/generic/variableOnly.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.variableOnly();
-  return parser;
-}
-
-describe("variableOnly", () => {
-  it("variableOnly can be a short named variable", () => {
-    const parser = parse("$users");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("variableOnly can be a variable", () => {
-    const parser = parse("$var.users");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("variableOnly can be a short named variable with sub props", () => {
-    const parser = parse("$users.x.y[1].z");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("variableOnly can be a variable with sub props", () => {
-    const parser = parse("$var.users.x.y[1].z");
-    expect(parser.errors).to.be.empty;
-  });
-
-  it("variableOnly cannot be an env variable", () => {
-    const parser = parse("$env.my_api_key");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("variableOnly cannot be an input variable", () => {
-    const parser = parse("$input.remote_ip");
-    expect(parser.errors).to.not.be.empty;
-  });
-
-  it("variableOnly cannot be a string", () => {
-    const parser = parse(`"someting"`);
-    expect(parser.errors).to.not.be.empty;
-  });
-});