@malloydata/malloy-tag 0.0.339 → 0.0.340

package/src/peggy/index.ts

@@ -1,89 +0,0 @@
-/*
- * Copyright Contributors to the Malloy project
- * SPDX-License-Identifier: MIT
- */
-
-import type {TagParse, TagError} from '../tags';
-import {Tag} from '../tags';
-import {Interpreter} from './interpreter';
-import type {TagStatement} from './statements';
-import * as parser from './dist/peg-tag-parser';
-
-/**
- * Parse a single line of Malloy tag language into a Tag.
- * Internal helper - use parseTag() as the public API.
- */
-function parseTagLine(source: string, extending: Tag | undefined): TagParse {
-  // Skip the prefix if present (e.g., "# " or "#(docs) ")
-  if (source[0] === '#') {
-    const skipTo = source.indexOf(' ');
-    if (skipTo > 0) {
-      source = source.slice(skipTo);
-    } else {
-      source = '';
-    }
-  }
-
-  const errors: TagError[] = [];
-  let statements: TagStatement[] = [];
-
-  try {
-    statements = parser.parse(source);
-  } catch (e: unknown) {
-    if (e && typeof e === 'object' && 'location' in e && 'message' in e) {
-      const peggyError = e as {
-        message: string;
-        location: {start: {line: number; column: number}};
-      };
-      // Return 0-based line and offset within the input string
-      errors.push({
-        code: 'tag-parse-syntax-error',
-        message: peggyError.message,
-        line: peggyError.location.start.line - 1,
-        offset: peggyError.location.start.column - 1,
-      });
-    } else {
-      errors.push({
-        code: 'tag-parse-syntax-error',
-        message: String(e),
-        line: 0,
-        offset: 0,
-      });
-    }
-    return {tag: extending?.clone() ?? new Tag({}), log: errors};
-  }
-
-  const interpreter = new Interpreter();
-  const tag = interpreter.execute(statements, extending);
-
-  return {tag, log: errors};
-}
-
-/**
- * Parse Malloy tag language into a Tag which can be queried.
- *
- * @param source - A single string or array of strings to parse. If a string
- *   starts with #, all characters up to the first space are skipped.
- *   When an array is provided, strings are parsed sequentially and merged.
- * @param extending - A tag which this parse will extend
- * @returns TagParse with the resulting tag and any errors. For arrays,
- *   error line numbers indicate the index in the array where the error occurred.
- */
-export function parseTag(source: string | string[], extending?: Tag): TagParse {
-  if (typeof source === 'string') {
-    return parseTagLine(source, extending);
-  }
-
-  const allErrs: TagError[] = [];
-  let current: Tag = extending ?? new Tag({});
-  for (let i = 0; i < source.length; i++) {
-    const text = source[i];
-    const noteParse = parseTagLine(text, current);
-    current = noteParse.tag;
-    // Adjust error line to be the index in the array
-    for (const err of noteParse.log) {
-      allErrs.push({...err, line: i + err.line});
-    }
-  }
-  return {tag: current, log: allErrs};
-}

package/src/peggy/interpreter.ts

@@ -1,265 +0,0 @@
-/*
- * Copyright Contributors to the Malloy project
- * SPDX-License-Identifier: MIT
- */
-
-import {Tag, RefTag} from '../tags';
-import type {TagStatement, TagValue, ArrayElement} from './statements';
-
-/**
- * Executes TagStatements to build a Tag object.
- */
-export class Interpreter {
-  execute(statements: TagStatement[], extending?: Tag): Tag {
-    // Root tag has no parent
-    const tag = extending?.clone() ?? new Tag({});
-
-    for (const stmt of statements) {
-      this.executeStatement(stmt, tag);
-    }
-
-    return tag;
-  }
-
-  private executeStatement(stmt: TagStatement, tag: Tag): void {
-    switch (stmt.kind) {
-      case 'setEq':
-        this.executeSetEq(stmt, tag);
-        break;
-      case 'replaceProperties':
-        this.executeReplaceProperties(stmt, tag);
-        break;
-      case 'updateProperties':
-        this.executeUpdateProperties(stmt, tag);
-        break;
-      case 'define':
-        this.executeDefine(stmt, tag);
-        break;
-      case 'clearAll':
-        tag.properties = {};
-        break;
-    }
-  }
-
-  private executeSetEq(
-    stmt: {
-      kind: 'setEq';
-      path: string[];
-      value: TagValue;
-      properties?: TagStatement[];
-      preserveProperties?: boolean;
-    },
-    tag: Tag
-  ): void {
-    const [writeKey, writeInto, parentTag] = this.buildAccessPath(
-      tag,
-      stmt.path
-    );
-
-    if (stmt.properties) {
-      // name = value { new_properties } - replace properties with new ones
-      const resultTag = this.createTagWithValue(stmt.value, parentTag);
-      for (const propStmt of stmt.properties) {
-        this.executeStatement(propStmt, resultTag);
-      }
-      writeInto[writeKey] = resultTag;
-    } else if (stmt.preserveProperties) {
-      // name = value { ... } - preserve existing properties, update value
-      const existing = writeInto[writeKey];
-      if (existing && stmt.value.kind !== 'reference') {
-        // Update value in place, preserving properties and parent chains
-        this.setTagValue(existing, stmt.value);
-      } else {
-        // No existing tag, or reference value (which requires a RefTag)
-        const resultTag = this.createTagWithValue(stmt.value, parentTag);
-        if (existing?.properties) {
-          // Clone properties with correct parent to preserve parent chains
-          resultTag.properties = {};
-          for (const [key, val] of Object.entries(existing.properties)) {
-            resultTag.properties[key] = val.clone(resultTag);
-          }
-        }
-        writeInto[writeKey] = resultTag;
-      }
-    } else {
-      // name = value - simple assignment
-      writeInto[writeKey] = this.createTagWithValue(stmt.value, parentTag);
-    }
-  }
-
-  private executeReplaceProperties(
-    stmt: {
-      kind: 'replaceProperties';
-      path: string[];
-      properties: TagStatement[];
-      preserveValue: boolean;
-    },
-    tag: Tag
-  ): void {
-    const [writeKey, writeInto, parentTag] = this.buildAccessPath(
-      tag,
-      stmt.path
-    );
-
-    if (stmt.preserveValue) {
-      // name = ... { properties } - preserve value, replace properties
-      const existing = writeInto[writeKey];
-      const resultTag = new Tag({}, parentTag);
-      if (existing) {
-        resultTag.eq = existing.eq;
-      }
-      for (const propStmt of stmt.properties) {
-        this.executeStatement(propStmt, resultTag);
-      }
-      writeInto[writeKey] = resultTag;
-    } else {
-      // name = { properties } - no value, replace properties
-      const resultTag = new Tag({}, parentTag);
-      for (const propStmt of stmt.properties) {
-        this.executeStatement(propStmt, resultTag);
-      }
-      writeInto[writeKey] = resultTag;
-    }
-  }
-
-  private executeUpdateProperties(
-    stmt: {
-      kind: 'updateProperties';
-      path: string[];
-      properties: TagStatement[];
-    },
-    tag: Tag
-  ): void {
-    const [writeKey, writeInto, parentTag] = this.buildAccessPath(
-      tag,
-      stmt.path
-    );
-    // Create or reuse the result tag - this is the tag that will be stored
-    // and that child tags will have as their parent
-    const resultTag = writeInto[writeKey] ?? new Tag({}, parentTag);
-
-    // Execute nested statements in the context of the result tag
-    for (const propStmt of stmt.properties) {
-      this.executeStatement(propStmt, resultTag);
-    }
-
-    writeInto[writeKey] = resultTag;
-  }
-
-  private executeDefine(
-    stmt: {kind: 'define'; path: string[]; deleted: boolean},
-    tag: Tag
-  ): void {
-    const [writeKey, writeInto, parentTag] = this.buildAccessPath(
-      tag,
-      stmt.path
-    );
-    if (stmt.deleted) {
-      writeInto[writeKey] = new Tag({deleted: true}, parentTag);
-    } else {
-      writeInto[writeKey] = new Tag({}, parentTag);
-    }
-  }
-
-  /**
-   * Navigate to the parent of the final path segment, creating intermediate
-   * tags as needed. Returns [finalKey, parentDict, parentTag] so caller can write to it.
-   */
-  private buildAccessPath(
-    tag: Tag,
-    path: string[]
-  ): [string, Record<string, Tag>, Tag] {
-    if (path.length === 0) {
-      throw new Error('INTERNAL ERROR: buildAccessPath called with empty path');
-    }
-
-    let currentTag = tag;
-    let parentDict = tag.getProperties();
-
-    for (const segment of path.slice(0, -1)) {
-      let next: Tag;
-      if (parentDict[segment] === undefined) {
-        next = new Tag({}, currentTag);
-        parentDict[segment] = next;
-      } else {
-        // Ensure properties exists on this intermediate tag
-        parentDict[segment].properties ??= {};
-        next = parentDict[segment];
-      }
-      currentTag = next;
-      parentDict = next.getProperties();
-    }
-
-    return [path[path.length - 1], parentDict, currentTag];
-  }
-
-  /**
-   * Resolve array elements to Tag[] with proper parent links.
-   */
-  private resolveArrayWithParent(elements: ArrayElement[], parent: Tag): Tag[] {
-    return elements.map(el => {
-      // Reference without properties becomes a RefTag
-      if (el.value?.kind === 'reference' && !el.properties) {
-        return new RefTag(el.value.ups, el.value.path, parent);
-      }
-
-      const resultTag = new Tag({}, parent);
-
-      if (el.value) {
-        if (el.value.kind === 'array') {
-          // Nested array
-          resultTag.eq = this.resolveArrayWithParent(
-            el.value.elements,
-            resultTag
-          );
-        } else if (el.value.kind !== 'reference') {
-          resultTag.eq = el.value.value;
-        }
-        // References with properties are ignored (just the properties are kept)
-      }
-
-      if (el.properties) {
-        for (const stmt of el.properties) {
-          this.executeStatement(stmt, resultTag);
-        }
-      }
-
-      return resultTag;
-    });
-  }
-
-  /**
-   * Update an existing tag's value in place, preserving its properties.
-   * Note: References must be handled separately since they require a RefTag.
-   */
-  private setTagValue(
-    tag: Tag,
-    valueData: Exclude<TagValue, {kind: 'reference'}>
-  ): void {
-    if (valueData.kind === 'array') {
-      tag.eq = this.resolveArrayWithParent(valueData.elements, tag);
-    } else {
-      tag.eq = valueData.value;
-    }
-  }
-
-  /**
-   * Create a Tag with value, resolving arrays with proper parent links.
-   * Returns a RefTag for reference values.
-   */
-  private createTagWithValue(valueData: TagValue, parent: Tag): Tag {
-    if (valueData.kind === 'reference') {
-      return new RefTag(valueData.ups, valueData.path, parent);
-    }
-
-    const resultTag = new Tag({}, parent);
-
-    if (valueData.kind === 'array') {
-      resultTag.eq = this.resolveArrayWithParent(valueData.elements, resultTag);
-    } else {
-      resultTag.eq = valueData.value;
-    }
-
-    return resultTag;
-  }
-}

package/src/peggy/malloy-tag.peggy

@@ -1,224 +0,0 @@
-/*
- * Copyright Contributors to the Malloy project
- * SPDX-License-Identifier: MIT
- */
-
-{{
-  // Helper to parse escape sequences in strings
-  // Handles: \b \f \n \r \t \uXXXX and passthrough for other escapes
-  function parseEscapes(str) {
-    return str.replace(/\\(u[0-9A-Fa-f]{4}|.)/g, (match, capture) => {
-      if (capture.startsWith('u') && capture.length === 5) {
-        return String.fromCharCode(parseInt(capture.slice(1), 16));
-      }
-      switch (capture) {
-        case 'b': return '\b';
-        case 'f': return '\f';
-        case 'n': return '\n';
-        case 'r': return '\r';
-        case 't': return '\t';
-        default: return capture;
-      }
-    });
-  }
-}}
-
-// Entry point - supports multi-line input
-tagLine = specs:(_ @tagSpec)* _ { return specs; }
-
-// Line comment: # to end of line
-comment = "#" [^\r\n]* ("\r\n" / "\r" / "\n" / !.)
-
-tagSpec
-  = tagEq
-  / tagReplaceProperties
-  / tagUpdateProperties
-  / tagEmpty
-  / tagDef
-
-// name = value { properties }  or  name = value { ... }
-tagEq
-  = path:propName _ "=" _ value:eqValue props:(_ properties)? {
-      const result = {
-        kind: 'setEq',
-        path,
-        value
-      };
-      if (props) {
-        if (props[1].dotty) {
-          result.preserveProperties = true;
-        } else {
-          result.properties = props[1].statements;
-        }
-      }
-      return result;
-    }
-
-// name = { properties }  or  name = ... { properties }  or  name: { properties }
-tagReplaceProperties
-  = path:propName _ "=" _ dotty:"..."? _ props:properties {
-      return {
-        kind: 'replaceProperties',
-        path,
-        properties: props.statements,
-        preserveValue: dotty !== null
-      };
-    }
-  / path:propName _ ":" _ props:properties {
-      return {
-        kind: 'replaceProperties',
-        path,
-        properties: props.statements,
-        preserveValue: false
-      };
-    }
-
-// name { properties }
-tagUpdateProperties
-  = path:propName _ props:properties {
-      return {
-        kind: 'updateProperties',
-        path,
-        properties: props.statements
-      };
-    }
-
-// name  or  -name
-tagDef
-  = deleted:"-"? path:propName {
-      return {
-        kind: 'define',
-        path,
-        deleted: deleted !== null
-      };
-    }
-
-// -...
-tagEmpty
-  = "-..." { return { kind: 'clearAll' }; }
-
-// Property path: a.b.c
-propName
-  = head:identifier tail:("." @identifier)* {
-      return [head, ...tail];
-    }
-
-// Values that can be assigned with =
-eqValue
-  = arrayValue
-  / booleanValue
-  / dateValue
-  / referenceValue
-  / numberValue
-  / stringValue
-
-// Reference to another value in the tag tree
-// $path.to.thing - absolute from root
-// $^thing - up one level
-// $^^thing - up two levels
-// $items[0].name - with array indexing
-referenceValue
-  = "$" ups:"^"* first:refPathElement rest:("." @refPathElement)* {
-      const path = [first, ...rest].flat();
-      return { kind: 'reference', ups: ups.length, path };
-    }
-
-refPathElement
-  = name:identifier index:("[" _ @$[0-9]+ _ "]")? {
-      return index !== null ? [name, parseInt(index, 10)] : [name];
-    }
-
-booleanValue
-  = "@true" { return { kind: 'boolean', value: true }; }
-  / "@false" { return { kind: 'boolean', value: false }; }
-
-dateValue
-  = "@" date:$isoDate { return { kind: 'date', value: new Date(date) }; }
-
-// ISO 8601 date/datetime patterns
-isoDate
-  = [0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9] ("T" [0-9][0-9] ":" [0-9][0-9] (":" [0-9][0-9] ("." [0-9]+)?)? ("Z" / [+-] [0-9][0-9] ":"? [0-9][0-9])?)?
-
-numberValue
-  = n:numericLiteral { return { kind: 'number', value: parseFloat(n) }; }
-
-stringValue
-  = s:textString { return { kind: 'string', value: s }; }
-
-// Array: [element, element, ...]
-arrayValue
-  = "[" _ "]" { return { kind: 'array', elements: [] }; }
-  / "[" _ head:arrayElement tail:(_ "," _ @arrayElement)* _ ","? _ "]" {
-      return { kind: 'array', elements: [head, ...tail] };
-    }
-
-// Scalar value for array elements (typed)
-scalarValue
-  = booleanValue
-  / dateValue
-  / referenceValue
-  / numberValue
-  / s:textString { return { kind: 'string', value: s }; }
-
-// Array element: can be value, value with props, just props, or nested array
-arrayElement
-  = value:scalarValue _ props:properties {
-      return {
-        value,
-        properties: props.statements
-      };
-    }
-  / value:scalarValue {
-      return { value };
-    }
-  / props:properties {
-      return { properties: props.statements };
-    }
-  / value:arrayValue {
-      return { value };
-    }
-
-// Properties block: { ... } or { tagSpec* }
-properties
-  = "{" _ "..." _ "}" { return { dotty: true }; }
-  / "{" specs:(_ @tagSpec)* _ "}" { return { dotty: false, statements: specs }; }
-
-// Identifiers for property names
-identifier
-  = bqString
-  / bareString
-
-// String literals (text only, not numbers)
-textString
-  = tripleString
-  / sqString
-  / dqString
-  / bareString
-
-// Bare string: alphanumeric and underscore
-bareString
-  = chars:$[0-9A-Za-z_\u00C0-\u024F\u1E00-\u1EFF]+ { return chars; }
-
-// Triple-quoted string (multi-line allowed)
-tripleString
-  = '"""' chars:$([^"\\] / '"' !('""') / "\\" .)* '"""' { return parseEscapes(chars); }
-
-// Single-quoted string (no raw newlines)
-sqString
-  = "'" chars:$([^'\\\r\n] / "\\" .)* "'" { return parseEscapes(chars); }
-
-// Double-quoted string (no raw newlines)
-dqString
-  = '"' chars:$([^"\\\r\n] / "\\" .)* '"' { return parseEscapes(chars); }
-
-// Backtick-quoted string (for identifiers with special chars, no raw newlines)
-bqString
-  = '`' chars:$([^`\\\r\n] / "\\" .)* '`' { return parseEscapes(chars); }
-
-// Numeric literals
-numericLiteral
-  = $("-"? [0-9]* "." [0-9]+ ([Ee] [+-]? [0-9]+)?)
-  / $("-"? [0-9]+ ([Ee] [+-]? [0-9]+)?)
-
-// Whitespace and comments (required between some tokens, optional elsewhere)
-_ = ([ \t\r\n] / comment)*

package/src/peggy/statements.ts

@@ -1,49 +0,0 @@
-/*
- * Copyright Contributors to the Malloy project
- * SPDX-License-Identifier: MIT
- */
-
-/**
- * Intermediate representation for tag statements.
- * The Peggy parser outputs these, and the interpreter executes them to build a Tag.
- */
-
-// Scalar value types
-export type ScalarValue =
-  | {kind: 'string'; value: string}
-  | {kind: 'number'; value: number}
-  | {kind: 'boolean'; value: boolean}
-  | {kind: 'date'; value: Date}
-  | {kind: 'reference'; ups: number; path: (string | number)[]};
-
-// Values that can be assigned
-export type TagValue = ScalarValue | {kind: 'array'; elements: ArrayElement[]};
-
-export type ArrayElement = {
-  value?: TagValue;
-  properties?: TagStatement[];
-};
-
-// Operations the parser outputs
-export type TagStatement =
-  // name = value { properties }  or  name = value {...}
-  | {
-      kind: 'setEq';
-      path: string[];
-      value: TagValue;
-      properties?: TagStatement[];
-      preserveProperties?: boolean; // true when {...} is used
-    }
-  // name = { properties }  or  name = ... { properties }
-  | {
-      kind: 'replaceProperties';
-      path: string[];
-      properties: TagStatement[];
-      preserveValue: boolean; // true when ... is used
-    }
-  // name { properties }
-  | {kind: 'updateProperties'; path: string[]; properties: TagStatement[]}
-  // name  or  -name
-  | {kind: 'define'; path: string[]; deleted: boolean}
-  // -...
-  | {kind: 'clearAll'};