Tests/to 100 bis

engines/algebra-sparql-1-2/test/extraCoverage.test.ts

@@ -0,0 +1,16 @@
+import { AlgebraFactory } from '@traqula/algebra-transformations-1-1';
+import { describe, it } from 'vitest';
+import { toAst } from '../lib/index.js';
+
+describe('algebra-sparql-1-2 extra coverage', () => {
+  const AF = new AlgebraFactory();
+
+  describe('toAst', () => {
+    it('converts a simple projection to sparql 1.2 ast', ({ expect }) => {
+      const op = AF.createProject(AF.createBgp([]), []);
+      const result = toAst(op);
+      expect(result).toBeDefined();
+      expect(result.type).toBe('query');
+    });
+  });
+});

engines/algebra-sparql-1-2/test/sparql.test.ts

@@ -19,6 +19,9 @@
     for (const suite of suites) {
       describe(suite, () => {
         for (const test of sparqlAlgebraTests(suite, false, false)) {
+          if (test.name !== 'sparql12/sparql-1-2-ar-langdir') {
+            continue;
+          }
           const { name, json, quads } = test;
           const expected = <Algebra.Operation> json;
           it (name, ({ expect }) => {
@@ -28,7 +31,7 @@
             // Console.log(genQuery);
             const ast = parser.parse(genQuery);
             const algebra = algebraUtils.objectify(toAlgebra(ast, { quads }));
             expect(canon.canonicalizeQuery(algebra, false)).toEqual(canon.canonicalizeQuery(expected, false));
           });
         }
       });

engines/generator-sparql-1-1/test/extraCoverage.test.ts

@@ -0,0 +1,149 @@
+import { Parser } from '@traqula/parser-sparql-1-1';
+import { AstFactory, completeGeneratorContext } from '@traqula/rules-sparql-1-1';
+import { beforeEach, describe, it } from 'vitest';
+import { Generator, sparql11GeneratorBuilder } from '../lib/index.js';
+
+describe('extra generator coverage', () => {
+  const generator = new Generator();
+  const F = new AstFactory();
+  const parser = new Parser({
+    lexerConfig: { positionTracking: 'full' },
+    defaultContext: { astFactory: F },
+  });
+
+  beforeEach(() => {
+    F.resetBlankNodeCounter();
+  });
+
+  describe('argList gImpl with DISTINCT', () => {
+    it('generates DISTINCT keyword in function call arguments', ({ expect }) => {
+      const ast = parser.parse(
+        'SELECT * WHERE { FILTER(<http://ex.org/func>(DISTINCT ?x)) }',
+        { parseMode: new Set([ 'canParseVars', 'canCreateBlankNodes', 'canParseAggregate' ]) },
+      );
+      const result = generator.generate(F.forcedAutoGenTree(ast));
+      expect(result).toContain('DISTINCT');
+      expect(result).toContain('<http://ex.org/func>');
+    });
+
+    it('throws when DISTINCT is used in function call outside aggregate context', ({ expect }) => {
+      // Covers expression.ts line 452: throw when DISTINCT is used without canParseAggregate
+      expect(() =>
+        parser.parse(
+          'SELECT * WHERE { FILTER(<http://ex.org/func>(DISTINCT ?x)) }',
+        )).toThrow(/DISTINCT implies/u);
+    });
+  });
+
+  describe('groupOrUnionGraphPattern gImpl with non-union pattern', () => {
+    it('generates a single group via graphPatternNotTriples rule', ({ expect }) => {
+      const rawGenerator = sparql11GeneratorBuilder.build();
+      const context = completeGeneratorContext({ astFactory: F });
+
+      const patternGroup = F.patternGroup([
+        F.patternBgp([
+          F.triple(
+            F.termVariable('s', F.gen()),
+            F.termVariable('p', F.gen()),
+            F.termVariable('o', F.gen()),
+          ),
+        ], F.gen()),
+      ], F.gen());
+
+      const result = rawGenerator.graphPatternNotTriples(patternGroup, context);
+      expect(result).toContain('?s');
+      expect(result).toContain('?p');
+    });
+  });
+
+  describe('triplesBlock gImpl separator paths', () => {
+    it('generates comma separator for same subject and predicate (different objects)', ({ expect }) => {
+      const bgp = F.patternBgp([
+        F.triple(
+          F.termVariable('s', F.gen()),
+          F.termVariable('p', F.gen()),
+          F.termVariable('o1', F.gen()),
+          F.gen(),
+        ),
+        F.triple(
+          F.dematerialized(F.termVariable('s', F.gen())),
+          F.dematerialized(F.termVariable('p', F.gen())),
+          F.termVariable('o2', F.gen()),
+          F.gen(),
+        ),
+      ], F.gen());
+
+      const query = F.querySelect({
+        variables: [ F.wildcard(F.gen()) ],
+        datasets: F.datasetClauses([], F.sourceLocation()),
+        context: [],
+        where: F.patternGroup([ bgp ], F.gen()),
+        solutionModifiers: {},
+      }, F.gen());
+
+      const result = generator.generate(query);
+      expect(result).toContain(',');
+    });
+
+    it('generates semicolon separator for same subject with different predicates', ({ expect }) => {
+      const bgp = F.patternBgp([
+        F.triple(
+          F.termVariable('s', F.gen()),
+          F.termVariable('p1', F.gen()),
+          F.termVariable('o1', F.gen()),
+          F.gen(),
+        ),
+        F.triple(
+          F.dematerialized(F.termVariable('s', F.gen())),
+          F.termVariable('p2', F.gen()),
+          F.termVariable('o2', F.gen()),
+          F.gen(),
+        ),
+      ], F.gen());
+
+      const query = F.querySelect({
+        variables: [ F.wildcard(F.gen()) ],
+        datasets: F.datasetClauses([], F.sourceLocation()),
+        context: [],
+        where: F.patternGroup([ bgp ], F.gen()),
+        solutionModifiers: {},
+      }, F.gen());
+
+      const result = generator.generate(query);
+      expect(result).toContain(';');
+    });
+  });
+
+  describe('iriOrFunction gImpl with TermNamed', () => {
+    it('generates a bare IRI via iriOrFunction rule directly', ({ expect }) => {
+      const rawGenerator = sparql11GeneratorBuilder.build();
+      const context = completeGeneratorContext({ astFactory: F });
+      const iri = F.termNamed(F.gen(), 'http://example.org/type');
+      const result = rawGenerator.iriOrFunction(iri, context);
+      expect(result).toContain('http://example.org/type');
+    });
+  });
+
+  describe('rdfLiteral gImpl with non-materialized type', () => {
+    it('generates a typed literal where the type IRI is dematerialized (prints raw value)', ({ expect }) => {
+      const rawGenerator = sparql11GeneratorBuilder.build();
+      const context = completeGeneratorContext({ astFactory: F });
+      const typeIri = F.dematerialized(F.termNamed(F.gen(), 'http://www.w3.org/2001/XMLSchema#integer'));
+      const lit = F.termLiteral(F.gen(), '42', typeIri);
+      const result = rawGenerator.rdfLiteral(lit, context);
+      expect(result).toContain('42');
+      expect(result).not.toContain('^^');
+    });
+  });
+
+  describe('queryOrUpdate gImpl for update branch', () => {
+    it('generates an update via the queryOrUpdate gImpl', ({ expect }) => {
+      // Covers index.ts:79 else branch: F.isQuery is false → SUBRULE(update, ast)
+      const rawGenerator = sparql11GeneratorBuilder.build();
+      const context = completeGeneratorContext({ astFactory: F });
+      const ast = parser.parse('INSERT DATA { <http://s> <http://p> <http://o> }');
+      const result = rawGenerator.queryOrUpdate(<any>ast, context);
+      expect(result).toContain('INSERT DATA');
+    });
+  });
+});

engines/generator-sparql-1-2/test/extraCoverage.test.ts

@@ -0,0 +1,84 @@
+import { AstFactory, completeGeneratorContext } from '@traqula/rules-sparql-1-2';
+import { beforeEach, describe, it } from 'vitest';
+import { Generator, sparql12GeneratorBuilder } from '../lib/index.js';
+
+describe('extra generator-sparql-1-2 coverage', () => {
+  const F = new AstFactory();
+  const generator = new Generator();
+
+  beforeEach(() => {
+    F.resetBlankNodeCounter();
+  });
+
+  describe('reifiedTriple gImpl with path predicate', () => {
+    it('generates a reified triple with path predicate via direct AST construction', ({ expect }) => {
+      const rawGenerator = sparql12GeneratorBuilder.build();
+      const context = completeGeneratorContext({ astFactory: F });
+      const s = F.termVariable('s', F.gen());
+      const pathPred = F.path('*', [ F.termNamed(F.gen(), 'http://p') ], F.gen());
+      const o = F.termVariable('o', F.gen());
+      const reifiedTriple = F.tripleCollectionReifiedTriple(F.gen(), s, <any>pathPred, o);
+      const result = rawGenerator.reifiedTriple(reifiedTriple, context);
+      expect(result).toContain('<<');
+      expect(result).toContain('*');
+    });
+  });
+
+  describe('generateTriplesBlock separator logic', () => {
+    it('generates comma separator for same subject and predicate (different objects)', ({ expect }) => {
+      const bgp = F.patternBgp([
+        F.triple(
+          F.termVariable('s', F.gen()),
+          F.termVariable('p', F.gen()),
+          F.termVariable('o1', F.gen()),
+          F.gen(),
+        ),
+        F.triple(
+          F.dematerialized(F.termVariable('s', F.gen())),
+          F.dematerialized(F.termVariable('p', F.gen())),
+          F.termVariable('o2', F.gen()),
+          F.gen(),
+        ),
+      ], F.gen());
+
+      const query = F.querySelect({
+        variables: [ F.wildcard(F.gen()) ],
+        datasets: F.datasetClauses([], F.sourceLocation()),
+        context: [],
+        where: F.patternGroup([ bgp ], F.gen()),
+        solutionModifiers: {},
+      }, F.gen());
+
+      const result = generator.generate(query);
+      expect(result).toContain(',');
+    });
+
+    it('generates semicolon separator for same subject with different predicates', ({ expect }) => {
+      const bgp = F.patternBgp([
+        F.triple(
+          F.termVariable('s', F.gen()),
+          F.termVariable('p1', F.gen()),
+          F.termVariable('o1', F.gen()),
+          F.gen(),
+        ),
+        F.triple(
+          F.dematerialized(F.termVariable('s', F.gen())),
+          F.termVariable('p2', F.gen()),
+          F.termVariable('o2', F.gen()),
+          F.gen(),
+        ),
+      ], F.gen());
+
+      const query = F.querySelect({
+        variables: [ F.wildcard(F.gen()) ],
+        datasets: F.datasetClauses([], F.sourceLocation()),
+        context: [],
+        where: F.patternGroup([ bgp ], F.gen()),
+        solutionModifiers: {},
+      }, F.gen());
+
+      const result = generator.generate(query);
+      expect(result).toContain(';');
+    });
+  });
+});

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

@@ -93,6 +93,7 @@ export const expressionParserBuilder = ParserBuilder.create(rulesNoBuiltIn)
     gram.aggregateGroup_concat,
     gram.aggregate,
     gram.iri,
+    gram.iriFull,
     gram.prefixedName,
     gram.argList,
     gram.string,