reinstate parser test files

Author: jitsedesmet

engines/parser-sparql-1-1/lib/Parser.ts

@@ -0,0 +1,33 @@
+import { Builder } from '@traqula/core';
+import type { SparqlQuery, SparqlGrammarRule } from '@traqula/rules-sparql-1-1';
+import { lex as l, SparqlParser, gram } from '@traqula/rules-sparql-1-1';
+import { queryUnitParserBuilder } from './queryUnitParser';
+import { updateParserBuilder } from './updateUnitParser';
+
+/**
+ * Query or update, optimized for the Query case.
+ * One could implement a new rule that does not use BACKTRACK.
+ */
+const queryOrUpdate: SparqlGrammarRule<'queryOrUpdate', SparqlQuery> = {
+  name: 'queryOrUpdate',
+  impl: ({ SUBRULE, OR, BACKTRACK }) => () => OR<SparqlQuery>([
+    { GATE: BACKTRACK(gram.queryUnit, undefined), ALT: () => SUBRULE(gram.queryUnit, undefined) },
+    { ALT: () => SUBRULE(gram.updateUnit, undefined) },
+  ]),
+};
+
+export const sparql11ParserBuilder = Builder.createBuilder(queryUnitParserBuilder)
+  .merge(updateParserBuilder, <const> [])
+  .addRule(queryOrUpdate);
+
+export class Parser extends SparqlParser<SparqlQuery> {
+  public constructor() {
+    const parser = sparql11ParserBuilder.consumeToParser({
+      tokenVocabulary: l.sparql11Tokens.build(),
+    });
+    super({
+      path: parser.path,
+      query: parser.queryOrUpdate,
+    });
+  }
+}

engines/parser-sparql-1-1/lib/expressionParser.ts

@@ -0,0 +1,100 @@
+import { Builder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+
+const rulesNoBuiltIn = <const> [
+  gram.expression,
+  gram.conditionalOrExpression,
+  gram.conditionalAndExpression,
+  gram.valueLogical,
+  gram.relationalExpression,
+  gram.numericExpression,
+  gram.expressionList,
+  gram.additiveExpression,
+  gram.multiplicativeExpression,
+  gram.unaryExpression,
+  gram.primaryExpression,
+  gram.brackettedExpression,
+  // BuiltInCall,
+  gram.iriOrFunction,
+  gram.rdfLiteral,
+  gram.numericLiteral,
+  gram.numericLiteralUnsigned,
+  gram.numericLiteralPositive,
+  gram.numericLiteralNegative,
+  gram.booleanLiteral,
+  gram.var_,
+  gram.builtInStr,
+  gram.builtInLang,
+  gram.builtInLangmatches,
+  gram.builtInDatatype,
+  gram.builtInBound,
+  gram.builtInIri,
+  gram.builtInUri,
+  gram.builtInBnodeSparqlJs,
+  gram.builtInRand,
+  gram.builtInAbs,
+  gram.builtInCeil,
+  gram.builtInFloor,
+  gram.builtInRound,
+  gram.builtInConcat,
+  gram.builtInStrlen,
+  gram.builtInUcase,
+  gram.builtInLcase,
+  gram.builtInEncode_for_uri,
+];
+
+const builtInPatch: typeof gram.builtInCall = {
+  name: 'builtInCall',
+  impl: ({ OR, SUBRULE }) => () => OR(gram.builtInCallList(SUBRULE).slice(0, -2)),
+};
+
+export const expressionParserBuilder = Builder.createBuilder(rulesNoBuiltIn)
+  .addMany(
+    gram.builtInContains,
+    gram.builtInStrstarts,
+    gram.builtInStrends,
+    gram.builtInStrbefore,
+    gram.builtInStrafter,
+    gram.builtInYear,
+    gram.builtInMonth,
+    gram.builtInDay,
+    gram.builtInHours,
+    gram.builtInMinutes,
+    gram.builtInSeconds,
+    gram.builtInTimezone,
+    gram.builtInTz,
+    gram.builtInNow,
+    gram.builtInUuid,
+    gram.builtInStruuid,
+    gram.builtInMd5,
+    gram.builtInSha1,
+    gram.builtInSha256,
+    gram.builtInSha384,
+    gram.builtInSha512,
+    gram.builtInCoalesce,
+    gram.builtInIf,
+    gram.builtInStrlang,
+    gram.builtInStrdt,
+    gram.builtInSameterm,
+    gram.builtInIsiri,
+    gram.builtInIsuri,
+    gram.builtInIsblank,
+    gram.builtInIsliteral,
+    gram.builtInIsnumeric,
+    gram.regexExpression,
+    gram.substringExpression,
+    gram.strReplaceExpression,
+    gram.aggregateCount,
+    gram.aggregateSum,
+    gram.aggregateMin,
+    gram.aggregateMax,
+    gram.aggregateAvg,
+    gram.aggregateSample,
+    gram.aggregateGroup_concat,
+    gram.aggregate,
+    gram.iri,
+    gram.prefixedName,
+    gram.argList,
+    gram.string,
+  )
+  .addRule(builtInPatch);

engines/parser-sparql-1-1/lib/index.ts

@@ -1,3 +1,9 @@
+export * from './expressionParser';
 export * from './objectListParser';
+export * from './queryUnitParser';
+export * from './Parser';
+export * from './subSelectParser';
 export * from './triplesBlockParser';
 export * from './triplesTemplateParserBuilder';
+export * from './updateNoModifyParser';
+export * from './updateUnitParser';

engines/parser-sparql-1-1/lib/queryUnitParser.ts

@@ -0,0 +1,30 @@
+import { Builder } from '@traqula/core';
+import { gram, lex } from '@traqula/rules-sparql-1-1';
+import { subSelectParserBuilder } from './subSelectParser';
+import { triplesTemplateParserBuilder } from './triplesTemplateParserBuilder';
+
+const rules = <const> [
+  gram.queryUnit,
+  gram.query,
+  gram.prologue,
+  gram.selectQuery,
+  gram.constructQuery,
+  gram.describeQuery,
+  gram.askQuery,
+  gram.valuesClause,
+  gram.baseDecl,
+  gram.prefixDecl,
+];
+
+export const queryUnitParserBuilder = Builder.createBuilder(rules)
+  // Select Query
+  .merge(subSelectParserBuilder, <const> [])
+  .addRule(gram.datasetClause)
+  .addRule(gram.datasetClauseStar)
+  .addRule(gram.defaultGraphClause)
+  .addRule(gram.namedGraphClause)
+  .addRule(gram.sourceSelector)
+  // Construct Query
+  .addRule(gram.constructTemplate)
+  .merge(triplesTemplateParserBuilder, <const> [])
+  .addRule(gram.constructTriples);

engines/parser-sparql-1-1/lib/subSelectParser.ts

@@ -0,0 +1,50 @@
+import { Builder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+import { expressionParserBuilder } from './expressionParser';
+import { triplesBlockParserBuilder } from './triplesBlockParser';
+
+const rules = <const> [
+  gram.subSelect,
+  gram.selectClause,
+  gram.whereClause,
+  gram.solutionModifier,
+  gram.valuesClause,
+];
+
+export const subSelectParserBuilder = Builder.createBuilder(rules)
+  .merge(expressionParserBuilder, <const> [])
+  .patchRule(gram.builtInCall)
+  .addMany(
+    gram.existsFunc,
+    gram.notExistsFunc,
+    gram.groupGraphPattern,
+    gram.groupGraphPatternSub,
+  )
+  .merge(triplesBlockParserBuilder, <const> [])
+  .addMany(
+    gram.graphPatternNotTriples,
+    gram.groupOrUnionGraphPattern,
+    gram.optionalGraphPattern,
+    gram.minusGraphPattern,
+    gram.graphGraphPattern,
+    gram.serviceGraphPattern,
+    gram.filter,
+    gram.bind,
+    gram.inlineData,
+    gram.constraint,
+    gram.functionCall,
+    gram.dataBlock,
+    gram.inlineDataOneVar,
+    gram.inlineDataFull,
+    gram.dataBlockValue,
+    // Solution modifier
+    gram.groupClause,
+    gram.havingClause,
+    gram.orderClause,
+    gram.limitOffsetClauses,
+    gram.groupCondition,
+    gram.havingCondition,
+    gram.orderCondition,
+    gram.limitClause,
+    gram.offsetClause,
+  );

engines/parser-sparql-1-1/lib/triplesTemplateParserBuilder.ts

@@ -1,5 +1,5 @@
 import { Builder } from '@traqula/core';
-import { gram } from '@traqula/rules-sparql-1-1';
+import { gram, lex } from '@traqula/rules-sparql-1-1';
 
 const rules = <const> [
   gram.triplesTemplate,

engines/parser-sparql-1-1/lib/updateNoModifyParser.ts

@@ -0,0 +1,58 @@
+import { Builder } from '@traqula/core';
+import type { UpdateOperation } from '@traqula/rules-sparql-1-1';
+import { gram } from '@traqula/rules-sparql-1-1';
+import { triplesTemplateParserBuilder } from './triplesTemplateParserBuilder';
+
+const update1Patch: typeof gram.update1 = {
+  name: 'update1',
+  impl: ({ SUBRULE, OR }) => () => OR<UpdateOperation>([
+    { ALT: () => SUBRULE(gram.load, undefined) },
+    { ALT: () => SUBRULE(gram.clear, undefined) },
+    { ALT: () => SUBRULE(gram.drop, undefined) },
+    { ALT: () => SUBRULE(gram.add, undefined) },
+    { ALT: () => SUBRULE(gram.move, undefined) },
+    { ALT: () => SUBRULE(gram.copy, undefined) },
+    { ALT: () => SUBRULE(gram.create, undefined) },
+    { ALT: () => SUBRULE(gram.insertData, undefined) },
+    { ALT: () => SUBRULE(gram.deleteData, undefined) },
+    { ALT: () => SUBRULE(gram.deleteWhere, undefined) },
+  ]),
+  gImpl: gram.update1.gImpl,
+};
+
+const rulesNoUpdate1 = <const>[
+  gram.updateUnit,
+  gram.update,
+  gram.prologue,
+  // Update1,
+  gram.baseDecl,
+  gram.prefixDecl,
+  gram.load,
+  gram.clear,
+  gram.drop,
+  gram.add,
+  gram.move,
+  gram.copy,
+  gram.create,
+  gram.insertData,
+  gram.deleteData,
+  gram.deleteWhere,
+  gram.iri,
+  gram.prefixedName,
+  gram.graphRef,
+  gram.graphRefAll,
+  gram.graphOrDefault,
+  gram.quadData,
+  gram.quads,
+];
+
+/**
+ * Simple SPARQL 1.1 Update parser excluding MODIFY operations.
+ * Top enable MODIFY, you need to path the update1 rule.
+ */
+export const updateNoModifyParserBuilder = Builder
+  .createBuilder(rulesNoUpdate1)
+  .addRule(update1Patch)
+  .merge(triplesTemplateParserBuilder, <const> [])
+  .addRule(gram.quadPattern)
+  .addRule(gram.quadsNotTriples);

engines/parser-sparql-1-1/lib/updateUnitParser.ts

@@ -0,0 +1,22 @@
+import { Builder } from '@traqula/core';
+import { gram } from '@traqula/rules-sparql-1-1';
+import { objectListBuilder } from './objectListParser';
+import { subSelectParserBuilder } from './subSelectParser';
+import { updateNoModifyParserBuilder } from './updateNoModifyParser';
+
+export const updateParserBuilder = Builder.createBuilder(updateNoModifyParserBuilder)
+  .patchRule(gram.update1)
+  .addMany(
+    gram.modify,
+    gram.deleteClause,
+    gram.insertClause,
+    gram.usingClause,
+    gram.defaultGraphClause,
+    gram.namedGraphClause,
+    gram.sourceSelector,
+    gram.usingClauseStar,
+    gram.groupGraphPattern,
+  )
+  // This substitutes all of propertyListNotEmpty
+  .merge(objectListBuilder, <const> [])
+  .merge(subSelectParserBuilder, <const> []);