@malloydata/malloy 0.0.70-dev230810160240 → 0.0.70

package/dist/tags.js

@@ -21,8 +21,189 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTagProperties = exports.Tags = void 0;
+exports.parseTagProperties = exports.Tags = exports.Tag = void 0;
+const tree_1 = require("antlr4ts/tree");
+const MalloyTagLexer_1 = require("./lang/lib/Malloy/MalloyTagLexer");
+const MalloyTagParser_1 = require("./lang/lib/Malloy/MalloyTagParser");
+const antlr4ts_1 = require("antlr4ts");
+const parse_utils_1 = require("./lang/parse-utils");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+/**
+ * Class for interacting with the parsed output of an annotation
+ * containing the Malloy tag language. Used by the parser to
+ * generate parsed data, and as an API to that data.
+ * ```
+ * tag.text(p?)        => string value of tag.p or ''
+ * tag.array(p?)       => Tag[] value of tag.p or []
+ * tag.numeric(p?)     => numeric value of tag.p or NaN
+ * tag.dict            => Record<string, Tag> of tag properties
+ * tag.tag(p)          => Tag value of tag.p
+ * ```
+ */
+class Tag {
+    constructor(from = {}) {
+        if (from.eq) {
+            this.eq = from.eq;
+        }
+        if (from.properties) {
+            this.properties = from.properties;
+        }
+    }
+    static tagFrom(from = {}) {
+        if (from instanceof Tag) {
+            return from;
+        }
+        return new Tag(from);
+    }
+    static id(t) {
+        let thisTagId = Tag.ids.get(t);
+        if (thisTagId === undefined) {
+            thisTagId = Tag.nextTagId;
+            Tag.ids.set(t, thisTagId);
+            Tag.nextTagId += 1;
+        }
+        return thisTagId;
+    }
+    peek() {
+        let str = `#${Tag.id(this)}`;
+        if (this.eq) {
+            if (typeof this.eq === 'string') {
+                str += `=${this.eq}`;
+            }
+            else {
+                str += '=[]';
+            }
+        }
+        if (this.properties) {
+            const propStr = Object.keys(this.properties)
+                .map(k => `${k}:`)
+                .join(', ');
+            str += `{${propStr}}`;
+        }
+        return str;
+    }
+    /**
+     * Parse a line of Malloy tag language into a Tag which can be queried
+     * @param source -- The source line to be parsed. If the string starts with #, then it skips
+     *   all characters up to the first space.
+     * @param extending A tag which this line will be extending
+     * @param importing Outer "scopes" for $() references
+     * @returns Something shaped like { tag: Tag  , log: ParseErrors[] }
+     */
+    static fromTagline(str, extending, ...importing) {
+        return parseTagline(str, extending, importing, __filename, 0, 0);
+    }
+    static annotationToTaglines(annote, prefix) {
+        annote || (annote = {});
+        const tagLines = annote.inherits
+            ? Tag.annotationToTaglines(annote.inherits, prefix)
+            : [];
+        function prefixed(na) {
+            const ret = [];
+            for (const n of na || []) {
+                if (prefix === undefined || n.text.match(prefix)) {
+                    ret.push(n.text);
+                }
+            }
+            return ret;
+        }
+        return tagLines.concat(prefixed(annote.blockNotes), prefixed(annote.notes));
+    }
+    static annotationToTag(annote, spec = {}) {
+        let extending = spec.extending || new Tag();
+        const prefix = spec.prefix || /^##? /;
+        annote || (annote = {});
+        const allErrs = [];
+        if (annote.inherits) {
+            const inherits = Tag.annotationToTag(annote.inherits, spec);
+            allErrs.push(...inherits.log);
+            extending = inherits.tag;
+        }
+        const allNotes = [];
+        if (annote.blockNotes) {
+            allNotes.push(...annote.blockNotes);
+        }
+        if (annote.notes) {
+            allNotes.push(...annote.notes);
+        }
+        for (const note of allNotes) {
+            if (note.text.match(prefix)) {
+                const noteParse = parseTagline(note.text, extending, spec.scopes || [], note.at.url, note.at.range.start.line, note.at.range.start.character);
+                extending = noteParse.tag;
+                allErrs.push(...noteParse.log);
+            }
+        }
+        return { tag: extending, log: allErrs };
+    }
+    find(at) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let findIn = this;
+        for (const seg of at) {
+            findIn = findIn.properties && Tag.tagFrom(findIn.properties[seg]);
+            if (!findIn) {
+                return undefined;
+            }
+        }
+        return findIn;
+    }
+    tag(...at) {
+        return this.find(at);
+    }
+    has(...at) {
+        return !!this.find(at);
+    }
+    text(...at) {
+        var _a;
+        const str = (_a = this.find(at)) === null || _a === void 0 ? void 0 : _a.eq;
+        if (typeof str === 'string') {
+            return str;
+        }
+        return '';
+    }
+    numeric(...at) {
+        var _a;
+        const str = (_a = this.find(at)) === null || _a === void 0 ? void 0 : _a.eq;
+        if (typeof str === 'string') {
+            return Number.parseFloat(str);
+        }
+        return NaN;
+    }
+    get dict() {
+        const newDict = {};
+        if (this.properties) {
+            for (const key in this.properties) {
+                newDict[key] = Tag.tagFrom(this.properties[key]);
+            }
+        }
+        return newDict;
+    }
+    array(...at) {
+        var _a;
+        const array = (_a = this.find(at)) === null || _a === void 0 ? void 0 : _a.eq;
+        if (array === undefined || typeof array === 'string') {
+            return [];
+        }
+        return array.map(el => typeof el === 'string' ? new Tag({ eq: el }) : Tag.tagFrom(el));
+    }
+    // Has the sometimes desireable side effect of initalizing properties
+    getProperties() {
+        if (this.properties === undefined) {
+            this.properties = {};
+        }
+        return this.properties;
+    }
+    clone() {
+        return new Tag((0, cloneDeep_1.default)(this));
+    }
+}
+exports.Tag = Tag;
+// --- Just for debugging ---
+Tag.ids = new Map();
+Tag.nextTagId = 1000;
 function isDocTag(a) {
     return (a === null || a === void 0 ? void 0 : a.docString) !== undefined;
 }
@@ -52,11 +233,14 @@ function tagList(tagNode) {
     if (!tagNode) {
         return [];
     }
-    return [
-        ...(tagNode.inherits ? tagList(tagNode.inherits) : []),
-        ...(tagNode.blockNotes || []),
-        ...(tagNode.notes || []),
-    ];
+    const justText = tagNode.inherits ? tagList(tagNode.inherits) : [];
+    if (tagNode.blockNotes) {
+        justText.push(...tagNode.blockNotes.map(bn => bn.text));
+    }
+    if (tagNode.notes) {
+        justText.push(...tagNode.notes.map(n => n.text));
+    }
+    return justText;
 }
 /**
  * Lines which start '#"' are doc strings
@@ -85,13 +269,6 @@ function parseTag(src, tagProp) {
     }
 }
 function parseTagProperties(src, tagProp) {
-    /*
-     * I went back and forth if the grammar for these annotations should be
-     * in the parser or the lexer. Eventually the fact that the lexer ate
-     * newlines meant I couldn't figure out how to do it in the parser.
-     *
-     * Seems wrong to be writing a parser though.
-     */
     const tokens = tokenize(src);
     let tn = 0;
     const lastToken = tokens.length - 1;
@@ -161,4 +338,215 @@ function tokenize(src) {
     }
     return parts;
 }
+class TagErrorListener {
+    constructor(sourceURL, atLine, fromChar) {
+        this.sourceURL = sourceURL;
+        this.atLine = atLine;
+        this.fromChar = fromChar;
+        this.log = [];
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
+        const errAt = {
+            line: this.atLine,
+            character: this.fromChar + charPositionInLine,
+        };
+        const range = { start: errAt, end: errAt };
+        const logMsg = {
+            message: msg,
+            at: { url: this.sourceURL, range },
+            severity: 'error',
+        };
+        this.log.push(logMsg);
+    }
+}
+function getBuildOn(ctx) {
+    const buildOn = ctx['buildOn'];
+    if (buildOn instanceof Tag) {
+        return buildOn;
+    }
+    return new Tag();
+}
+function parsePath(buildOn, path) {
+    let writeInto = buildOn.getProperties();
+    for (const p of path.slice(0, path.length - 1)) {
+        let next;
+        if (writeInto[p] === undefined) {
+            next = new Tag({});
+            writeInto[p] = next;
+        }
+        else {
+            next = Tag.tagFrom(writeInto[p]);
+        }
+        writeInto = next.getProperties();
+    }
+    return [path[path.length - 1], writeInto];
+}
+function getString(ctx) {
+    return ctx.BARE_STRING() ? ctx.text : (0, parse_utils_1.parseString)(ctx.text, ctx.text[0]);
+}
+function parseTagline(source, extending, outerScope, sourceURL, onLine, atChar) {
+    if (source[0] === '#') {
+        const skipTo = source.indexOf(' ');
+        if (skipTo > 0) {
+            source = source.slice(skipTo);
+        }
+        else {
+            source = '';
+        }
+    }
+    const inputStream = antlr4ts_1.CharStreams.fromString(source);
+    const lexer = new MalloyTagLexer_1.MalloyTagLexer(inputStream);
+    const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+    const taglineParser = new MalloyTagParser_1.MalloyTagParser(tokenStream);
+    taglineParser.removeErrorListeners();
+    const pLog = new TagErrorListener(sourceURL, onLine, atChar);
+    taglineParser.addErrorListener(pLog);
+    const tagTree = taglineParser.tagLine();
+    const treeWalker = new TaglineParser(outerScope);
+    const tag = treeWalker.tagLineToTag(tagTree, extending);
+    return { tag, log: pLog.log };
+}
+class TaglineParser extends tree_1.AbstractParseTreeVisitor {
+    constructor(outerScopes = []) {
+        super();
+        this.scopes = [];
+        this.scopes.unshift(...outerScopes);
+    }
+    defaultResult() {
+        return new Tag();
+    }
+    visitString(ctx) {
+        return new Tag({ eq: getString(ctx) });
+    }
+    getPropName(ctx) {
+        return ctx.string().map(cx => getString(cx));
+    }
+    getTags(tags, tagLine) {
+        for (const tagSpec of tags) {
+            // Stash the current state of this tag in the context and then visit it
+            // visit functions should alter the tagLine
+            tagSpec['buildOn'] = tagLine;
+            this.visit(tagSpec);
+        }
+        return tagLine;
+    }
+    tagLineToTag(ctx, extending) {
+        extending = (extending === null || extending === void 0 ? void 0 : extending.clone()) || new Tag({});
+        this.scopes.unshift(extending);
+        this.getTags(ctx.tagSpec(), extending);
+        return extending;
+    }
+    visitTagLine(_ctx) {
+        throw new Error('INTERNAL: ERROR: Call tagLineToTag, not vistTagLine');
+        return this.defaultResult();
+    }
+    visitProperties(ctx) {
+        return this.getTags(ctx.tagSpec(), getBuildOn(ctx));
+    }
+    visitArrayValue(ctx) {
+        return new Tag({ eq: this.getArray(ctx) });
+    }
+    getArray(ctx) {
+        return ctx.arrayElement().map(v => this.visit(v));
+    }
+    visitArrayElement(ctx) {
+        const propCx = ctx.properties();
+        const properties = propCx ? this.visitProperties(propCx) : undefined;
+        const strCx = ctx.string();
+        let value = strCx ? getString(strCx) : undefined;
+        const arrayCx = ctx.arrayValue();
+        if (arrayCx) {
+            value = this.getArray(arrayCx);
+        }
+        if (properties) {
+            if (value) {
+                properties.eq = value;
+            }
+            return properties;
+        }
+        const refCx = ctx.reference();
+        if (refCx) {
+            return this.visitReference(refCx);
+        }
+        return new Tag({ eq: value });
+    }
+    visitReference(ctx) {
+        const path = this.getPropName(ctx.propName());
+        for (const scope of this.scopes) {
+            // first scope which has the first component gets to resolve the whole path
+            if (scope.has(path[0])) {
+                const refTo = scope.tag(...path);
+                if (refTo) {
+                    return refTo.clone();
+                }
+                break;
+            }
+        }
+        // MTOY TODO SYNTAX ERROR NOT FOUND
+        return this.defaultResult();
+    }
+    visitTagEq(ctx) {
+        const buildOn = getBuildOn(ctx);
+        const name = this.getPropName(ctx.propName());
+        const [writeKey, writeInto] = parsePath(buildOn, name);
+        const eq = this.visit(ctx.eqValue());
+        const propCx = ctx.properties();
+        if (propCx) {
+            // a.b.c { -y } means i want to do -y on
+            if (propCx.DOTTY() === undefined) {
+                const properties = this.visitProperties(propCx).dict;
+                // Add new properties old value
+                writeInto[writeKey] = { ...eq, properties };
+            }
+            else {
+                // preserve old properties, add new value
+                writeInto[writeKey] = { ...writeInto[writeKey], ...eq };
+            }
+        }
+        else {
+            writeInto[writeKey] = eq;
+        }
+        return buildOn;
+    }
+    visitTagReplaceProperties(ctx) {
+        const buildOn = getBuildOn(ctx);
+        const name = this.getPropName(ctx.propName());
+        const [writeKey, writeInto] = parsePath(buildOn, name);
+        const propCx = ctx.properties();
+        const props = this.visitProperties(propCx);
+        if (ctx.DOTTY() === undefined) {
+            // No dots, thropw away the value
+            writeInto[writeKey] = { properties: props.dict };
+        }
+        else {
+            /// DOTS, just update the properties
+            writeInto[writeKey].properties = props.dict;
+        }
+        return buildOn;
+    }
+    visitTagUpdateProperties(ctx) {
+        const buildOn = getBuildOn(ctx);
+        const name = this.getPropName(ctx.propName());
+        const [writeKey, writeInto] = parsePath(buildOn, name);
+        const propCx = ctx.properties();
+        propCx['buildOn'] = Tag.tagFrom(writeInto[writeKey]);
+        const props = this.visitProperties(propCx);
+        const thisObj = writeInto[writeKey] || {};
+        const properties = { ...thisObj.properties, ...props.dict };
+        writeInto[writeKey] = { ...thisObj, properties };
+        return buildOn;
+    }
+    visitTagDef(ctx) {
+        const buildOn = getBuildOn(ctx);
+        const path = this.getPropName(ctx.propName());
+        const [writeKey, writeInto] = parsePath(buildOn, path);
+        if (ctx.MINUS()) {
+            delete writeInto[writeKey];
+        }
+        else {
+            writeInto[writeKey] = {};
+        }
+        return buildOn;
+    }
+}
 //# sourceMappingURL=tags.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.70-dev230810160240",
+  "version": "0.0.70",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
   "dependencies": {
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
+    "jest-diff": "^29.6.2",
     "lodash": "^4.17.20",
     "luxon": "^1.26.0",
     "uuid": "^8.3.2"