@malloydata/malloy-tag 0.0.237-dev250225144145

package/src/lib/Malloy/MalloyTagVisitor.ts

@@ -0,0 +1,141 @@
+// Generated from MalloyTag.g4 by ANTLR 4.9.0-SNAPSHOT
+
+
+import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
+
+import { TagEqContext } from "./MalloyTagParser";
+import { TagReplacePropertiesContext } from "./MalloyTagParser";
+import { TagUpdatePropertiesContext } from "./MalloyTagParser";
+import { TagDefContext } from "./MalloyTagParser";
+import { TagEmptyContext } from "./MalloyTagParser";
+import { TagLineContext } from "./MalloyTagParser";
+import { TagSpecContext } from "./MalloyTagParser";
+import { StringContext } from "./MalloyTagParser";
+import { IdentifierContext } from "./MalloyTagParser";
+import { PropNameContext } from "./MalloyTagParser";
+import { EqValueContext } from "./MalloyTagParser";
+import { ArrayElementContext } from "./MalloyTagParser";
+import { ReferenceContext } from "./MalloyTagParser";
+import { ArrayValueContext } from "./MalloyTagParser";
+import { PropertiesContext } from "./MalloyTagParser";
+
+
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `MalloyTagParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export interface MalloyTagVisitor<Result> extends ParseTreeVisitor<Result> {
+	/**
+	 * Visit a parse tree produced by the `tagEq`
+	 * labeled alternative in `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagEq?: (ctx: TagEqContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `tagReplaceProperties`
+	 * labeled alternative in `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagReplaceProperties?: (ctx: TagReplacePropertiesContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `tagUpdateProperties`
+	 * labeled alternative in `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagUpdateProperties?: (ctx: TagUpdatePropertiesContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `tagDef`
+	 * labeled alternative in `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagDef?: (ctx: TagDefContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by the `tagEmpty`
+	 * labeled alternative in `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagEmpty?: (ctx: TagEmptyContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.tagLine`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagLine?: (ctx: TagLineContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.tagSpec`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitTagSpec?: (ctx: TagSpecContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.string`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitString?: (ctx: StringContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.identifier`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitIdentifier?: (ctx: IdentifierContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.propName`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitPropName?: (ctx: PropNameContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.eqValue`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitEqValue?: (ctx: EqValueContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.arrayElement`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitArrayElement?: (ctx: ArrayElementContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.reference`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitReference?: (ctx: ReferenceContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.arrayValue`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitArrayValue?: (ctx: ArrayValueContext) => Result;
+
+	/**
+	 * Visit a parse tree produced by `MalloyTagParser.properties`.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	visitProperties?: (ctx: PropertiesContext) => Result;
+}
+

package/src/lib/Malloy/_BUILD_DIGEST_

@@ -0,0 +1 @@
+{"/home/runner/work/malloy/malloy/packages/malloy-tag/scripts/build_parser.js":"37886ea9-7b84-5377-bc58-fe80ec897c23","MalloyTag.g4":"b40515f5-cbf3-528f-bb13-81707cb0a69b"}

package/src/tags.spec.ts

@@ -0,0 +1,331 @@
+/*
+ * 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.
+ */
+
+import {TagDict, Tag} from './tags';
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace jest {
+    interface Matchers<R> {
+      tagsAre(t: TagDict): R;
+    }
+  }
+}
+
+expect.extend({
+  tagsAre(src: string | Tag, result: Tag) {
+    if (typeof src === 'string') {
+      const {tag, log} = Tag.fromTagLine(src, 0, undefined);
+      const errs = log.map(e => e.message);
+      if (log.length > 0) {
+        return {
+          pass: false,
+          message: () => `${src}: Tag Parsing Error(s)\n${errs.join('\n')}`,
+        };
+      }
+      src = tag;
+    }
+    const got = src.properties;
+    if (this.equals(got, result)) {
+      return {
+        pass: true,
+        message: () => 'Parse returned expected object',
+      };
+    }
+    return {
+      pass: false,
+      message: () => this.utils.diff(result, got) ?? 'Not different',
+    };
+  },
+});
+
+type TagTestTuple = [string, TagDict];
+describe('tagParse to Tag', () => {
+  const tagTests: TagTestTuple[] = [
+    ['just_name', {just_name: {}}],
+    ['name=bare_string', {name: {eq: 'bare_string'}}],
+    ['name="quoted_string"', {name: {eq: 'quoted_string'}}],
+    ['name {prop1}', {name: {properties: {prop1: {}}}}],
+    [
+      'name {prop1 prop2=value}',
+      {
+        name: {
+          properties: {
+            prop1: {},
+            prop2: {eq: 'value'},
+          },
+        },
+      },
+    ],
+    ['name.prop', {name: {properties: {prop: {}}}}],
+    ['name.prop=value', {name: {properties: {prop: {eq: 'value'}}}}],
+    [
+      'name.prop.sub=value',
+      {name: {properties: {prop: {properties: {sub: {eq: 'value'}}}}}},
+    ],
+    [
+      'name{first3=[a, b, c]}',
+      {name: {properties: {first3: {eq: [{eq: 'a'}, {eq: 'b'}, {eq: 'c'}]}}}},
+    ],
+    ['name{first1=[a,]}', {name: {properties: {first1: {eq: [{eq: 'a'}]}}}}],
+    [
+      'name{first=[a {A}]}',
+      {name: {properties: {first: {eq: [{eq: 'a', properties: {A: {}}}]}}}},
+    ],
+    [
+      'name{first=[{A}]}',
+      {name: {properties: {first: {eq: [{properties: {A: {}}}]}}}},
+    ],
+    ['name=value {prop}', {name: {eq: 'value', properties: {prop: {}}}}],
+    [
+      'name.prop={prop2}',
+      {name: {properties: {prop: {properties: {prop2: {}}}}}},
+    ],
+    ['no yes -no', {yes: {}}],
+
+    // TODO interesting behavior that removing a non-existant element, or the last element,
+    // does not remove the `properties`.
+    ['x -x.y', {x: {properties: {}}}],
+    ['x={y} -x.y', {x: {properties: {}}}],
+
+    ['x={y z} -x.y', {x: {properties: {z: {}}}}],
+    ['x={y z} x {-y}', {x: {properties: {z: {}}}}],
+    ['x=1 x {xx=11}', {x: {eq: '1', properties: {xx: {eq: '11'}}}}],
+    ['x.y=xx x=1 {...}', {x: {eq: '1', properties: {y: {eq: 'xx'}}}}],
+    ['a {b c} a=1', {a: {eq: '1'}}],
+    ['a=1 a=...{b}', {a: {eq: '1', properties: {b: {}}}}],
+    [
+      'a=red { shade=dark } color=$(a) shade=$(a.shade)',
+      {
+        a: {eq: 'red', properties: {shade: {eq: 'dark'}}},
+        color: {eq: 'red', properties: {shade: {eq: 'dark'}}},
+        shade: {eq: 'dark'},
+      },
+    ],
+    ['x=.01', {x: {eq: '.01'}}],
+    ['x=-7', {x: {eq: '-7'}}],
+    ['x=7', {x: {eq: '7'}}],
+    ['x=7.0', {x: {eq: '7.0'}}],
+    ['x=.7', {x: {eq: '.7'}}],
+    ['x=.7e2', {x: {eq: '.7e2'}}],
+    ['x=7E2', {x: {eq: '7E2'}}],
+    ['`spacey name`=Zaphod', {'spacey name': {eq: 'Zaphod'}}],
+    [
+      'image { alt=hello { field=department } }',
+      {
+        image: {
+          properties: {
+            alt: {eq: 'hello', properties: {field: {eq: 'department'}}},
+          },
+        },
+      },
+    ],
+    [
+      'image image.alt=hello image.alt.field=department',
+      {
+        image: {
+          properties: {
+            alt: {eq: 'hello', properties: {field: {eq: 'department'}}},
+          },
+        },
+      },
+    ],
+    ['can remove.properties -...', {}],
+  ];
+  test.each(tagTests)('tag %s', (expression: string, expected: TagDict) => {
+    expect(expression).tagsAre(expected);
+  });
+  test.skip('unskip to debug just one of the expressions', () => {
+    const x: TagTestTuple = ['word -...', {}];
+    expect(x[0]).tagsAre(x[1]);
+  });
+});
+
+describe('Tag access', () => {
+  test('just text', () => {
+    const strToParse = 'a=b';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    expect(a?.text()).toEqual('b');
+  });
+  test('tag path', () => {
+    const strToParse = 'a.b.c.d.e=f';
+    const tagParse = Tag.fromTagLine(strToParse, undefined);
+    expect(tagParse.log).toEqual([]);
+    const abcde = tagParse.tag.tag('a', 'b', 'c', 'd', 'e');
+    expect(abcde).toBeDefined();
+    expect(abcde?.text()).toEqual('f');
+  });
+  test('just array', () => {
+    const strToParse = 'a=[b]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    const aval = a?.array();
+    expect(aval).toBeDefined();
+    if (aval) {
+      expect(aval.length).toEqual(1);
+      expect(aval[0].text()).toEqual('b');
+    }
+  });
+  test('tag path into array', () => {
+    const strToParse = 'a.b.c = [{d=e}]';
+    const tagParse = Tag.fromTagLine(strToParse, undefined);
+    expect(tagParse.log).toEqual([]);
+    const abcde = tagParse.tag.tag('a', 'b', 'c', 0, 'd');
+    expect(abcde).toBeDefined();
+    expect(abcde?.text()).toEqual('e');
+  });
+  test('array as text', () => {
+    const strToParse = 'a=[b]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    expect(a?.text()).toBeUndefined();
+  });
+  test('text as array', () => {
+    const strToParse = 'a=b';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    expect(a?.array()).toBeUndefined();
+  });
+  test('just numeric', () => {
+    const strToParse = 'a=7';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const n = a?.numeric();
+    expect(typeof n).toBe('number');
+    expect(n).toEqual(7);
+  });
+  test('text as numeric', () => {
+    const strToParse = 'a=seven';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const n = a?.numeric();
+    expect(n).toBeUndefined();
+  });
+  test('array as numeric', () => {
+    const strToParse = 'a=[seven]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const n = a?.numeric();
+    expect(n).toBeUndefined();
+  });
+  test('full text array', () => {
+    const strToParse = 'a=[b,c]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const ais = a?.textArray();
+    expect(ais).toEqual(['b', 'c']);
+  });
+  test('filtered text array', () => {
+    const strToParse = 'a=[b,c,{d}]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const ais = a?.textArray();
+    expect(ais).toEqual(['b', 'c']);
+  });
+  test('full numeric array', () => {
+    const strToParse = 'a=[1,2]';
+    const getTags = Tag.fromTagLine(strToParse, undefined);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const ais = a?.numericArray();
+    expect(ais).toEqual([1, 2]);
+  });
+  test('filtered numeric array', () => {
+    const strToParse = 'a=[1,2,three]';
+    const getTags = Tag.fromTagLine(strToParse);
+    expect(getTags.log).toEqual([]);
+    const a = getTags.tag.tag('a');
+    expect(a).toBeDefined();
+    const ais = a?.numericArray();
+    expect(ais).toEqual([1, 2]);
+  });
+  test('has', () => {
+    const strToParse = 'a b.d';
+    const getTags = Tag.fromTagLine(strToParse);
+    expect(getTags.log).toEqual([]);
+    expect(getTags.tag.has('a')).toBeTruthy();
+    expect(getTags.tag.has('b', 'd')).toBeTruthy();
+    expect(getTags.tag.has('c')).toBeFalsy();
+  });
+  test('property access on existing tag (which does not yet have properties)', () => {
+    const parsePlot = Tag.fromTagLine('# plot');
+    const parsed = Tag.fromTagLine('# plot.x=2', 0, parsePlot.tag);
+    const allTags = parsed.tag;
+    const plotTag = allTags.tag('plot');
+    const xTag = plotTag!.tag('x');
+    const x = xTag!.numeric();
+    expect(parsed.tag.numeric('plot', 'x')).toEqual(2);
+    expect(plotTag!.numeric('x')).toEqual(2);
+    expect(x).toEqual(2);
+  });
+  test('set tag', () => {
+    const base = Tag.withPrefix('# ');
+    const ext = base.set(['a', 'b', 0], 3).set(['a', 'b', 1], 4);
+    expect(ext).tagsAre({
+      a: {properties: {b: {eq: [{eq: '3'}, {eq: '4'}]}}},
+    });
+    expect(ext.toString()).toBe('# a.b = [3, 4]');
+  });
+  test('soft remove', () => {
+    const base = Tag.fromTagLine('# a.b.c = [{ d = 1 }]').tag;
+    const ext = base.delete('a', 'b', 'c', 0, 'd').delete('a', 'b', 'c', 0);
+    expect(ext).tagsAre({
+      a: {properties: {b: {properties: {c: {eq: []}}}}},
+    });
+    expect(ext.toString()).toBe('# a.b.c = []');
+  });
+  test('hard remove', () => {
+    const base = Tag.fromTagLine('# hello').tag;
+    const ext = base.unset('goodbye').unset('a', 'dieu');
+    expect(ext).tagsAre({
+      hello: {},
+      goodbye: {deleted: true},
+      a: {properties: {dieu: {deleted: true}}},
+    });
+    expect(ext.toString()).toBe('# hello -goodbye a { -dieu }');
+  });
+  test('set with different prefix', () => {
+    const base = Tag.withPrefix('#(docs) ');
+    const ext = base.set(['a'], 3).set(['a', 'b'], null);
+    expect(ext.toString()).toBe('#(docs) a = 3 { b }');
+  });
+});