@malloydata/malloy 0.0.55 → 0.0.56-dev230707230009

package/dist/lang/{string-parser.js → parse-utils.js}

@@ -22,7 +22,53 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseString = void 0;
+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) {
+        const strParts = [];
+        for (const part of cx.sqlInterpolation()) {
+            const upToOpen = part.OPEN_CODE().text;
+            if (upToOpen.length > 2) {
+                strParts.push(upToOpen.slice(0, upToOpen.length - 2));
+            }
+            if (part.query()) {
+                strParts.push(part.query());
+            }
+        }
+        const lastChars = (_a = cx.SQL_END()) === null || _a === void 0 ? void 0 : _a.text.slice(0, -3);
+        if (lastChars && lastChars.length > 0) {
+            strParts.push(lastChars);
+        }
+        return strParts;
+    }
+    return [];
+}
+exports.getStringParts = getStringParts;
 var ParseState;
 (function (ParseState) {
     ParseState[ParseState["Normal"] = 0] = "Normal";
@@ -102,4 +148,41 @@ function parseString(str, surround = '') {
     return out;
 }
 exports.parseString = parseString;
-//# sourceMappingURL=string-parser.js.map
+/**
+ * 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;
+//# sourceMappingURL=parse-utils.js.map

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

@@ -23,38 +23,105 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./parse-expects");
-const string_parser_1 = require("../string-parser");
+const parse_utils_1 = require("../parse-utils");
+const test_translator_1 = require("./test-translator");
 describe('test internal string parsing', () => {
     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('all strings are parsed in all places', () => {
+    const tz = 'America/Mexico_City';
+    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.55",
+  "version": "0.0.56-dev230707230009",
   "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;