@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/tests/formulas/range_tokenizer_test.ts

@@ -0,0 +1,187 @@
+import { rangeTokenize } from "../../src/formulas";
+
+describe("rangeTokenizer", () => {
+  test("only range", () => {
+    expect(rangeTokenize("=A1:A2")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A1:A2" },
+    ]);
+  });
+  test("operation and no range", () => {
+    expect(rangeTokenize("=A3+A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A3" },
+      { type: "OPERATOR", value: "+" },
+      { type: "SYMBOL", value: "A1" },
+    ]);
+  });
+  test("operation and range", () => {
+    expect(rangeTokenize("=A3+A1:A2")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A3" },
+      { type: "OPERATOR", value: "+" },
+      { type: "SYMBOL", value: "A1:A2" },
+    ]);
+  });
+  test("operation and range with spaces", () => {
+    expect(rangeTokenize("=A3+  A1 : A2   ")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A3" },
+      { type: "OPERATOR", value: "+" },
+      { type: "SYMBOL", value: "A1:A2" },
+    ]);
+  });
+
+  test("range with spaces then operation", () => {
+    expect(rangeTokenize("=  A1 : A2   +a3")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A1:A2" },
+      { type: "OPERATOR", value: "+" },
+      { type: "SYMBOL", value: "a3" },
+    ]);
+  });
+
+  test("= SUM ( C4 : C5 )", () => {
+    expect(rangeTokenize("= SUM ( C4 : C5 )")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SPACE", value: " " },
+      { type: "FUNCTION", value: "SUM" },
+      { type: "SPACE", value: " " },
+      { type: "LEFT_PAREN", value: "(" },
+      { type: "SYMBOL", value: "C4:C5" },
+      { type: "RIGHT_PAREN", value: ")" },
+    ]);
+  });
+});
+
+describe("knows what's a reference and what's not", () => {
+  test("lowercase cell reference", () => {
+    expect(rangeTokenize("=a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "a1" },
+    ]);
+  });
+
+  test("single cell reference", () => {
+    expect(rangeTokenize("=AA1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "AA1" },
+    ]);
+  });
+
+  test("large single cell reference", () => {
+    expect(rangeTokenize("=AA100")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "AA100" },
+    ]);
+  });
+
+  test("fixed cell", () => {
+    expect(rangeTokenize("=$a$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "$a$1" },
+    ]);
+  });
+
+  test("fixed row", () => {
+    expect(rangeTokenize("=a$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "a$1" },
+    ]);
+  });
+
+  test("fixed column", () => {
+    expect(rangeTokenize("=$a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "$a1" },
+    ]);
+  });
+
+  test("sheet, with lowercase cell reference", () => {
+    expect(rangeTokenize("=Sheet3!a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet3!a1" },
+    ]);
+  });
+
+  test("sheet, fixed cell", () => {
+    expect(rangeTokenize("=Sheet3!$a$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet3!$a$1" },
+    ]);
+  });
+
+  test("sheet, fixed row", () => {
+    expect(rangeTokenize("=Sheet3!a$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet3!a$1" },
+    ]);
+  });
+
+  test("sheet, fixed column", () => {
+    expect(rangeTokenize("=Sheet3!$a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet3!$a1" },
+    ]);
+  });
+
+  test("sheet with quotes and spaces", () => {
+    expect(rangeTokenize("='Sheet3'!a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'Sheet3'!a1" },
+    ]);
+    expect(rangeTokenize("='S h i t'!a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'S h i t'!a1" },
+    ]);
+    expect(rangeTokenize("='S ''h i t'!a1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'S ''h i t'!a1" },
+    ]);
+  });
+});
+
+describe("tokenize ranges", () => {
+  test("normal range", () => {
+    expect(rangeTokenize("=A1:B2")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "A1:B2" },
+    ]);
+  });
+
+  test("invalid range should be corrected", () => {
+    expect(rangeTokenize("=B1:A2")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "B1:A2" },
+    ]);
+  });
+
+  test.skip("column", () => {
+    expect(rangeTokenize("=A:A")).toEqual({
+      type: "BIN_OPERATION",
+      value: ":",
+      left: {
+        type: "REFERENCE",
+        value: "A",
+      },
+      right: {
+        type: "REFERENCE",
+        value: "A",
+      },
+    });
+  });
+  test.skip("row", () => {
+    expect(rangeTokenize("=1:1")).toEqual({
+      type: "BIN_OPERATION",
+      value: ":",
+      left: {
+        type: "REFERENCE",
+        value: "1",
+      },
+      right: {
+        type: "REFERENCE",
+        value: "1",
+      },
+    });
+  });
+});

package/tests/formulas/tokenizer_test.ts

@@ -0,0 +1,164 @@
+import { tokenize } from "../../src/formulas";
+
+describe("tokenizer", () => {
+  test("simple token", () => {
+    expect(tokenize("1")).toEqual([{ type: "NUMBER", value: "1" }]);
+  });
+  test("number with decimal token", () => {
+    expect(tokenize("=1.5")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "NUMBER", value: "1.5" },
+    ]);
+  });
+  test("formula token", () => {
+    expect(tokenize("=1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "NUMBER", value: "1" },
+    ]);
+  });
+  test("longer operators >=", () => {
+    expect(tokenize("= >= <= <")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SPACE", value: " " },
+      { type: "OPERATOR", value: ">=" },
+      { type: "SPACE", value: " " },
+      { type: "OPERATOR", value: "<=" },
+      { type: "SPACE", value: " " },
+      { type: "OPERATOR", value: "<" },
+    ]);
+  });
+
+  test("concat operator", () => {
+    expect(tokenize("=&")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "OPERATOR", value: "&" },
+    ]);
+  });
+
+  test("not equal operator", () => {
+    expect(tokenize("=<>")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "OPERATOR", value: "<>" },
+    ]);
+  });
+
+  test("can tokenize various number expressions", () => {
+    expect(tokenize("1%")).toEqual([{ type: "NUMBER", value: "1%" }]);
+    expect(tokenize("1 %")).toEqual([{ type: "NUMBER", value: "1 %" }]);
+    expect(tokenize("1.1")).toEqual([{ type: "NUMBER", value: "1.1" }]);
+    expect(tokenize("1e3")).toEqual([{ type: "NUMBER", value: "1e3" }]);
+  });
+
+  test("debug formula token", () => {
+    expect(tokenize("=?1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "DEBUGGER", value: "?" },
+      { type: "NUMBER", value: "1" },
+    ]);
+  });
+  test("String", () => {
+    expect(tokenize('"hello"')).toEqual([{ type: "STRING", value: '"hello"' }]);
+    expect(tokenize("'hello'")).toEqual([{ type: "SYMBOL", value: "'hello'" }]);
+    expect(tokenize("'hello")).toEqual([{ type: "UNKNOWN", value: "'hello" }]);
+    expect(tokenize('"he\\"l\\"lo"')).toEqual([{ type: "STRING", value: '"he\\"l\\"lo"' }]);
+    expect(tokenize("\"hel'l'o\"")).toEqual([{ type: "STRING", value: "\"hel'l'o\"" }]);
+    expect(tokenize('"hello""test"')).toEqual([
+      { type: "STRING", value: '"hello"' },
+      { type: "STRING", value: '"test"' },
+    ]);
+  });
+
+  test.each(['"hello', `"hello'`, '"hello\\"'])("String without closing double quotes", (str) => {
+    expect(tokenize(str)).toEqual([{ type: "STRING", value: str }]);
+  });
+
+  test("Function token", () => {
+    expect(tokenize("SUM")).toEqual([{ type: "FUNCTION", value: "SUM" }]);
+    expect(tokenize("RAND")).toEqual([{ type: "FUNCTION", value: "RAND" }]);
+    expect(tokenize("rand")).toEqual([{ type: "FUNCTION", value: "rand" }]);
+  });
+
+  test("Function token with point", () => {
+    expect(tokenize("CEILING.MATH")).toEqual([{ type: "FUNCTION", value: "CEILING.MATH" }]);
+    expect(tokenize("ceiling.math")).toEqual([{ type: "FUNCTION", value: "ceiling.math" }]);
+  });
+
+  test("Boolean", () => {
+    expect(tokenize("true")).toEqual([{ type: "SYMBOL", value: "true" }]);
+    expect(tokenize("false")).toEqual([
+      {
+        type: "SYMBOL",
+        value: "false",
+      },
+    ]);
+    expect(tokenize("=AND(true,false)")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "FUNCTION", value: "AND" },
+      { type: "LEFT_PAREN", value: "(" },
+      { type: "SYMBOL", value: "true" },
+      { type: "COMMA", value: "," },
+      { type: "SYMBOL", value: "false" },
+      { type: "RIGHT_PAREN", value: ")" },
+    ]);
+    expect(tokenize("=trueee")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "trueee" },
+    ]);
+  });
+
+  test("$references", () => {
+    expect(tokenize("=$A$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "$A$1" },
+    ]);
+    expect(tokenize("=C$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "C$1" },
+    ]);
+    expect(tokenize("=$C1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "$C1" },
+    ]);
+  });
+
+  test("reference and sheets", () => {
+    expect(tokenize("=Sheet1!A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet1!A1" },
+    ]);
+    expect(tokenize("='Sheet1'!A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'Sheet1'!A1" },
+    ]);
+    expect(tokenize("='Aryl Nibor Xela Nalim'!A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'Aryl Nibor Xela Nalim'!A1" },
+    ]);
+    expect(tokenize("=Sheet1!$A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet1!$A1" },
+    ]);
+    expect(tokenize("=Sheet1!A$1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "Sheet1!A$1" },
+    ]);
+    expect(tokenize("='a '' b'!A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "SYMBOL", value: "'a '' b'!A1" },
+    ]);
+
+    // note the missing ' in the following test:
+    expect(tokenize("='Sheet1!A1")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "UNKNOWN", value: "'Sheet1!A1" },
+    ]);
+  });
+
+  test("Unknown characters", () => {
+    expect(tokenize("=ù4")).toEqual([
+      { type: "OPERATOR", value: "=" },
+      { type: "UNKNOWN", value: "ù" },
+      { type: "NUMBER", value: "4" },
+    ]);
+  });
+});

package/tests/functions/arguments_test.ts

@@ -0,0 +1,141 @@
+import { args } from "../../src/functions/arguments";
+
+describe("args", () => {
+  test("various", () => {
+    expect(args(``)).toEqual([]);
+    expect(args(`test (number) some number`)).toEqual([
+      {
+        type: ["NUMBER"],
+        description: "some number",
+        name: "test",
+      },
+    ]);
+
+    expect(
+      args(`
+       test (number) some number
+       test2 (number) some other number
+      `)
+    ).toEqual([
+      {
+        type: ["NUMBER"],
+        description: "some number",
+        name: "test",
+      },
+      {
+        type: ["NUMBER"],
+        description: "some other number",
+        name: "test2",
+      },
+    ]);
+  });
+
+  test("empty description", () => {
+    expect(args(`test (number)`)).toEqual([
+      {
+        type: ["NUMBER"],
+        name: "test",
+        description: "",
+      },
+    ]);
+  });
+
+  test("default number value", () => {
+    expect(args(`test (number,default=10) descr`)).toEqual([
+      {
+        type: ["NUMBER"],
+        name: "test",
+        description: "descr",
+        default: 10,
+      },
+    ]);
+  });
+
+  test("default string value", () => {
+    expect(args(`test (number,default="asdf") descr`)).toEqual([
+      {
+        type: ["NUMBER"],
+        name: "test",
+        description: "descr",
+        default: "asdf",
+      },
+    ]);
+  });
+
+  test("with parenthesis in the description", () => {
+    expect(args(`test (number) descr( hahaha )`)).toEqual([
+      {
+        type: ["NUMBER"],
+        name: "test",
+        description: "descr( hahaha )",
+      },
+    ]);
+  });
+
+  test("does not care if lower or uppercase", () => {
+    expect(args(`test (NUMBER)`)).toEqual([
+      {
+        type: ["NUMBER"],
+        name: "test",
+        description: "",
+      },
+    ]);
+  });
+
+  test("accept all basic types", () => {
+    expect(args(`test (boolean)`)[0].type).toEqual(["BOOLEAN"]);
+    expect(args(`test (any)`)[0].type).toEqual(["ANY"]);
+    expect(args(`test (NumBer)`)[0].type).toEqual(["NUMBER"]);
+    expect(args(`test (string)`)[0].type).toEqual(["STRING"]);
+  });
+
+  test("accept all range types", () => {
+    expect(args(`test (range)`)[0].type).toEqual(["RANGE"]);
+    expect(args(`test (range<any>)`)[0].type).toEqual(["RANGE"]);
+    expect(args(`test (range<boolean>)`)[0].type).toEqual(["RANGE<BOOLEAN>"]);
+    expect(args(`test (range<number>)`)[0].type).toEqual(["RANGE<NUMBER>"]);
+    expect(args(`test (range<string>)`)[0].type).toEqual(["RANGE<STRING>"]);
+  });
+
+  test("accept multiple types", () => {
+    expect(args(`test (boolean,string)`)[0].type).toEqual(["BOOLEAN", "STRING"]);
+    expect(args(`test (string,any)`)[0].type).toEqual(["STRING", "ANY"]);
+  });
+
+  test("accept optional flag", () => {
+    expect(args(`test (boolean,optional)`)).toEqual([
+      {
+        description: "",
+        name: "test",
+        type: ["BOOLEAN"],
+        optional: true,
+      },
+    ]);
+    expect(args(`test (boolean,optional,string)`)).toEqual([
+      {
+        description: "",
+        name: "test",
+        type: ["BOOLEAN", "STRING"],
+        optional: true,
+      },
+    ]);
+  });
+  test("accept repeating flag", () => {
+    expect(args(`test (boolean,repeating)`)).toEqual([
+      {
+        description: "",
+        name: "test",
+        type: ["BOOLEAN"],
+        repeating: true,
+      },
+    ]);
+    expect(args(`test (boolean,repeating,number)`)).toEqual([
+      {
+        description: "",
+        name: "test",
+        type: ["BOOLEAN", "NUMBER"],
+        repeating: true,
+      },
+    ]);
+  });
+});