@traqula/rules-sparql-1-1 0.0.21 → 0.0.23

package/dist/cjs/lib/grammar/updateUnit.js

@@ -0,0 +1,546 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateUnit_exports = {};
+__export(updateUnit_exports, {
+  add: () => add,
+  clear: () => clear,
+  copy: () => copy,
+  create: () => create,
+  deleteClause: () => deleteClause,
+  deleteData: () => deleteData,
+  deleteWhere: () => deleteWhere,
+  drop: () => drop,
+  graphOrDefault: () => graphOrDefault,
+  graphRef: () => graphRef,
+  graphRefAll: () => graphRefAll,
+  insertClause: () => insertClause,
+  insertData: () => insertData,
+  load: () => load,
+  modify: () => modify,
+  move: () => move,
+  quadData: () => quadData,
+  quadPattern: () => quadPattern,
+  quads: () => quads,
+  quadsNotTriples: () => quadsNotTriples,
+  update: () => update,
+  update1: () => update1,
+  updateUnit: () => updateUnit
+});
+module.exports = __toCommonJS(updateUnit_exports);
+var import_core = require("@traqula/core");
+var l = __toESM(require("../lexer/index.js"), 1);
+var import_validators = require("../validation/validators.js");
+var import_dataSetClause = require("./dataSetClause.js");
+var import_general = require("./general.js");
+var import_literals = require("./literals.js");
+var import_tripleBlock = require("./tripleBlock.js");
+var import_whereClause = require("./whereClause.js");
+const updateUnit = {
+  name: "updateUnit",
+  impl: ({ SUBRULE }) => () => SUBRULE(update)
+};
+const update = {
+  name: "update",
+  impl: ({ ACTION, SUBRULE, SUBRULE1, SUBRULE2, CONSUME, OPTION1, MANY }) => (C) => {
+    const updates = [];
+    const prologueValues = SUBRULE1(import_general.prologue);
+    updates.push({ context: prologueValues });
+    let parsedSemi = true;
+    MANY({
+      GATE: () => parsedSemi,
+      DEF: () => {
+        parsedSemi = false;
+        updates.at(-1).operation = SUBRULE(update1);
+        OPTION1(() => {
+          CONSUME(l.symbols.semi);
+          parsedSemi = true;
+          const innerPrologue = SUBRULE2(import_general.prologue);
+          updates.push({ context: innerPrologue });
+        });
+      }
+    });
+    return ACTION(() => {
+      const update2 = {
+        type: "update",
+        updates,
+        loc: C.astFactory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation)
+      };
+      (0, import_validators.updateNoReuseBlankNodeLabels)(update2);
+      return update2;
+    });
+  },
+  gImpl: ({ SUBRULE, PRINT, NEW_LINE }) => (ast, { astFactory: F }) => {
+    const [head, ...tail] = ast.updates;
+    if (head) {
+      SUBRULE(import_general.prologue, head.context);
+      if (head.operation) {
+        SUBRULE(update1, head.operation);
+      }
+    }
+    for (const update2 of tail) {
+      F.printFilter(ast, () => {
+        PRINT(";");
+        NEW_LINE();
+      });
+      SUBRULE(import_general.prologue, update2.context);
+      if (update2.operation) {
+        SUBRULE(update1, update2.operation);
+      }
+    }
+  }
+};
+const update1 = {
+  name: "update1",
+  impl: ({ SUBRULE, OR }) => () => OR([
+    { ALT: () => SUBRULE(load) },
+    { ALT: () => SUBRULE(clear) },
+    { ALT: () => SUBRULE(drop) },
+    { ALT: () => SUBRULE(add) },
+    { ALT: () => SUBRULE(move) },
+    { ALT: () => SUBRULE(copy) },
+    { ALT: () => SUBRULE(create) },
+    { ALT: () => SUBRULE(insertData) },
+    { ALT: () => SUBRULE(deleteData) },
+    { ALT: () => SUBRULE(deleteWhere) },
+    { ALT: () => SUBRULE(modify) }
+  ]),
+  gImpl: ({ SUBRULE }) => (ast) => {
+    switch (ast.subType) {
+      case "load":
+        SUBRULE(load, ast);
+        break;
+      case "clear":
+        SUBRULE(clear, ast);
+        break;
+      case "drop":
+        SUBRULE(drop, ast);
+        break;
+      case "add":
+        SUBRULE(add, ast);
+        break;
+      case "move":
+        SUBRULE(move, ast);
+        break;
+      case "copy":
+        SUBRULE(copy, ast);
+        break;
+      case "create":
+        SUBRULE(create, ast);
+        break;
+      case "insertdata":
+        SUBRULE(insertData, ast);
+        break;
+      case "deletedata":
+        SUBRULE(deleteData, ast);
+        break;
+      case "deletewhere":
+        SUBRULE(deleteWhere, ast);
+        break;
+      case "modify":
+        SUBRULE(modify, ast);
+        break;
+    }
+  }
+};
+const load = {
+  name: "load",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION1, OPTION2 }) => (C) => {
+    const loadToken = CONSUME(l.load);
+    const silent = OPTION1(() => CONSUME(l.silent));
+    const source = SUBRULE1(import_literals.iri);
+    const destination = OPTION2(() => {
+      CONSUME(l.loadInto);
+      return SUBRULE1(graphRef);
+    });
+    return ACTION(() => C.astFactory.updateOperationLoad(C.astFactory.sourceLocation(loadToken, source, destination), source, Boolean(silent), destination));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("LOAD ");
+      if (ast.silent) {
+        PRINT_WORD("SILENT");
+      }
+    });
+    SUBRULE(import_literals.iri, ast.source);
+    if (ast.destination) {
+      F.printFilter(ast, () => PRINT_WORD("INTO"));
+      SUBRULE(graphRefAll, ast.destination);
+    }
+  }
+};
+function clearOrDrop(operation) {
+  return {
+    name: (0, import_core.unCapitalize)(operation.name),
+    impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+      const opToken = CONSUME(operation);
+      const silent = OPTION(() => CONSUME(l.silent));
+      const destination = SUBRULE1(graphRefAll);
+      return ACTION(() => C.astFactory.updateOperationClearDrop((0, import_core.unCapitalize)(operation.name), Boolean(silent), destination, C.astFactory.sourceLocation(opToken, destination)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+      F.printFilter(ast, () => {
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
+        if (ast.silent) {
+          PRINT_WORD("SILENT");
+        }
+      });
+      SUBRULE(graphRefAll, ast.destination);
+    }
+  };
+}
+const clear = clearOrDrop(l.clear);
+const drop = clearOrDrop(l.drop);
+const create = {
+  name: "create",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+    const createToken = CONSUME(l.create);
+    const silent = OPTION(() => CONSUME(l.silent));
+    const destination = SUBRULE1(graphRef);
+    return ACTION(() => C.astFactory.updateOperationCreate(destination, Boolean(silent), C.astFactory.sourceLocation(createToken, destination)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => {
+      PRINT_ON_EMPTY("CREATE ");
+      if (ast.silent) {
+        PRINT_WORD("SILENT");
+      }
+    });
+    SUBRULE(graphRefAll, ast.destination);
+  }
+};
+function copyMoveAddOperation(operation) {
+  return {
+    name: (0, import_core.unCapitalize)(operation.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION }) => (C) => {
+      const op = CONSUME(operation);
+      const silent = OPTION(() => CONSUME(l.silent));
+      const source = SUBRULE1(graphOrDefault);
+      CONSUME(l.to);
+      const destination = SUBRULE2(graphOrDefault);
+      return ACTION(() => C.astFactory.updateOperationAddMoveCopy((0, import_core.unCapitalize)(operation.name), source, destination, Boolean(silent), C.astFactory.sourceLocation(op, destination)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY }) => (ast, { astFactory: F }) => {
+      F.printFilter(ast, () => {
+        PRINT_ON_EMPTY(operation.name.toUpperCase(), " ");
+        if (ast.silent) {
+          PRINT_WORD("SILENT");
+        }
+      });
+      SUBRULE(graphRefAll, ast.source);
+      F.printFilter(ast, () => PRINT_WORD("TO"));
+      SUBRULE(graphRefAll, ast.destination);
+    }
+  };
+}
+const add = copyMoveAddOperation(l.add);
+const move = copyMoveAddOperation(l.move);
+const copy = copyMoveAddOperation(l.copy);
+const quadPattern = {
+  name: "quadPattern",
+  impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
+    const open = CONSUME(l.symbols.LCurly);
+    const val = SUBRULE1(quads);
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
+  }
+};
+const quadData = {
+  name: "quadData",
+  impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
+    const open = CONSUME(l.symbols.LCurly);
+    const couldParseVars = ACTION(() => C.parseMode.delete("canParseVars"));
+    const val = SUBRULE1(quads);
+    ACTION(() => couldParseVars && C.parseMode.add("canParseVars"));
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.wrap(val.val, C.astFactory.sourceLocation(open, close)));
+  }
+};
+function insertDeleteDelWhere(name, subType, cons1, dataRule) {
+  return {
+    name,
+    impl: ({ ACTION, SUBRULE1, CONSUME }) => (C) => {
+      const insDelToken = CONSUME(cons1);
+      let couldCreateBlankNodes = true;
+      if (name !== "insertData") {
+        couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
+      }
+      const data = SUBRULE1(dataRule);
+      if (name !== "insertData") {
+        ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
+      }
+      return ACTION(() => C.astFactory.updateOperationInsDelDataWhere(subType, data.val, C.astFactory.sourceLocation(insDelToken, data)));
+    },
+    gImpl: ({ SUBRULE, PRINT_WORD, PRINT_ON_EMPTY, PRINT_ON_OWN_LINE, NEW_LINE }) => (ast, C) => {
+      const { astFactory: F, indentInc } = C;
+      F.printFilter(ast, () => {
+        if (subType === "insertdata") {
+          PRINT_ON_EMPTY("INSERT DATA ");
+        } else if (subType === "deletedata") {
+          PRINT_ON_EMPTY("DELETE DATA ");
+        } else if (subType === "deletewhere") {
+          PRINT_ON_EMPTY("DELETE WHERE ");
+        }
+        C[import_core.traqulaIndentation] += indentInc;
+        PRINT_WORD("{");
+        NEW_LINE();
+      });
+      SUBRULE(quads, F.wrap(ast.data, ast.loc));
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] -= indentInc;
+        PRINT_ON_OWN_LINE("}");
+      });
+    }
+  };
+}
+const insertData = insertDeleteDelWhere("insertData", "insertdata", l.insertDataClause, quadData);
+const deleteData = insertDeleteDelWhere("deleteData", "deletedata", l.deleteDataClause, quadData);
+const deleteWhere = insertDeleteDelWhere("deleteWhere", "deletewhere", l.deleteWhereClause, quadPattern);
+const modify = {
+  name: "modify",
+  impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OR }) => (C) => {
+    const graph = OPTION1(() => {
+      const withToken = CONSUME(l.modifyWith);
+      const graph2 = SUBRULE1(import_literals.iri);
+      return { withToken, graph: graph2 };
+    });
+    const { insert, del } = OR([
+      { ALT: () => {
+        const del2 = SUBRULE1(deleteClause);
+        const insert2 = OPTION2(() => SUBRULE1(insertClause));
+        return { del: del2, insert: insert2 };
+      } },
+      { ALT: () => {
+        const insert2 = SUBRULE2(insertClause);
+        return { insert: insert2, del: void 0 };
+      } }
+    ]);
+    const using = SUBRULE1(import_dataSetClause.usingClauseStar);
+    CONSUME(l.where);
+    const where = SUBRULE1(import_whereClause.groupGraphPattern);
+    return ACTION(() => C.astFactory.updateOperationModify(C.astFactory.sourceLocation(graph?.withToken, del, insert, where), insert?.val ?? [], del?.val ?? [], where, using, graph?.graph));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORDS, PRINT_ON_EMPTY, NEW_LINE }) => (ast, C) => {
+    const { astFactory: F, indentInc } = C;
+    if (ast.graph) {
+      F.printFilter(ast, () => PRINT_WORDS("WITH"));
+      SUBRULE(import_literals.iri, ast.graph);
+    }
+    if (ast.delete.length > 0) {
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] += indentInc;
+        PRINT_WORDS("DELETE", "{");
+        NEW_LINE();
+      });
+      SUBRULE(quads, F.wrap(ast.delete, ast.loc));
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("}");
+        NEW_LINE();
+      });
+    }
+    if (ast.insert.length > 0) {
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] += indentInc;
+        PRINT_WORDS("INSERT", "{");
+        NEW_LINE();
+      });
+      SUBRULE(quads, F.wrap(ast.insert, ast.loc));
+      F.printFilter(ast, () => {
+        C[import_core.traqulaIndentation] -= indentInc;
+        PRINT_ON_EMPTY("} ");
+        NEW_LINE();
+      });
+    }
+    SUBRULE(import_dataSetClause.usingClauseStar, ast.from);
+    F.printFilter(ast, () => PRINT_WORDS("WHERE"));
+    SUBRULE(import_whereClause.groupGraphPattern, ast.where);
+  }
+};
+const deleteClause = {
+  name: "deleteClause",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const delToken = CONSUME(l.deleteClause);
+    const couldCreateBlankNodes = ACTION(() => C.parseMode.delete("canCreateBlankNodes"));
+    const del = SUBRULE(quadPattern);
+    ACTION(() => couldCreateBlankNodes && C.parseMode.add("canCreateBlankNodes"));
+    return ACTION(() => C.astFactory.wrap(del.val, C.astFactory.sourceLocation(delToken, del)));
+  }
+};
+const insertClause = {
+  name: "insertClause",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const insertToken = CONSUME(l.insertClause);
+    const insert = SUBRULE(quadPattern);
+    return ACTION(() => C.astFactory.wrap(insert.val, C.astFactory.sourceLocation(insertToken, insert)));
+  }
+};
+const graphOrDefault = {
+  name: "graphOrDefault",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION, OR }) => (C) => OR([
+    { ALT: () => {
+      const def = CONSUME(l.graph.default_);
+      return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
+    } },
+    { ALT: () => {
+      const graph = OPTION(() => CONSUME(l.graph.graph));
+      const name = SUBRULE1(import_literals.iri);
+      return ACTION(() => C.astFactory.graphRefSpecific(name, C.astFactory.sourceLocation(graph, name)));
+    } }
+  ])
+};
+const graphRef = {
+  name: "graphRef",
+  impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+    const graph = CONSUME(l.graph.graph);
+    const val = SUBRULE(import_literals.iri);
+    return ACTION(() => C.astFactory.graphRefSpecific(val, C.astFactory.sourceLocation(graph, val)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    F.printFilter(ast, () => PRINT_WORD("GRAPH"));
+    SUBRULE(import_literals.iri, ast.graph);
+  }
+};
+const graphRefAll = {
+  name: "graphRefAll",
+  impl: ({ ACTION, SUBRULE, CONSUME, OR }) => (C) => OR([
+    { ALT: () => SUBRULE(graphRef) },
+    { ALT: () => {
+      const def = CONSUME(l.graph.default_);
+      return ACTION(() => C.astFactory.graphRefDefault(C.astFactory.sourceLocation(def)));
+    } },
+    { ALT: () => {
+      const named = CONSUME(l.graph.named);
+      return ACTION(() => C.astFactory.graphRefNamed(C.astFactory.sourceLocation(named)));
+    } },
+    { ALT: () => {
+      const graphAll = CONSUME(l.graph.graphAll);
+      return ACTION(() => C.astFactory.graphRefAll(C.astFactory.sourceLocation(graphAll)));
+    } }
+  ]),
+  gImpl: ({ SUBRULE, PRINT_WORD }) => (ast, { astFactory: F }) => {
+    if (F.isGraphRefSpecific(ast)) {
+      SUBRULE(graphRef, ast);
+    } else if (F.isGraphRefDefault(ast)) {
+      F.printFilter(ast, () => PRINT_WORD("DEFAULT"));
+    } else if (F.isGraphRefNamed(ast)) {
+      F.printFilter(ast, () => PRINT_WORD("NAMED"));
+    } else if (F.isGraphRefAll(ast)) {
+      F.printFilter(ast, () => PRINT_WORD("ALL"));
+    }
+  }
+};
+const quads = {
+  name: "quads",
+  impl: ({ ACTION, SUBRULE, CONSUME, MANY, SUBRULE1, SUBRULE2, OPTION1, OPTION2, OPTION3 }) => (C) => {
+    const quads2 = [];
+    let last;
+    OPTION1(() => {
+      const triples = SUBRULE1(import_tripleBlock.triplesTemplate);
+      last = triples;
+      ACTION(() => quads2.push(triples));
+    });
+    MANY(() => {
+      const notTriples = SUBRULE(quadsNotTriples);
+      last = notTriples;
+      quads2.push(notTriples);
+      OPTION2(() => {
+        const dotToken = CONSUME(l.symbols.dot);
+        last = dotToken;
+        return dotToken;
+      });
+      OPTION3(() => {
+        const triples = SUBRULE2(import_tripleBlock.triplesTemplate);
+        last = triples;
+        ACTION(() => quads2.push(triples));
+      });
+    });
+    return ACTION(() => C.astFactory.wrap(quads2, C.astFactory.sourceLocation(quads2.at(0), last)));
+  },
+  gImpl: ({ SUBRULE }) => (ast, { astFactory: F }) => {
+    for (const quad of ast.val) {
+      if (F.isPattern(quad)) {
+        SUBRULE(import_tripleBlock.triplesBlock, quad);
+      } else {
+        SUBRULE(quadsNotTriples, quad);
+      }
+    }
+  }
+};
+const quadsNotTriples = {
+  name: "quadsNotTriples",
+  impl: ({ ACTION, SUBRULE1, CONSUME, OPTION }) => (C) => {
+    const graph = CONSUME(l.graph.graph);
+    const name = SUBRULE1(import_general.varOrIri);
+    CONSUME(l.symbols.LCurly);
+    const triples = OPTION(() => SUBRULE1(import_tripleBlock.triplesTemplate));
+    const close = CONSUME(l.symbols.RCurly);
+    return ACTION(() => C.astFactory.graphQuads(name, triples ?? C.astFactory.patternBgp([], C.astFactory.sourceLocationNoMaterialize()), C.astFactory.sourceLocation(graph, close)));
+  },
+  gImpl: ({ SUBRULE, PRINT_WORD, NEW_LINE, PRINT_ON_OWN_LINE }) => (ast, C) => {
+    const { astFactory: F, indentInc } = C;
+    F.printFilter(ast, () => PRINT_WORD("GRAPH"));
+    SUBRULE(import_general.varOrTerm, ast.graph);
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] += indentInc;
+      PRINT_WORD("{");
+      NEW_LINE();
+    });
+    SUBRULE(import_tripleBlock.triplesBlock, ast.triples);
+    F.printFilter(ast, () => {
+      C[import_core.traqulaIndentation] -= indentInc;
+      PRINT_ON_OWN_LINE("}");
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  add,
+  clear,
+  copy,
+  create,
+  deleteClause,
+  deleteData,
+  deleteWhere,
+  drop,
+  graphOrDefault,
+  graphRef,
+  graphRefAll,
+  insertClause,
+  insertData,
+  load,
+  modify,
+  move,
+  quadData,
+  quadPattern,
+  quads,
+  quadsNotTriples,
+  update,
+  update1,
+  updateUnit
+});