@traqula/parser-sparql-1-1-adjust 0.0.21 → 0.0.23

package/dist/cjs/lib/Parser.js

@@ -0,0 +1,46 @@
+"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,
+  adjustLexerBuilder: () => adjustLexerBuilder,
+  adjustParserBuilder: () => adjustParserBuilder
+});
+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_1_adjust = require("@traqula/rules-sparql-1-1-adjust");
+const adjustParserBuilder = import_core.ParserBuilder.create(import_parser_sparql_1_1.sparql11ParserBuilder).typePatch().addRule(import_rules_sparql_1_1_adjust.gram.builtInAdjust).patchRule(import_rules_sparql_1_1_adjust.gram.builtInPatch);
+const adjustLexerBuilder = import_core.LexerBuilder.create(import_rules_sparql_1_1.lex.sparql11LexerBuilder).addBefore(import_rules_sparql_1_1.lex.a, import_rules_sparql_1_1_adjust.lex.BuiltInAdjust);
+class Parser extends import_rules_sparql_1_1.MinimalSparqlParser {
+  constructor() {
+    const parser = adjustParserBuilder.build({
+      tokenVocabulary: adjustLexerBuilder.tokenVocabulary,
+      queryPreProcessor: import_rules_sparql_1_1.sparqlCodepointEscape
+    });
+    super(parser);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parser,
+  adjustLexerBuilder,
+  adjustParserBuilder
+});

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/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

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/statics.test.js

@@ -0,0 +1,59 @@
+"use strict";
+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.1 + adjust parser", () => {
+  const parser = new import_lib.Parser();
+  const context = { prefixes: { ex: "http://example.org/" } };
+  (0, import_vitest.it)("passes chevrotain validation", () => {
+    import_lib.adjustParserBuilder.build({
+      tokenVocabulary: import_lib.adjustLexerBuilder.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).toEqualParsedQuery(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)("specific sparql 1.1 tests", () => {
+    (0, import_test_utils.importSparql11NoteTests)(parser, new import_rdf_data_factory.DataFactory());
+  });
+  (0, import_vitest.it)("parses ADJUST function", ({ expect }) => {
+    const query = `
+SELECT ?s ?p (ADJUST(?o, "-PT10H"^^<http://www.w3.org/2001/XMLSchema#dayTimeDuration>) as ?adjusted) WHERE {
+  ?s ?p ?o
+}
+`;
+    const res = parser.parse(query);
+    expect(res).toMatchObject({});
+  });
+});