@malloydata/malloy 0.0.1

package/dist/lang/test/test-translator.d.ts

@@ -0,0 +1,38 @@
+import { StructDef, NamedModelObject, ModelDef, Query, FieldDef, PipeSegment, TurtleDef, DocumentLocation } from "../../model/malloy_types";
+import { MalloyElement, ModelEntry, NameSpace } from "../ast";
+import { MalloyTranslator, TranslateResponse } from "../parse-malloy";
+export declare function pretty(thing: any): string;
+export declare const aTableDef: StructDef;
+/**
+ * When translating partial trees, there will not be a document node
+ * to handle namespace requests, this stands in for document in that case.
+ */
+declare class TestRoot extends MalloyElement implements NameSpace {
+    private modelDef;
+    elementType: string;
+    constructor(child: MalloyElement, forTranslator: MalloyTranslator, modelDef: ModelDef);
+    namespace(): NameSpace;
+    getEntry(name: string): ModelEntry | undefined;
+    setEntry(_name: string, _val: ModelEntry): void;
+}
+export declare class TestTranslator extends MalloyTranslator {
+    testRoot?: TestRoot;
+    internalModel: ModelDef;
+    constructor(source: string, rootRule?: string);
+    translate(): TranslateResponse;
+    ast(): MalloyElement | undefined;
+    private explainFailure;
+    get nameSpace(): Record<string, NamedModelObject>;
+    exploreFor(exploreName: string): StructDef;
+}
+export declare function getExplore(modelDef: ModelDef, name: string): StructDef;
+export declare function getModelQuery(modelDef: ModelDef, name: string): Query;
+export declare function getField(thing: StructDef | PipeSegment, name: string): FieldDef;
+export declare function getQueryField(structDef: StructDef, name: string): TurtleDef;
+export declare function getJoinField(structDef: StructDef, name: string): StructDef;
+export interface MarkedSource {
+    code: string;
+    locations: DocumentLocation[];
+}
+export declare function markSource(unmarked: TemplateStringsArray, ...marked: string[]): MarkedSource;
+export {};

package/dist/lang/test/test-translator.js

@@ -0,0 +1,334 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markSource = exports.getJoinField = exports.getQueryField = exports.getField = exports.getModelQuery = exports.getExplore = exports.TestTranslator = exports.aTableDef = exports.pretty = void 0;
+const util_1 = require("util");
+const malloy_types_1 = require("../../model/malloy_types");
+const ast_1 = require("../ast");
+const parse_malloy_1 = require("../parse-malloy");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
+function pretty(thing) {
+    return (0, util_1.inspect)(thing, { breakLength: 72, depth: Infinity });
+}
+exports.pretty = pretty;
+const mockSchema = {
+    aTable: {
+        type: "struct",
+        name: "aTable",
+        dialect: "standardsql",
+        structSource: { type: "table" },
+        structRelationship: { type: "basetable", connectionName: "test" },
+        fields: [
+            { type: "string", name: "astr" },
+            { type: "number", name: "af", numberType: "float" },
+            { type: "number", name: "ai", numberType: "integer" },
+            { type: "date", name: "ad" },
+            { type: "boolean", name: "abool" },
+            { type: "timestamp", name: "ats" },
+        ],
+    },
+    "malloytest.carriers": {
+        type: "struct",
+        name: "malloytest.carriers",
+        dialect: "standardsql",
+        structSource: {
+            type: "table",
+            tablePath: "malloytest.carriers",
+        },
+        structRelationship: { type: "basetable", connectionName: "bigquery" },
+        fields: [
+            { name: "code", type: "string" },
+            { name: "name", type: "string" },
+            { name: "nickname", type: "string" },
+        ],
+        as: "carriers",
+    },
+    "malloytest.flights": {
+        type: "struct",
+        name: "malloytest.flights",
+        dialect: "standardsql",
+        structSource: {
+            type: "table",
+            tablePath: "malloytest.flights",
+        },
+        structRelationship: { type: "basetable", connectionName: "bigquery" },
+        fields: [
+            { name: "carrier", type: "string" },
+            { name: "origin", type: "string" },
+            { name: "destination", type: "string" },
+            { name: "flight_num", type: "string" },
+            { name: "flight_time", type: "number", numberType: "integer" },
+            { name: "tail_num", type: "string" },
+            { name: "dep_time", type: "timestamp" },
+            { name: "arr_time", type: "timestamp" },
+            { name: "dep_delay", type: "number", numberType: "integer" },
+            { name: "arr_delay", type: "number", numberType: "integer" },
+            { name: "taxi_out", type: "number", numberType: "integer" },
+            { name: "taxi_in", type: "number", numberType: "integer" },
+            { name: "distance", type: "number", numberType: "integer" },
+            { name: "cancelled", type: "string" },
+            { name: "diverted", type: "string" },
+            { name: "id2", type: "number", numberType: "integer" },
+        ],
+        as: "flights",
+    },
+    "malloytest.airports": {
+        type: "struct",
+        name: "malloytest.airports",
+        dialect: "standardsql",
+        structSource: {
+            type: "table",
+            tablePath: "malloytest.airports",
+        },
+        structRelationship: { type: "basetable", connectionName: "bigquery" },
+        fields: [
+            { name: "id", type: "number", numberType: "integer" },
+            { name: "code", type: "string" },
+            { name: "site_number", type: "string" },
+            { name: "fac_type", type: "string" },
+            { name: "fac_use", type: "string" },
+            { name: "faa_region", type: "string" },
+            { name: "faa_dist", type: "string" },
+            { name: "city", type: "string" },
+            { name: "county", type: "string" },
+            { name: "state", type: "string" },
+            { name: "full_name", type: "string" },
+            { name: "own_type", type: "string" },
+            { name: "longitude", type: "number", numberType: "float" },
+            { name: "latitude", type: "number", numberType: "float" },
+            { name: "elevation", type: "number", numberType: "integer" },
+            { name: "aero_cht", type: "string" },
+            { name: "cbd_dist", type: "number", numberType: "integer" },
+            { name: "cbd_dir", type: "string" },
+            { name: "act_date", type: "string" },
+            { name: "cert", type: "string" },
+            { name: "fed_agree", type: "string" },
+            { name: "cust_intl", type: "string" },
+            { name: "c_ldg_rts", type: "string" },
+            { name: "joint_use", type: "string" },
+            { name: "mil_rts", type: "string" },
+            { name: "cntl_twr", type: "string" },
+            { name: "major", type: "string" },
+        ],
+        as: "airports",
+    },
+};
+exports.aTableDef = mockSchema.aTable;
+/**
+ * When translating partial trees, there will not be a document node
+ * to handle namespace requests, this stands in for document in that case.
+ */
+class TestRoot extends ast_1.MalloyElement {
+    constructor(child, forTranslator, modelDef) {
+        super({ child });
+        this.modelDef = modelDef;
+        this.elementType = "test root";
+        this.setTranslator(forTranslator);
+    }
+    namespace() {
+        return this;
+    }
+    getEntry(name) {
+        const struct = this.modelDef.contents[name];
+        if (struct.type == "struct") {
+            const exported = this.modelDef.exports.includes(name);
+            return { entry: struct, exported };
+        }
+    }
+    setEntry(_name, _val) {
+        throw new Error("Can't add entries to test model def");
+    }
+}
+const testURI = "internal://test/langtests/root.malloy";
+class TestTranslator extends parse_malloy_1.MalloyTranslator {
+    constructor(source, rootRule = "malloyDocument") {
+        super(testURI);
+        /*
+         * Tests can assume this model exists:
+         *   explore: a is table('aTable') { primary_key: astr }
+         *   explore: b is a
+         *   explore: ab is a {
+         *     join_one: b with astr
+         *     measure: acount is count()
+         *     query: aturtle is { group_by: astr; aggregate: acount }
+         *   }
+         */
+        this.internalModel = {
+            name: testURI,
+            exports: [],
+            contents: {
+                a: { ...exports.aTableDef, primaryKey: "astr", as: "a" },
+                b: { ...exports.aTableDef, primaryKey: "astr", as: "b" },
+                ab: {
+                    ...exports.aTableDef,
+                    as: "ab",
+                    primaryKey: "astr",
+                    fields: [
+                        ...exports.aTableDef.fields,
+                        {
+                            ...exports.aTableDef,
+                            as: "b",
+                            structRelationship: {
+                                type: "one",
+                                onExpression: [
+                                    { type: "field", path: "astr" },
+                                    "=",
+                                    { type: "field", path: "b.astr" },
+                                ],
+                            },
+                        },
+                        {
+                            type: "number",
+                            name: "acount",
+                            numberType: "integer",
+                            aggregate: true,
+                            e: ["COUNT()"],
+                            code: "count()",
+                        },
+                        {
+                            type: "turtle",
+                            name: "aturtle",
+                            pipeline: [
+                                {
+                                    type: "reduce",
+                                    fields: ["astr", "acount"],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        };
+        this.grammarRule = rootRule;
+        this.importZone.define(testURI, source);
+        for (const tableName in mockSchema) {
+            this.schemaZone.define(tableName, mockSchema[tableName]);
+        }
+    }
+    translate() {
+        return super.translate(this.internalModel);
+    }
+    ast() {
+        const astAsk = this.astStep.step(this);
+        if (astAsk.ast) {
+            if (this.grammarRule !== "malloyDocument") {
+                this.testRoot = new TestRoot(astAsk.ast, this, this.internalModel);
+            }
+            return astAsk.ast;
+        }
+        this.explainFailure();
+    }
+    explainFailure() {
+        let mysterious = true;
+        if (this.logger.empty()) {
+            const whatImports = this.importZone.getUndefined();
+            if (whatImports) {
+                mysterious = false;
+                this.logger.log({
+                    at: this.defaultLocation(),
+                    message: `Missing imports: ${whatImports.join(",")}`,
+                });
+            }
+            const needThese = this.schemaZone.getUndefined();
+            if (needThese) {
+                mysterious = false;
+                this.logger.log({
+                    at: this.defaultLocation(),
+                    message: `Missing schema: ${needThese.join(",")}`,
+                });
+            }
+            if (mysterious) {
+                this.logger.log({
+                    at: this.defaultLocation(),
+                    message: "mysterious translation failure",
+                });
+            }
+        }
+    }
+    get nameSpace() {
+        var _a;
+        const gotModel = this.translate();
+        return ((_a = gotModel === null || gotModel === void 0 ? void 0 : gotModel.translated) === null || _a === void 0 ? void 0 : _a.modelDef.contents) || {};
+    }
+    exploreFor(exploreName) {
+        const explore = this.nameSpace[exploreName];
+        if (explore && explore.type === "struct") {
+            return explore;
+        }
+        throw new Error(`Expected model to contain explore '${exploreName}'`);
+    }
+}
+exports.TestTranslator = TestTranslator;
+function getExplore(modelDef, name) {
+    return modelDef.contents[name];
+}
+exports.getExplore = getExplore;
+function getModelQuery(modelDef, name) {
+    return modelDef.contents[name];
+}
+exports.getModelQuery = getModelQuery;
+function getField(thing, name) {
+    const result = thing.fields.find((field) => typeof field !== "string" && (field.as || field.name) === name);
+    if (typeof result === "string") {
+        throw new Error("Expected a def, got a ref.");
+    }
+    if (result === undefined) {
+        throw new Error("Expected a field, not undefined");
+    }
+    if ((0, malloy_types_1.isFilteredAliasedName)(result)) {
+        throw new Error("Ignoring these for now");
+    }
+    return result;
+}
+exports.getField = getField;
+// TODO "as" is almost always a code smell ...
+function getQueryField(structDef, name) {
+    return getField(structDef, name);
+}
+exports.getQueryField = getQueryField;
+// TODO "as" is almost always a code smell ...
+function getJoinField(structDef, name) {
+    return getField(structDef, name);
+}
+exports.getJoinField = getJoinField;
+function markSource(unmarked, ...marked) {
+    let code = "";
+    const locations = [];
+    for (let index = 0; index < marked.length; index++) {
+        const mark = marked[index];
+        code += unmarked[index];
+        const lines = code.split("\n");
+        const start = {
+            line: lines.length - 1,
+            character: lines[lines.length - 1].length,
+        };
+        const bitLines = mark.split("\n");
+        const location = {
+            url: testURI,
+            range: {
+                start,
+                end: {
+                    line: start.line + bitLines.length - 1,
+                    character: bitLines.length === 1 ? start.character + mark.length : mark.length,
+                },
+            },
+        };
+        locations.push(location);
+        code += mark;
+    }
+    code += unmarked[marked.length];
+    return { code, locations };
+}
+exports.markSource = markSource;
+//# sourceMappingURL=test-translator.js.map

package/dist/lang/zone.d.ts

@@ -0,0 +1,57 @@
+import { DocumentLocation } from "../model/malloy_types";
+export declare type ZoneData<TValue> = Record<string, TValue>;
+declare type EntryStatus = "present" | "reference" | "error";
+interface AllEntries {
+    status: EntryStatus;
+    firstReference?: DocumentLocation;
+}
+interface EntryPresent<T> extends AllEntries {
+    status: "present";
+    value: T;
+}
+interface ReferenceEntry {
+    status: "reference";
+    firstReference: DocumentLocation;
+}
+interface EntryErrored extends AllEntries {
+    status: "error";
+    message: string;
+}
+declare type ZoneEntry<T> = EntryPresent<T> | ReferenceEntry | EntryErrored;
+/**
+ * A Zone is a symbol table which may contain references to symbols
+ * which are not yet defined. This is used by the parser to track
+ * references to objects which it will have to request values from
+ * before the translation can be complete. The API is struictured to
+ * build the repsonse-style interfaces that the translator uses.
+ */
+export declare class Zone<TValue> {
+    zone: Map<string, ZoneEntry<TValue>>;
+    location: Record<string, DocumentLocation>;
+    constructor();
+    get(str: string): TValue | undefined;
+    getEntry(str: string): ZoneEntry<TValue>;
+    /**
+     * Add a symbol and it's definition to the symbol table.
+     * @param str
+     * @param val
+     */
+    define(str: string, val: TValue): void;
+    /**
+     * Add a symbol to the symbol table.
+     * @param str The symbol
+     * @param loc The location of the reference
+     */
+    reference(str: string, loc: DocumentLocation): void;
+    /**
+     * @returns A list of all symbols which have references but not definitions
+     */
+    getUndefined(): string[] | undefined;
+    /**
+     * Provide values for symbols
+     * @param updateData Symbols and their values
+     * @param errorData Pass on errors encountered during fetch
+     */
+    updateFrom(updateData: ZoneData<TValue> | undefined, errorData: Record<string, string> | undefined): void;
+}
+export {};

package/dist/lang/zone.js

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zone = void 0;
+/**
+ * A Zone is a symbol table which may contain references to symbols
+ * which are not yet defined. This is used by the parser to track
+ * references to objects which it will have to request values from
+ * before the translation can be complete. The API is struictured to
+ * build the repsonse-style interfaces that the translator uses.
+ */
+class Zone {
+    constructor() {
+        this.location = {};
+        this.zone = new Map();
+    }
+    get(str) {
+        const zst = this.zone.get(str);
+        if ((zst === null || zst === void 0 ? void 0 : zst.status) === "present") {
+            return zst.value;
+        }
+    }
+    getEntry(str) {
+        const zst = this.zone.get(str);
+        if (zst) {
+            if (zst.firstReference || !this.location[str]) {
+                return zst;
+            }
+            return { ...zst, firstReference: this.location[str] };
+        }
+        return { status: "error", message: "import reference failure" };
+    }
+    /**
+     * Add a symbol and it's definition to the symbol table.
+     * @param str
+     * @param val
+     */
+    define(str, val) {
+        this.zone.set(str, { status: "present", value: val });
+    }
+    /**
+     * Add a symbol to the symbol table.
+     * @param str The symbol
+     * @param loc The location of the reference
+     */
+    reference(str, loc) {
+        const zst = this.zone.get(str);
+        if ((zst === null || zst === void 0 ? void 0 : zst.status) == undefined) {
+            this.zone.set(str, { status: "reference", firstReference: loc });
+            this.location[str] = loc;
+        }
+    }
+    /**
+     * @returns A list of all symbols which have references but not definitions
+     */
+    getUndefined() {
+        const allUndefined = [];
+        for (const [name, val] of this.zone) {
+            if (val.status === "reference") {
+                allUndefined.push(name);
+            }
+        }
+        return allUndefined.length > 0 ? allUndefined : undefined;
+    }
+    /**
+     * Provide values for symbols
+     * @param updateData Symbols and their values
+     * @param errorData Pass on errors encountered during fetch
+     */
+    updateFrom(updateData, errorData) {
+        if (updateData) {
+            for (const [updateKey, updateVal] of Object.entries(updateData)) {
+                if (updateVal !== undefined) {
+                    this.define(updateKey, updateVal);
+                }
+            }
+        }
+        if (errorData) {
+            for (const [errorKey, errorMessage] of Object.entries(errorData)) {
+                this.zone.set(errorKey, { status: "error", message: errorMessage });
+            }
+        }
+    }
+}
+exports.Zone = Zone;
+//# sourceMappingURL=zone.js.map