@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207171614

package/dist/lang/parse-tree-walkers/find-external-references.d.ts

@@ -0,0 +1,11 @@
+import { CommonTokenStream } from "antlr4ts";
+import type { ParseTree } from "antlr4ts/tree";
+import { DocumentRange } from "../../model/malloy_types";
+import { MalloyTranslation } from "../parse-malloy";
+declare type References = Record<string, DocumentRange>;
+interface FinderFound {
+    tables?: References;
+    urls?: References;
+}
+export declare function findReferences(trans: MalloyTranslation, tokens: CommonTokenStream, parseTree: ParseTree): FinderFound | null;
+export {};

package/dist/lang/parse-tree-walkers/find-external-references.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findReferences = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+class FindExternalReferences {
+    constructor(trans, tokens) {
+        this.trans = trans;
+        this.tokens = tokens;
+        this.needTables = {};
+        this.needImports = {};
+    }
+    enterTableName(pcx) {
+        const tableName = this.tokens.getText(pcx).slice(1, -1);
+        if (!this.needTables[tableName]) {
+            this.needTables[tableName] = this.trans.rangeFromContext(pcx);
+        }
+    }
+    enterImportURL(pcx) {
+        const url = JSON.parse(pcx.JSON_STRING().text);
+        if (!this.needImports[url]) {
+            this.needImports[url] = this.trans.rangeFromContext(pcx);
+        }
+    }
+}
+function findReferences(trans, tokens, parseTree) {
+    const finder = new FindExternalReferences(trans, tokens);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    let refs = {};
+    if (Object.keys(finder.needTables).length > 0) {
+        refs = { tables: finder.needTables };
+    }
+    if (Object.keys(finder.needImports).length > 0) {
+        refs = { ...refs, urls: finder.needImports };
+    }
+    return Object.keys(refs).length > 0 ? refs : null;
+}
+exports.findReferences = findReferences;
+//# sourceMappingURL=find-external-references.js.map

package/dist/lang/reference-list.d.ts

@@ -0,0 +1,10 @@
+import { DocumentReference, DocumentPosition } from "../model";
+export declare class ReferenceList {
+    private readonly sourceURL;
+    constructor(sourceURL: string);
+    private readonly references;
+    private findIndexBefore;
+    add(reference: DocumentReference): void;
+    private isPositionEqual;
+    find(position: DocumentPosition): DocumentReference | undefined;
+}

package/dist/lang/reference-list.js

@@ -0,0 +1,90 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceList = void 0;
+class ReferenceList {
+    constructor(sourceURL) {
+        this.sourceURL = sourceURL;
+        // These should always be sorted by their end positions
+        this.references = [];
+    }
+    findIndexBefore(position) {
+        let low = 0;
+        let high = this.references.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            const compare = this.references[middle].location.range.end;
+            if (compare.line < position.line ||
+                (compare.line === position.line &&
+                    compare.character < position.character)) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        return low;
+    }
+    add(reference) {
+        // Ignore any reference in another file
+        if (reference.location.url !== this.sourceURL) {
+            return;
+        }
+        const insertIndex = this.findIndexBefore(reference.location.range.end);
+        // Ignore duplicate references
+        if (insertIndex < this.references.length &&
+            this.isPositionEqual(reference, this.references[insertIndex])) {
+            return;
+        }
+        this.references.splice(insertIndex, 0, reference);
+    }
+    isPositionEqual(referenceA, referenceB) {
+        const rangeA = referenceA.location.range;
+        const rangeB = referenceB.location.range;
+        return (rangeA.start.line === rangeB.start.line &&
+            rangeA.start.character === rangeB.start.character &&
+            rangeA.end.line === rangeB.end.line &&
+            rangeA.end.character === rangeB.end.character);
+    }
+    find(position) {
+        // Here we assume that references DO NOT overlap. And then we do a binary
+        // search to find the one we're looking for.
+        const index = this.findIndexBefore(position);
+        if (index === this.references.length) {
+            return undefined;
+        }
+        const reference = this.references[index];
+        if (reference.location.range.start.line <= position.line &&
+            reference.location.range.end.line >= position.line &&
+            (position.line !== reference.location.range.start.line ||
+                position.character >= reference.location.range.start.character) &&
+            (position.line !== reference.location.range.end.line ||
+                position.character <= reference.location.range.end.character)) {
+            return reference;
+        }
+        return undefined;
+    }
+}
+exports.ReferenceList = ReferenceList;
+//# sourceMappingURL=reference-list.js.map

package/dist/lang/test/document-help-context-walker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lang/test/document-help-context-walker.spec.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+function testHelpContext(source, position, type, token) {
+    const doc = new test_translator_1.TestTranslator(source.code);
+    expect(doc.logger.hasErrors()).toBeFalsy();
+    const helpContext = doc.helpContext(position).helpContext;
+    expect(helpContext).toEqual({ type, token });
+}
+const source = `source: foo is table('bar') {
+  where: bazz ~ 'biff'
+  query: foo is {
+    group_by: bazz
+    where: bop ~ 'blat'
+  }
+}
+
+query: bar {
+  group_by: bazz
+}`;
+test("Supports model properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 0, character: 1 }, "model_property", "source:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 8, character: 1 }, "model_property", "query:");
+});
+test("Supports explore properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 1, character: 3 }, "explore_property", "where:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 2, character: 3 }, "explore_property", "query:");
+});
+test("Supports query properties", () => {
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 3, character: 5 }, "query_property", "group_by:");
+    testHelpContext((0, test_translator_1.markSource) `${source}`, { line: 4, character: 5 }, "query_property", "where:");
+});
+//# sourceMappingURL=document-help-context-walker.spec.js.map

package/dist/lang/test/document-symbol-walker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lang/test/document-symbol-walker.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+class MalloyExplore extends test_translator_1.TestTranslator {
+    constructor(src) {
+        super(src);
+    }
+    get symbols() {
+        const md = this.metadata();
+        return md.symbols || [];
+    }
+}
+function testSymbol(source, name, type, path) {
+    const doc = new MalloyExplore(source.code);
+    let current = { children: doc.symbols };
+    path.forEach((segment) => {
+        current = current.children[segment];
+    });
+    expect(doc.logger.hasErrors()).toBeFalsy();
+    expect(current).toMatchObject({
+        name,
+        range: source.locations[0].range,
+        type,
+    });
+}
+test("explore symbols are included", () => {
+    testSymbol((0, test_translator_1.markSource) `explore: ${"flights is table('my.table.flights')"}`, "flights", "explore", [0]);
+});
+test("query symbols are included", () => {
+    testSymbol((0, test_translator_1.markSource) `query: ${"flights_by_carrier is flights -> by_carrier"}`, "flights_by_carrier", "query", [0]);
+});
+test("expression field defs are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        dimension: ${"one is 1"}
+      }
+    `, "one", "field", [0, 0]);
+});
+test("renamed fields are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        rename: ${"field_two is field_2"}
+      }
+    `, "field_two", "field", [0, 0]);
+});
+test("name only fields are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        dimension: ${"field_two is field_2"}
+      }
+    `, "field_two", "field", [0, 0]);
+});
+test("turtle fields are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        query: ${"my_turtle is { group_by: a }"}
+      }
+    `, "my_turtle", "query", [0, 0]);
+});
+test("turtle children fields are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        query: my_turtle is { group_by: ${"a"} }
+      }
+    `, "a", "field", [0, 0, 0]);
+});
+test("turtle children turtles are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        query: my_turtle is { nest: ${"inner_turtle is { group_by: a }"} }
+      }
+    `, "inner_turtle", "query", [0, 0, 0]);
+});
+test("join withs are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        join_one: ${"a is b with c"}
+      }
+    `, "a", "join", [0, 0]);
+});
+test("join ons are included", () => {
+    testSymbol((0, test_translator_1.markSource) `
+      explore: flights is table('my.table.flights') {
+        join_one: ${"a is b on c"}
+      }
+    `, "a", "join", [0, 0]);
+});
+//# sourceMappingURL=document-symbol-walker.spec.js.map

package/dist/lang/test/field-symbols.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lang/test/field-symbols.spec.js

@@ -0,0 +1,184 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const static_space_1 = require("../ast/field-space/static-space");
+const column_space_field_1 = require("../ast/field-space/column-space-field");
+const field_space_1 = require("../ast/types/field-space");
+const query_field_struct_1 = require("../ast/field-space/query-field-struct");
+const space_param_1 = require("../ast/types/space-param");
+/*
+ **  A set of tests to make sure structdefs can become fieldspaces
+ ** and the fieldspace produces the same strcutdef
+ */
+describe("structdef comprehension", () => {
+    function mkStructDef(field) {
+        return {
+            type: "struct",
+            name: "test",
+            dialect: "standardsql",
+            structSource: { type: "table", tablePath: "test" },
+            structRelationship: { type: "basetable", connectionName: "test" },
+            fields: [field],
+        };
+    }
+    function fieldRef(fieldPath) {
+        return fieldPath.split(".").map((name) => new field_space_1.FieldName(name));
+    }
+    test(`import string field`, () => {
+        const field = {
+            name: "t",
+            type: "string",
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import float field`, () => {
+        const field = {
+            name: "t",
+            type: "number",
+            numberType: "float",
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import integer field`, () => {
+        const field = {
+            name: "t",
+            type: "number",
+            numberType: "integer",
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import boolean field`, () => {
+        const field = {
+            name: "t",
+            type: "boolean",
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import nested field`, () => {
+        const field = {
+            name: "t",
+            type: "struct",
+            dialect: "standardsql",
+            structRelationship: { type: "nested", field: "a", isArray: false },
+            structSource: { type: "nested" },
+            fields: [{ type: "string", name: "b" }],
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.b")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import inline field`, () => {
+        const field = {
+            name: "t",
+            type: "struct",
+            dialect: "standardsql",
+            structRelationship: { type: "inline" },
+            structSource: { type: "inline" },
+            fields: [{ type: "string", name: "a" }],
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import join field`, () => {
+        const field = {
+            name: "t",
+            type: "struct",
+            dialect: "standardsql",
+            structRelationship: {
+                type: "one",
+                onExpression: [
+                    { type: "field", path: "aKey" },
+                    "=",
+                    { type: "field", path: "t.a" },
+                ],
+            },
+            structSource: { type: "table", tablePath: "t" },
+            fields: [{ type: "string", name: "a" }],
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t.a")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test(`import query stage field`, () => {
+        const field = {
+            name: "t",
+            type: "turtle",
+            pipeline: [
+                {
+                    type: "reduce",
+                    fields: ["a"],
+                },
+            ],
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(query_field_struct_1.QueryFieldStruct);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
+    test("import struct with parameters", () => {
+        const struct = mkStructDef({ name: "f", type: "string" });
+        struct.parameters = {
+            cReqStr: {
+                name: "cReqStr",
+                type: "string",
+                value: null,
+                constant: false,
+            },
+            cOptStr: {
+                name: "cOptStr",
+                type: "string",
+                value: ["value"],
+                constant: false,
+            },
+        };
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("cReqStr")).found).toBeInstanceOf(space_param_1.DefinedParameter);
+        expect(space.lookup(fieldRef("cOptStr")).found).toBeInstanceOf(space_param_1.DefinedParameter);
+    });
+});
+//# sourceMappingURL=field-symbols.spec.js.map

package/dist/lang/test/parse.spec.d.ts

@@ -0,0 +1,14 @@
+import { DocumentLocation } from "../../model";
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            modelParsed(): R;
+            toBeErrorless(): R;
+            toCompile(): R;
+            modelCompiled(): R;
+            toReturnType(tp: string): R;
+            compileToFailWith(...expectedErrors: string[]): R;
+            isLocationIn(at: DocumentLocation, txt: string): R;
+        }
+    }
+}