@malloydata/malloy 0.0.56-dev230707210748 → 0.0.56-dev230710162623

package/dist/lang/parse-utils.js

@@ -0,0 +1,238 @@
+"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.unIndent = exports.getOptionalId = exports.getId = exports.getIsNotes = exports.getNotes = exports.parseString = exports.getStringParts = exports.getStringIfShort = exports.getShortString = void 0;
+/**
+ * Take the text of a matched string, including the matching quote
+ * characters, and return the actual contents of the string after
+ * \ processing.
+ * @param cx Any parse context which contains a string
+ * @returns Decocded string
+ */
+function getShortString(scx) {
+    var _a, _b;
+    const str = ((_a = scx.DQ_STRING()) === null || _a === void 0 ? void 0 : _a.text) || ((_b = scx.SQ_STRING()) === null || _b === void 0 ? void 0 : _b.text);
+    if (str) {
+        return parseString(str, str[0]);
+    }
+    // shortString: DQ_STRING | SQ_STRING; So this will never happen
+    return '';
+}
+exports.getShortString = getShortString;
+function getStringIfShort(cx) {
+    const scx = cx.string().shortString();
+    if (scx) {
+        return getShortString(scx);
+    }
+}
+exports.getStringIfShort = getStringIfShort;
+function* getStringParts(cx) {
+    var _a;
+    if (cx) {
+        for (const part of cx.sqlInterpolation()) {
+            const upToOpen = part.OPEN_CODE().text;
+            if (upToOpen.length > 2) {
+                yield upToOpen.slice(0, upToOpen.length - 2);
+            }
+            if (part.query()) {
+                yield part.query();
+            }
+        }
+        const lastChars = (_a = cx.SQL_END()) === null || _a === void 0 ? void 0 : _a.text.slice(0, -3);
+        if (lastChars && lastChars.length > 0) {
+            yield lastChars;
+        }
+    }
+}
+exports.getStringParts = getStringParts;
+var ParseState;
+(function (ParseState) {
+    ParseState[ParseState["Normal"] = 0] = "Normal";
+    ParseState[ParseState["ReverseVirgule"] = 1] = "ReverseVirgule";
+    ParseState[ParseState["Unicode"] = 2] = "Unicode";
+})(ParseState || (ParseState = {}));
+/**
+ * Parses the interior of a string, doing all \ substitutions. In most cases
+ * a lexical analyzer has already recognized this as a string. As a convenience,
+ * strip off the quoting outer chartacters if asked, then parse the interior of
+ * the string. The intention is to be compatible with JSON strings, in terms
+ * of which \X substitutions are processed.
+ * @param str is the string to parse
+ * @param surround is the quoting character, default means quotes already stripped
+ * @returns a string with the \ processing completed
+ */
+function parseString(str, surround = '') {
+    let inner = str.slice(surround.length);
+    let state = ParseState.Normal;
+    if (surround.length) {
+        inner = inner.slice(0, -surround.length);
+    }
+    let out = '';
+    let unicode = '';
+    for (const c of inner) {
+        switch (state) {
+            case ParseState.Normal: {
+                if (c === '\\') {
+                    state = ParseState.ReverseVirgule;
+                }
+                else {
+                    out += c;
+                }
+                break;
+            }
+            case ParseState.ReverseVirgule: {
+                let outc = c;
+                if (c === 'u') {
+                    state = ParseState.Unicode;
+                    unicode = '';
+                    continue;
+                }
+                if (c === 'b') {
+                    outc = '\b';
+                }
+                else if (c === 'f') {
+                    outc = '\f';
+                }
+                else if (c === 'n') {
+                    outc = '\n';
+                }
+                else if (c === 'r') {
+                    outc = '\r';
+                }
+                else if (c === 't') {
+                    outc = '\t';
+                }
+                out += outc;
+                state = ParseState.Normal;
+                break;
+            }
+            case ParseState.Unicode: {
+                if ('ABCDEFabcdef0123456789'.includes(c)) {
+                    unicode += c;
+                    if (unicode.length === 4) {
+                        out += String.fromCharCode(parseInt(unicode, 16));
+                        state = ParseState.Normal;
+                    }
+                }
+                else {
+                    // Don't think we ever get here ...
+                    state = ParseState.Normal;
+                }
+            }
+        }
+    }
+    return out;
+}
+exports.parseString = parseString;
+/**
+ * Get all the possibly missing annotations from this parse rule
+ * @param cx Any parse context which has an ANNOTATION* rules
+ * @returns Array of texts for the annotations
+ */
+function getNotes(cx) {
+    return cx.ANNOTATION().map(a => a.text);
+}
+exports.getNotes = getNotes;
+function getIsNotes(cx) {
+    const before = getNotes(cx._beforeIs);
+    return before.concat(getNotes(cx._afterIs));
+}
+exports.getIsNotes = getIsNotes;
+/**
+ * An identifier is either a sequence of id characters or a `quoted`
+ * This parses either to simply the resulting text.
+ * @param cx A context which has an identifier
+ * @returns The indenftifier text
+ */
+function getId(cx) {
+    const quoted = cx.id().BQ_STRING();
+    if (quoted) {
+        return parseString(quoted.text, '`');
+    }
+    return cx.id().text;
+}
+exports.getId = getId;
+function getOptionalId(cx) {
+    function containsID(cx) {
+        return 'id' in cx;
+    }
+    if (containsID(cx) && cx.id()) {
+        return getId(cx);
+    }
+}
+exports.getOptionalId = getOptionalId;
+function* linesOf(allText) {
+    while (allText.length > 0) {
+        const lineMatch = allText.match(/^.*?\r?\n/);
+        let nextLine = allText;
+        if (lineMatch) {
+            nextLine = lineMatch[0];
+        }
+        yield nextLine;
+        allText = allText.slice(nextLine.length);
+    }
+}
+function minIndent(allText) {
+    let leftMost;
+    for (const line of linesOf(allText)) {
+        // look for lines starting with spaces, that have a non blank character somewhere
+        const leadingMatch = line.match(/^( *).*[^\s]/);
+        if (leadingMatch) {
+            const indentBy = leadingMatch[1].length;
+            if (leftMost === undefined || indentBy < leftMost) {
+                leftMost = indentBy;
+            }
+        }
+    }
+    return leftMost;
+}
+function unIndent(parts) {
+    let removeSpaces;
+    for (const part of parts) {
+        if (typeof part === 'string') {
+            const newLeft = minIndent(part);
+            if (newLeft !== undefined &&
+                (removeSpaces === undefined || newLeft < removeSpaces)) {
+                removeSpaces = newLeft;
+            }
+        }
+    }
+    if (removeSpaces) {
+        for (let i = 0; i <= parts.length; i += 1) {
+            const ent = parts[i];
+            if (typeof ent === 'string') {
+                let newEnt = '';
+                for (let line of linesOf(ent)) {
+                    if (line[0] === ' ') {
+                        line = line.slice(removeSpaces);
+                    }
+                    newEnt += line;
+                }
+                parts[i] = newEnt;
+            }
+        }
+    }
+}
+exports.unIndent = unIndent;
+//# sourceMappingURL=parse-utils.js.map

package/dist/lang/test/strings.spec.js

@@ -23,38 +23,133 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./parse-expects");
-const string_parser_1 = require("../string-parser");
-describe('test internal string parsing', () => {
+const parse_utils_1 = require("../parse-utils");
+const test_translator_1 = require("./test-translator");
+describe('quote comprehension inside strings', () => {
     test('\\b', () => {
-        expect((0, string_parser_1.parseString)('\\b')).toEqual('\b');
+        expect((0, parse_utils_1.parseString)('\\b')).toEqual('\b');
     });
     test('\\f', () => {
-        expect((0, string_parser_1.parseString)('\\f')).toEqual('\f');
+        expect((0, parse_utils_1.parseString)('\\f')).toEqual('\f');
     });
     test('\\n', () => {
-        expect((0, string_parser_1.parseString)('\\n')).toEqual('\n');
+        expect((0, parse_utils_1.parseString)('\\n')).toEqual('\n');
     });
     test('\\r', () => {
-        expect((0, string_parser_1.parseString)('\\r')).toEqual('\r');
+        expect((0, parse_utils_1.parseString)('\\r')).toEqual('\r');
     });
     test('\\t', () => {
-        expect((0, string_parser_1.parseString)('\\t')).toEqual('\t');
+        expect((0, parse_utils_1.parseString)('\\t')).toEqual('\t');
     });
     test('unicode ?', () => {
-        expect((0, string_parser_1.parseString)('\\u003f')).toEqual('?');
-        expect((0, string_parser_1.parseString)('\\u003F')).toEqual('?');
+        expect((0, parse_utils_1.parseString)('\\u003f')).toEqual('?');
+        expect((0, parse_utils_1.parseString)('\\u003F')).toEqual('?');
     });
     test('normal stuff', () => {
-        expect((0, string_parser_1.parseString)('normal stuff')).toEqual('normal stuff');
+        expect((0, parse_utils_1.parseString)('normal stuff')).toEqual('normal stuff');
     });
     test('stuff & nonsense', () => {
-        expect((0, string_parser_1.parseString)('stuff \\u0026 nonsense')).toEqual('stuff & nonsense');
+        expect((0, parse_utils_1.parseString)('stuff \\u0026 nonsense')).toEqual('stuff & nonsense');
     });
     test('one thing\\nnext thing', () => {
-        expect((0, string_parser_1.parseString)('one thing\\nnext thing')).toEqual('one thing\nnext thing');
+        expect((0, parse_utils_1.parseString)('one thing\\nnext thing')).toEqual('one thing\nnext thing');
     });
     test('quote stripping works', () => {
-        expect((0, string_parser_1.parseString)('|42|', '|')).toEqual('42');
+        expect((0, parse_utils_1.parseString)('|42|', '|')).toEqual('42');
+    });
+});
+describe('string parsing in language', () => {
+    const tz = 'America/Mexico_City';
+    test('multi-line indent increasing', () => {
+        const checking = new test_translator_1.BetaExpression(`"""
+      left
+        mid
+          right
+    """`);
+        expect(checking).toTranslate();
+        const v = checking.generated().value[0];
+        expect(v).toMatchObject({ literal: '\nleft\n  mid\n    right\n' });
+    });
+    test('multi-line indent decreasing', () => {
+        const checking = new test_translator_1.BetaExpression(`"""
+          right
+        mid
+      left
+    """`);
+        expect(checking).toTranslate();
+        const v = checking.generated().value[0];
+        expect(v).toMatchObject({ literal: '\n    right\n  mid\nleft\n' });
+    });
+    test('multi-line indent keep', () => {
+        const checking = new test_translator_1.BetaExpression(`"""right
+        mid
+      left"""`);
+        expect(checking).toTranslate();
+        const v = checking.generated().value[0];
+        expect(v).toMatchObject({ literal: 'right\n        mid\n      left' });
+    });
+    test('timezone single quote', () => {
+        const m = new test_translator_1.TestTranslator(`run: a-> {timezone: '${tz}'; project: *}`);
+        expect(m).toParse();
+    });
+    test('timezone double quote', () => {
+        const m = new test_translator_1.TestTranslator(`run: a-> {timezone: "${tz}"; project: *}`);
+        expect(m).toParse();
+    });
+    test('timezone triple quote', () => {
+        const m = new test_translator_1.TestTranslator(`run: a->{timezone: """${tz}"""; project: *}`);
+        expect(m).toParse();
+    });
+    test('timezone with illegal query', () => {
+        expect(`run: a->{timezone: """${tz}%{ab->aturtle}%"""; project: *}`).translationToFailWith('%{ query }% illegal in this string');
+    });
+    test('table single quote', () => {
+        const m = new test_translator_1.TestTranslator("source: n is bigquery.table('n')");
+        expect(m).toParse();
+    });
+    test('table double quote', () => {
+        const m = new test_translator_1.TestTranslator('source: n is bigquery.table("n")');
+        expect(m).toParse();
+    });
+    test('table triple quote', () => {
+        const m = new test_translator_1.TestTranslator('source: n is bigquery.table("""n""")');
+        expect(m).toParse();
+    });
+    test('sql single quote', () => {
+        const m = new test_translator_1.TestTranslator("source: n is bigquery.sql('n')");
+        expect(m).toParse();
+    });
+    test('sql double quote', () => {
+        const m = new test_translator_1.TestTranslator('source: n is bigquery.sql("n")');
+        expect(m).toParse();
+    });
+    test('sql triple quote', () => {
+        const m = new test_translator_1.TestTranslator('source: n is bigquery.sql("""n""")');
+        expect(m).toParse();
+    });
+    test('import single quote', () => {
+        const m = new test_translator_1.TestTranslator("import 'a'");
+        expect(m).toParse();
+    });
+    test('import double quote', () => {
+        const m = new test_translator_1.TestTranslator('import "a"');
+        expect(m).toParse();
+    });
+    test('import triple quote', () => {
+        const m = new test_translator_1.TestTranslator('import """a"""');
+        expect(m).toParse();
+    });
+    test('literal single quote', () => {
+        const x = new test_translator_1.BetaExpression("'x'");
+        expect(x).toParse();
+    });
+    test('literal double quote', () => {
+        const x = new test_translator_1.BetaExpression('"x"');
+        expect(x).toParse();
+    });
+    test('literal triple quote', () => {
+        const x = new test_translator_1.BetaExpression('"""x"""');
+        expect(x).toParse();
     });
 });
 //# sourceMappingURL=strings.spec.js.map

package/package.json

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

package/dist/lang/string-parser.d.ts

@@ -1,11 +0,0 @@
-/**
- * Parses the interior of a string, doing all \ substitutions. In most cases
- * a lexical analyzer has already recognized this as a string. As a convenience,
- * strip off the quoting outer chartacters if asked, then parse the interior of
- * the string. The intention is to be compatible with JSON strings, in terms
- * of which \X substitutions are processed.
- * @param str is the string to parse
- * @param surround is the quoting character, default means quotes already stripped
- * @returns a string with the \ processing completed
- */
-export declare function parseString(str: string, surround?: string): string;

package/dist/lang/string-parser.js

@@ -1,105 +0,0 @@
-"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.parseString = void 0;
-var ParseState;
-(function (ParseState) {
-    ParseState[ParseState["Normal"] = 0] = "Normal";
-    ParseState[ParseState["ReverseVirgule"] = 1] = "ReverseVirgule";
-    ParseState[ParseState["Unicode"] = 2] = "Unicode";
-})(ParseState || (ParseState = {}));
-/**
- * Parses the interior of a string, doing all \ substitutions. In most cases
- * a lexical analyzer has already recognized this as a string. As a convenience,
- * strip off the quoting outer chartacters if asked, then parse the interior of
- * the string. The intention is to be compatible with JSON strings, in terms
- * of which \X substitutions are processed.
- * @param str is the string to parse
- * @param surround is the quoting character, default means quotes already stripped
- * @returns a string with the \ processing completed
- */
-function parseString(str, surround = '') {
-    let inner = str.slice(surround.length);
-    let state = ParseState.Normal;
-    if (surround.length) {
-        inner = inner.slice(0, -surround.length);
-    }
-    let out = '';
-    let unicode = '';
-    for (const c of inner) {
-        switch (state) {
-            case ParseState.Normal: {
-                if (c === '\\') {
-                    state = ParseState.ReverseVirgule;
-                }
-                else {
-                    out += c;
-                }
-                break;
-            }
-            case ParseState.ReverseVirgule: {
-                let outc = c;
-                if (c === 'u') {
-                    state = ParseState.Unicode;
-                    unicode = '';
-                    continue;
-                }
-                if (c === 'b') {
-                    outc = '\b';
-                }
-                else if (c === 'f') {
-                    outc = '\f';
-                }
-                else if (c === 'n') {
-                    outc = '\n';
-                }
-                else if (c === 'r') {
-                    outc = '\r';
-                }
-                else if (c === 't') {
-                    outc = '\t';
-                }
-                out += outc;
-                state = ParseState.Normal;
-                break;
-            }
-            case ParseState.Unicode: {
-                if ('ABCDEFabcdef0123456789'.includes(c)) {
-                    unicode += c;
-                    if (unicode.length === 4) {
-                        out += String.fromCharCode(parseInt(unicode, 16));
-                        state = ParseState.Normal;
-                    }
-                }
-                else {
-                    // Don't think we ever get here ...
-                    state = ParseState.Normal;
-                }
-            }
-        }
-    }
-    return out;
-}
-exports.parseString = parseString;
-//# sourceMappingURL=string-parser.js.map