@traqula/parser-sparql-1-2 0.0.21 → 0.0.22

package/dist/cjs/lib/Parser.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Parser_exports = {};
+__export(Parser_exports, {
+  Parser: () => Parser,
+  sparql12ParserBuilder: () => sparql12ParserBuilder
+});
+module.exports = __toCommonJS(Parser_exports);
+var import_core = require("@traqula/core");
+var import_parser_sparql_1_1 = require("@traqula/parser-sparql-1-1");
+var import_rules_sparql_1_1 = require("@traqula/rules-sparql-1-1");
+var import_rules_sparql_1_2 = require("@traqula/rules-sparql-1-2");
+const sparql12ParserBuilder = import_core.ParserBuilder.create(import_parser_sparql_1_1.sparql11ParserBuilder).widenContext().typePatch().addMany(import_rules_sparql_1_2.gram.reifiedTripleBlock, import_rules_sparql_1_2.gram.reifiedTripleBlockPath, import_rules_sparql_1_2.gram.reifier, import_rules_sparql_1_2.gram.varOrReifierId, import_rules_sparql_1_2.gram.annotation, import_rules_sparql_1_2.gram.annotationPath, import_rules_sparql_1_2.gram.annotationBlockPath, import_rules_sparql_1_2.gram.annotationBlock, import_rules_sparql_1_2.gram.reifiedTriple, import_rules_sparql_1_2.gram.reifiedTripleSubject, import_rules_sparql_1_2.gram.reifiedTripleObject, import_rules_sparql_1_2.gram.tripleTerm, import_rules_sparql_1_2.gram.tripleTermSubject, import_rules_sparql_1_2.gram.tripleTermObject, import_rules_sparql_1_2.gram.tripleTermData, import_rules_sparql_1_2.gram.tripleTermDataSubject, import_rules_sparql_1_2.gram.tripleTermDataObject, import_rules_sparql_1_2.gram.exprTripleTerm, import_rules_sparql_1_2.gram.exprTripleTermSubject, import_rules_sparql_1_2.gram.exprTripleTermObject).addMany(import_rules_sparql_1_2.gram.versionDecl, import_rules_sparql_1_2.gram.versionSpecifier).addMany(import_rules_sparql_1_2.gram.buildInLangDir, import_rules_sparql_1_2.gram.buildInLangStrDir, import_rules_sparql_1_2.gram.buildInHasLang, import_rules_sparql_1_2.gram.buildInHasLangDir, import_rules_sparql_1_2.gram.buildInIsTriple, import_rules_sparql_1_2.gram.buildInTriple, import_rules_sparql_1_2.gram.buildInSubject, import_rules_sparql_1_2.gram.buildInPredicate, import_rules_sparql_1_2.gram.buildInObject).patchRule(import_rules_sparql_1_2.gram.dataBlockValue).patchRule(import_rules_sparql_1_2.gram.triplesSameSubject).patchRule(import_rules_sparql_1_2.gram.triplesSameSubjectPath).patchRule(import_rules_sparql_1_2.gram.object).patchRule(import_rules_sparql_1_2.gram.objectPath).patchRule(import_rules_sparql_1_2.gram.graphNode).patchRule(import_rules_sparql_1_2.gram.graphNodePath).patchRule(import_rules_sparql_1_2.gram.varOrTerm).deleteRule(import_rules_sparql_1_1.gram.graphTerm.name).patchRule(import_rules_sparql_1_2.gram.primaryExpression).patchRule(import_rules_sparql_1_2.gram.builtInCall).patchRule(import_rules_sparql_1_2.gram.rdfLiteral).patchRule(import_rules_sparql_1_2.gram.unaryExpression).patchRule(import_rules_sparql_1_2.gram.prologue);
+class Parser {
+  parser;
+  F = new import_rules_sparql_1_2.AstFactory();
+  constructor(args = {}) {
+    this.parser = sparql12ParserBuilder.build({
+      ...args,
+      queryPreProcessor: import_rules_sparql_1_1.sparqlCodepointEscape,
+      tokenVocabulary: import_rules_sparql_1_2.lex.sparql12LexerBuilder.tokenVocabulary
+    });
+  }
+  parse(query, context = {}) {
+    return this.parser.queryOrUpdate(query, (0, import_rules_sparql_1_2.completeParseContext)(context));
+  }
+  parsePath(query, context = {}) {
+    const res = this.parser.path(query, (0, import_rules_sparql_1_2.completeParseContext)(context));
+    if (this.F.isPathPure(res)) {
+      return {
+        ...res,
+        prefixes: {}
+      };
+    }
+    return res;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parser,
+  sparql12ParserBuilder
+});

package/dist/cjs/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+module.exports = __toCommonJS(lib_exports);
+__reExport(lib_exports, require("./Parser.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Parser.js")
+});

package/dist/cjs/spec/parser.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parser_exports = {};
+__export(parser_exports, {
+  parse: () => parse,
+  query: () => query,
+  update: () => update
+});
+module.exports = __toCommonJS(parser_exports);
+var import_rdf_test_suite = require("rdf-test-suite");
+var import_lib = require("../lib/index.js");
+function parse(query2, context = {}) {
+  const parser = new import_lib.Parser();
+  parser.parse(query2, context);
+}
+function query() {
+  return Promise.reject(new import_rdf_test_suite.ErrorSkipped("Querying is not supported"));
+}
+function update() {
+  return Promise.reject(new import_rdf_test_suite.ErrorSkipped("Updating is not supported"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parse,
+  query,
+  update
+});

package/dist/cjs/test/query.bench.js

@@ -0,0 +1,22 @@
+"use strict";
+var import_test_utils = require("@traqula/test-utils");
+var import_sparqljs = require("sparqljs");
+var import_vitest = require("vitest");
+var import_lib = require("../lib/index.js");
+(0, import_vitest.describe)("query 1.2, exclude construction", () => {
+  const traqulaParser = new import_lib.Parser();
+  const sparqlJSparser = new import_sparqljs.Parser();
+  (0, import_vitest.describe)("general queries", async () => {
+    const allQueries = await Promise.all([...(0, import_test_utils.positiveTest)("sparql-1-1")].map((x) => x.statics().then((x2) => x2.query)));
+    (0, import_vitest.bench)("traqula parse 1.2", () => {
+      for (const query of allQueries) {
+        traqulaParser.parse(query);
+      }
+    });
+    (0, import_vitest.bench)("sparqljs", () => {
+      for (const query of allQueries) {
+        sparqlJSparser.parse(query);
+      }
+    });
+  });
+});

package/dist/cjs/test/statics.test.js

@@ -0,0 +1,113 @@
+"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 __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 import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_rules_sparql_1_2 = require("@traqula/rules-sparql-1-2");
+var import_test_utils = require("@traqula/test-utils");
+var import_rdf_data_factory = require("rdf-data-factory");
+var import_vitest = require("vitest");
+var import_lib = require("../lib/index.js");
+(0, import_vitest.describe)("a SPARQL 1.2 parser", () => {
+  const parser = new import_lib.Parser();
+  const F = new import_rules_sparql_1_2.AstFactory();
+  const context = { prefixes: { ex: "http://example.org/" } };
+  function _sinkAst(suite, test, response) {
+    const dir = (0, import_test_utils.getStaticFilePath)();
+    const fileLoc = import_node_path.default.join(dir, suite, `${test}.json`);
+    import_node_fs.default.writeFileSync(fileLoc, JSON.stringify(response, null, 2));
+  }
+  (0, import_vitest.it)("passes chevrotain validation", () => {
+    import_lib.sparql12ParserBuilder.build({
+      tokenVocabulary: import_rules_sparql_1_2.lex.sparql12LexerBuilder.tokenVocabulary,
+      lexerConfig: {
+        skipValidations: false,
+        ensureOptimizations: true
+      },
+      parserConfig: {
+        skipValidations: false
+      }
+    });
+  });
+  (0, import_vitest.describe)("positive paths", () => {
+    for (const { name, statics } of (0, import_test_utils.positiveTest)("paths")) {
+      (0, import_vitest.it)(`can parse ${name}`, async ({ expect }) => {
+        const { query, ast } = await statics();
+        const res = parser.parsePath(query, context);
+        expect(res).toEqualParsedQuery(ast);
+      });
+    }
+  });
+  (0, import_vitest.describe)("positive sparql 1.1", () => {
+    for (const { name, statics } of (0, import_test_utils.positiveTest)("sparql-1-1")) {
+      (0, import_vitest.it)(`can parse ${name}`, async ({ expect }) => {
+        const { query, ast } = await statics();
+        const res = parser.parse(query, context);
+        expect(res).toEqualParsedQueryIgnoring((obj) => F.isTriple(obj), ["annotations"], ast);
+      });
+    }
+  });
+  (0, import_vitest.describe)("negative SPARQL 1.1", () => {
+    for (const { name, statics } of (0, import_test_utils.negativeTest)("sparql-1-1-invalid")) {
+      (0, import_vitest.it)(`should NOT parse ${name}`, async ({ expect }) => {
+        const { query } = await statics();
+        expect(() => parser.parse(query, context)).toThrow();
+      });
+    }
+  });
+  (0, import_vitest.describe)("positive sparql 1.2", () => {
+    for (const { name, statics } of (0, import_test_utils.positiveTest)("sparql-1-2")) {
+      (0, import_vitest.it)(`can parse ${name}`, async ({ expect }) => {
+        const { query, ast } = await statics();
+        const res = parser.parse(query, context);
+        expect(res).toEqualParsedQuery(ast);
+      });
+    }
+  });
+  (0, import_vitest.it)(`should NOT parse $only thing}`, async ({ expect }) => {
+    const query = `
+    PREFIX : <http://example.com/ns#>
+
+SELECT * WHERE {
+   <<( ?s ?p ?o )>> .
+}
+    `;
+    expect(() => parser.parse(query)).toThrow();
+  });
+  (0, import_vitest.describe)("negative sparql 1.2", () => {
+    const skip = /* @__PURE__ */ new Set([
+      "sparql-1-2-syntax-basic-tripleterm-subject",
+      "sparql-1-2-syntax-compound-tripleterm-subject",
+      "sparql-1-2-syntax-subject-tripleterm"
+    ]);
+    for (const { name, statics } of (0, import_test_utils.negativeTest)("sparql-1-2-invalid", (name2) => !skip.has(name2))) {
+      (0, import_vitest.it)(`should NOT parse ${name}`, async ({ expect }) => {
+        const { query } = await statics();
+        expect(() => parser.parse(query, context)).toThrow();
+      });
+    }
+  });
+  (0, import_vitest.describe)("specific sparql 1.1 tests", () => {
+    (0, import_test_utils.importSparql11NoteTests)(parser, new import_rdf_data_factory.DataFactory());
+  });
+});