@malloydata/malloy 0.0.28-dev230314211807 → 0.0.28-dev230320190215

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

@@ -2,8 +2,9 @@ import { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Qu
 import { MalloyElement } from '../ast';
 import { NameSpace } from '../ast/types/name-space';
 import { ModelEntry } from '../ast/types/model-entry';
-import { MalloyTranslator } from '../parse-malloy';
-import { TranslateResponse } from '../translate-response';
+import { MalloyChildTranslator, MalloyTranslator } from '../parse-malloy';
+import { DataRequestResponse, TranslateResponse } from '../translate-response';
+import { ExprValue } from '../ast/types/expr-value';
 export declare function pretty(thing: any): string;
 export declare const aTableDef: StructDef;
 /**
@@ -18,15 +19,32 @@ declare class TestRoot extends MalloyElement implements NameSpace {
     getEntry(name: string): ModelEntry | undefined;
     setEntry(_name: string, _val: ModelEntry): void;
 }
+export declare class TestChildTranslator extends MalloyChildTranslator {
+    translate(): TranslateResponse;
+    addChild(url: string): void;
+}
 export declare class TestTranslator extends MalloyTranslator {
+    readonly testSrc: string;
     testRoot?: TestRoot;
     internalModel: ModelDef;
-    constructor(source: string, rootRule?: string);
+    constructor(testSrc: string, rootRule?: string);
     translate(): TranslateResponse;
+    addChild(url: string): void;
     ast(): MalloyElement | undefined;
     private explainFailure;
     get nameSpace(): Record<string, NamedModelObject>;
     exploreFor(exploreName: string): StructDef;
+    static inspectCompile: boolean;
+    compile(): void;
+    unresolved(): DataRequestResponse;
+    getSourceDef(srcName: string): StructDef | undefined;
+    getQuery(queryName: string | number): Query | undefined;
+}
+export declare class BetaExpression extends TestTranslator {
+    private compiled?;
+    constructor(src: string);
+    compile(): void;
+    generated(): ExprValue;
 }
 export declare function getExplore(modelDef: ModelDef, name: string): StructDef;
 export declare function getModelQuery(modelDef: ModelDef, name: string): Query;

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

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable no-console */
 /*
  * Copyright 2023 Google LLC
  *
@@ -22,11 +23,12 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 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;
+exports.markSource = exports.getJoinField = exports.getQueryField = exports.getField = exports.getModelQuery = exports.getExplore = exports.BetaExpression = exports.TestTranslator = exports.TestChildTranslator = 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");
+const static_space_1 = require("../ast/field-space/static-space");
 // 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 });
@@ -162,19 +164,40 @@ class TestRoot extends ast_1.MalloyElement {
         throw new Error("Can't add entries to test model def");
     }
 }
+class TestChildTranslator extends parse_malloy_1.MalloyChildTranslator {
+    translate() {
+        if (this.root instanceof TestTranslator) {
+            return super.translate(this.root.internalModel);
+        }
+        else {
+            return super.translate();
+        }
+    }
+    addChild(url) {
+        if (!this.childTranslators.get(url)) {
+            const child = new TestChildTranslator(url, this.root);
+            this.childTranslators.set(url, child);
+        }
+    }
+}
+exports.TestChildTranslator = TestChildTranslator;
 const testURI = 'internal://test/langtests/root.malloy';
 class TestTranslator extends parse_malloy_1.MalloyTranslator {
-    constructor(source, rootRule = 'malloyDocument') {
+    constructor(testSrc, rootRule = 'malloyDocument') {
         super(testURI);
+        this.testSrc = testSrc;
         /*
-         * Tests can assume this model exists:
-         *   explore: a is table('aTable') { primary_key: astr }
-         *   explore: b is a
-         *   explore: ab is a {
+         * All test source files can assume that an import of this
+         * model has already happened.
+         *   source: a is table('aTable') { primary_key: astr }
+         *   source: b is a
+         *   source: ab is a {
          *     join_one: b with astr
          *     measure: acount is count()
          *     query: aturtle is { group_by: astr; aggregate: acount }
          *   }
+         * Also the following tables will be available
+         *   'aTable', 'malloytest.carriers'
          */
         this.internalModel = {
             name: testURI,
@@ -223,7 +246,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
             },
         };
         this.grammarRule = rootRule;
-        this.importZone.define(testURI, source);
+        this.importZone.define(testURI, testSrc);
         for (const tableName in mockSchema) {
             this.schemaZone.define(tableName, mockSchema[tableName]);
         }
@@ -231,6 +254,12 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
     translate() {
         return super.translate(this.internalModel);
     }
+    addChild(url) {
+        if (!this.childTranslators.get(url)) {
+            const child = new TestChildTranslator(url, this);
+            this.childTranslators.set(url, child);
+        }
+    }
     ast() {
         const astAsk = this.astStep.step(this);
         if (astAsk.ast) {
@@ -280,8 +309,77 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
         }
         throw new Error(`Expected model to contain explore '${exploreName}'`);
     }
+    compile() {
+        const compileTo = this.translate();
+        if (compileTo.translated && TestTranslator.inspectCompile) {
+            console.log('MODEL: ', pretty(compileTo.translated.modelDef));
+            console.log('QUERIES: ', pretty(compileTo.translated.queryList));
+        }
+        // All the stuff to ask the ast for a translation is already in TestTranslator
+    }
+    unresolved() {
+        return this.importsAndTablesStep.step(this);
+    }
+    getSourceDef(srcName) {
+        var _a;
+        const t = this.translate().translated;
+        const s = (_a = t === null || t === void 0 ? void 0 : t.modelDef) === null || _a === void 0 ? void 0 : _a.contents[srcName];
+        if (s && s.type === 'struct') {
+            return s;
+        }
+        return undefined;
+    }
+    getQuery(queryName) {
+        const t = this.translate().translated;
+        if (t) {
+            const s = typeof queryName === 'string'
+                ? t.modelDef.contents[queryName]
+                : t.queryList[queryName];
+            if ((s === null || s === void 0 ? void 0 : s.type) === 'query') {
+                return s;
+            }
+        }
+        return undefined;
+    }
 }
 exports.TestTranslator = TestTranslator;
+TestTranslator.inspectCompile = false;
+class BetaExpression extends TestTranslator {
+    constructor(src) {
+        super(src, 'justExpr');
+    }
+    compile() {
+        const exprAst = this.ast();
+        if (exprAst instanceof ast_1.ExpressionDef) {
+            const aStruct = this.internalModel.contents['ab'];
+            if (aStruct.type === 'struct') {
+                const tstFS = new static_space_1.StaticSpace(aStruct);
+                const exprDef = exprAst.getExpression(tstFS);
+                this.compiled = exprDef;
+                if (TestTranslator.inspectCompile) {
+                    console.log('EXPRESSION: ', pretty(exprDef));
+                }
+            }
+            else {
+                throw new Error("Can't get simple namespace for expression tests");
+            }
+        }
+        else if (this.logger.hasErrors()) {
+            return;
+        }
+        else {
+            const whatIsIt = (exprAst === null || exprAst === void 0 ? void 0 : exprAst.toString()) || 'NO AST GENERATED';
+            throw new Error(`Not an expression: ${whatIsIt}`);
+        }
+    }
+    generated() {
+        if (!this.compiled) {
+            throw new Error('Must compile expression before fetching generated code');
+        }
+        return this.compiled;
+    }
+}
+exports.BetaExpression = BetaExpression;
 function getExplore(modelDef, name) {
     return modelDef.contents[name];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.28-dev230314211807",
+  "version": "0.0.28-dev230320190215",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",