@glossarist/concept-browser 0.7.51 → 0.7.52

package/src/__tests__/concept-rdf/shape-consistency.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Parser, Store } from 'n3';
+
+const SHAPES_PATH = join(process.cwd(), 'data', 'concept-model', 'shapes', 'glossarist.shacl.ttl');
+
+const SH = 'http://www.w3.org/ns/shacl#';
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+
+function parseShapes(): Store {
+  const text = readFileSync(SHAPES_PATH, 'utf8');
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(text));
+  return store;
+}
+
+let store: Store;
+
+beforeAll(() => {
+  store = parseShapes();
+});
+
+function allQuads(): any[] {
+  return [...(store as any)];
+}
+
+function isShapeQuad(q: any): boolean {
+  return q.predicate.value === `${RDF}type` && q.object.value === `${SH}NodeShape`;
+}
+
+describe('WS P7 — canonical SHACL shape self-consistency', () => {
+  it('every sh:NodeShape declares an sh:targetClass', () => {
+    const shapes = allQuads().filter(isShapeQuad);
+    expect(shapes.length).toBeGreaterThan(0);
+    for (const shape of shapes) {
+      const targetClasses = (store as any).getObjects(shape.subject, `${SH}targetClass`, null);
+      expect(targetClasses.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('every sh:targetClass IRI uses a known namespace', () => {
+    const targets = allQuads()
+      .filter((q: any) => q.predicate.value === `${SH}targetClass`)
+      .map((q: any) => q.object.value);
+    expect(targets.length).toBeGreaterThan(0);
+    const knownPrefixes = [
+      'https://www.glossarist.org/',
+      'http://www.w3.org/2004/02/skos-core#',
+      'http://www.w3.org/2008/05/skos-xl#',
+      'http://www.w3.org/ns/shacl#',
+      'http://xmlns.com/foaf/0.1/',
+      'http://www.w3.org/ns/prov#',
+      'http://purl.org/dc/terms/',
+    ];
+    for (const target of targets) {
+      const known = knownPrefixes.some(p => target === p || target.startsWith(p));
+      expect(known).toBe(true);
+    }
+  });
+
+  it('every sh:datatype references a built-in XSD datatype (when XSD-prefixed)', () => {
+    const builtins = new Set([
+      `${XSD}string`, `${XSD}integer`, `${XSD}dateTime`, `${XSD}date`, `${XSD}anyURI`,
+      `${XSD}boolean`, `${XSD}decimal`, `${XSD}double`, `${XSD}float`,
+      `${XSD}nonNegativeInteger`, `${XSD}positiveInteger`, `${XSD}duration`,
+    ]);
+    const datatypes = allQuads().filter((q: any) => q.predicate.value === `${SH}datatype`);
+    expect(datatypes.length).toBeGreaterThan(0);
+    for (const dt of datatypes) {
+      const value = dt.object.value;
+      if (value.startsWith(XSD)) {
+        expect(builtins.has(value)).toBe(true);
+      }
+    }
+  });
+
+  it('every sh:property has exactly one sh:path', () => {
+    const props = allQuads().filter((q: any) => q.predicate.value === `${SH}property`);
+    expect(props.length).toBeGreaterThan(0);
+    for (const prop of props) {
+      const paths = (store as any).getObjects(prop.object, `${SH}path`, null);
+      expect(paths.length).toBe(1);
+    }
+  });
+
+  it('no two NodeShapes share both a target class AND the same predicate path', () => {
+    const shapes = allQuads().filter(isShapeQuad);
+
+    const seen = new Map<string, string[]>();
+    for (const shape of shapes) {
+      const shapeIri = String(shape.subject.value);
+      const targetClasses = (store as any)
+        .getObjects(shape.subject, `${SH}targetClass`, null)
+        .map((t: any) => String(t.value));
+      const properties = (store as any).getObjects(shape.subject, `${SH}property`, null);
+      const paths: string[] = [];
+      for (const prop of properties) {
+        const propPaths = (store as any)
+          .getObjects(prop, `${SH}path`, null)
+          .map((t: any) => String(t.value));
+        paths.push(...propPaths);
+      }
+
+      for (const tc of targetClasses) {
+        for (const p of paths) {
+          const key = `${tc}|${p}`;
+          const existing = seen.get(key) ?? [];
+          existing.push(shapeIri);
+          seen.set(key, existing);
+        }
+      }
+    }
+
+    for (const [key, shapeIris] of seen.entries()) {
+      if (shapeIris.length > 1) {
+        expect.fail(`Conflicting NodeShapes at ${key}: ${shapeIris.join(', ')}`);
+      }
+    }
+  });
+
+  it('no NodeShape has both sh:property and a contradiction (path declared twice)', () => {
+    const shapes = allQuads().filter(isShapeQuad);
+    for (const shape of shapes) {
+      const properties = (store as any).getObjects(shape.subject, `${SH}property`, null);
+      const seenPaths = new Set<string>();
+      for (const prop of properties) {
+        const paths = (store as any).getObjects(prop, `${SH}path`, null).map((t: any) => String(t.value));
+        for (const p of paths) {
+          expect(seenPaths.has(p)).toBe(false);
+          seenPaths.add(p);
+        }
+      }
+    }
+  });
+});

package/src/__tests__/concept-rdf/snapshot-generation.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { CONCEPT_FIXTURES } from '../__fixtures__/concepts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..', '..');
+const SNAPSHOTS_DIR = join(ROOT, 'test', 'snapshots', 'js');
+
+beforeAll(() => {
+  mkdirSync(SNAPSHOTS_DIR, { recursive: true });
+});
+
+describe('WS P1 — JS snapshot generator', () => {
+  for (const fixture of CONCEPT_FIXTURES) {
+    it(`emits a canonical Turtle snapshot for ${fixture.name}`, () => {
+      const { graph } = emitConceptGraph(fixture.concept, fixture.uri);
+      const ttl = writeTurtle(graph);
+      const target = join(SNAPSHOTS_DIR, `${fixture.name}.ttl`);
+      writeFileSync(target, ttl);
+      expect(existsSync(target)).toBe(true);
+      expect(ttl.length).toBeGreaterThan(0);
+    });
+  }
+
+  it('snapshot directory contains one .ttl per fixture after generation', () => {
+    const files = existsSync(SNAPSHOTS_DIR)
+      ? readdirSync(SNAPSHOTS_DIR).filter(f => f.endsWith('.ttl'))
+      : [];
+    expect(files.length).toBeGreaterThanOrEqual(CONCEPT_FIXTURES.length);
+    for (const fixture of CONCEPT_FIXTURES) {
+      expect(files).toContain(`${fixture.name}.ttl`);
+    }
+  });
+
+  it('re-emitting the same fixture produces byte-identical Turtle (deterministic)', () => {
+    for (const fixture of CONCEPT_FIXTURES) {
+      const a = writeTurtle(emitConceptGraph(fixture.concept, fixture.uri).graph);
+      const b = writeTurtle(emitConceptGraph(fixture.concept, fixture.uri).graph);
+      expect(a).toBe(b);
+    }
+  });
+});
+
+describe('WS P1 — JS snapshots are stable across runs (drift detector)', () => {
+  for (const fixture of CONCEPT_FIXTURES) {
+    it(`${fixture.name}: emitted snapshot matches the file on disk (run npm test to refresh)`, () => {
+      const { graph } = emitConceptGraph(fixture.concept, fixture.uri);
+      const ttl = writeTurtle(graph);
+      const target = join(SNAPSHOTS_DIR, `${fixture.name}.ttl`);
+      if (!existsSync(target)) {
+        writeFileSync(target, ttl);
+        return;
+      }
+      const existing = readFileSync(target, 'utf8');
+      if (existing !== ttl) {
+        writeFileSync(target, ttl);
+        expect.fail(
+          `Snapshot drift for ${fixture.name}.\n` +
+          `Updated ${target}.\n` +
+          `Commit the change if the new output is the canonical shape.`,
+        );
+      }
+      expect(existing).toBe(ttl);
+    });
+  }
+});
+
+function readdirSync(p: string): string[] {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  return require('node:fs').readdirSync(p);
+}

package/src/__tests__/concept-rdf/table-formula-emitter.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import {
+  emitFormulaGraph,
+  emitTableGraph,
+  formulaIri,
+  tableIri,
+} from '../../components/concept-rdf/table-formula-emitter';
+
+const G = 'https://www.glossarist.org/ontologies/';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+describe('WS K3 — Formula representation', () => {
+  it('types each formula as gloss:Formula', () => {
+    const graph = emitFormulaGraph({
+      registerId: 'iso-geodetic',
+      formulaId: 'f1',
+      expression: 'E = mc^2',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = formulaIri({ registerId: 'iso-geodetic', formulaId: 'f1', expression: '' });
+    const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${G}Formula`);
+  });
+
+  it('emits gloss:expression as the canonical form', () => {
+    const graph = emitFormulaGraph({
+      registerId: 'r',
+      formulaId: 'f1',
+      expression: 'tan(θ) = μ',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = formulaIri({ registerId: 'r', formulaId: 'f1', expression: '' });
+    const exprs = store.getObjects(iri, `${G}expression`, null).map(q => q.value);
+    expect(exprs).toContain('tan(θ) = μ');
+  });
+
+  it('emits gloss:latexForm when provided', () => {
+    const graph = emitFormulaGraph({
+      registerId: 'r',
+      formulaId: 'f1',
+      expression: 'E = mc^2',
+      latexForm: '\\mathrm{E} = mc^2',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = formulaIri({ registerId: 'r', formulaId: 'f1', expression: '' });
+    const latex = store.getObjects(iri, `${G}latexForm`, null).map(q => q.value);
+    expect(latex).toContain('\\mathrm{E} = mc^2');
+  });
+
+  it('emits dcterms:description when provided', () => {
+    const graph = emitFormulaGraph({
+      registerId: 'r',
+      formulaId: 'f1',
+      expression: 'E = mc^2',
+      description: 'Mass-energy equivalence',
+      lang: 'eng',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = formulaIri({ registerId: 'r', formulaId: 'f1', expression: '' });
+    const desc = store.getObjects(iri, `${DCTERMS}description`, null).map(q => q.value);
+    expect(desc).toContain('Mass-energy equivalence');
+  });
+});
+
+describe('WS K3 — Table representation', () => {
+  it('types each table as gloss:Table', () => {
+    const graph = emitTableGraph({
+      registerId: 'r',
+      tableId: 't1',
+      title: 'Conversion factors',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = tableIri({ registerId: 'r', tableId: 't1' });
+    const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${G}Table`);
+  });
+
+  it('emits dcterms:title and gloss:caption when provided', () => {
+    const graph = emitTableGraph({
+      registerId: 'r',
+      tableId: 't1',
+      title: 'Conversion factors',
+      caption: 'Common unit conversions',
+      lang: 'eng',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = tableIri({ registerId: 'r', tableId: 't1' });
+    expect(store.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value)).toContain('Conversion factors');
+    expect(store.getObjects(iri, `${G}caption`, null).map(q => q.value)).toContain('Common unit conversions');
+  });
+
+  it('emits a MarkupTable content blank when markup is provided', () => {
+    const graph = emitTableGraph({
+      registerId: 'r',
+      tableId: 't1',
+      markup: '<table><tr><td>1</td></tr></table>',
+      markupFormat: 'html',
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = tableIri({ registerId: 'r', tableId: 't1' });
+    const contentBlanks = store.getObjects(iri, `${G}content`, null);
+    expect(contentBlanks.length).toBe(1);
+    const contentBlank = contentBlanks[0];
+    const innerTypes = store.getObjects(contentBlank, RDF_TYPE, null).map(q => q.value);
+    expect(innerTypes).toContain(`${G}MarkupTable`);
+    const markupLiterals = store.getObjects(contentBlank, `${G}content`, null).map(q => q.value);
+    expect(markupLiterals).toContain('<table><tr><td>1</td></tr></table>');
+    const formats = store.getObjects(contentBlank, `${DCTERMS}format`, null).map(q => q.value);
+    expect(formats).toContain('html');
+  });
+
+  it('emits a StructuredTable content blank when headers and rows are provided', () => {
+    const graph = emitTableGraph({
+      registerId: 'r',
+      tableId: 't1',
+      headers: [{ value: 'Term' }, { value: 'Definition' }],
+      rows: [
+        { cells: ['metre', 'unit of length'] },
+        { cells: ['second', 'unit of time'] },
+      ],
+    });
+    const store = parse(writeTurtle(graph));
+    const iri = tableIri({ registerId: 'r', tableId: 't1' });
+    const contentBlanks = store.getObjects(iri, `${G}content`, null);
+    expect(contentBlanks.length).toBe(1);
+    const contentBlank = contentBlanks[0];
+    const innerTypes = store.getObjects(contentBlank, RDF_TYPE, null).map(q => q.value);
+    expect(innerTypes).toContain(`${G}StructuredTable`);
+    const rows = store.getObjects(contentBlank, `${G}hasRow`, null);
+    expect(rows.length).toBe(2);
+  });
+});

package/src/__tests__/concept-rdf/turtle-writer.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { RdfGraph, lit, iri, blank, triple } from '../../components/concept-rdf/rdf-graph';
+
+describe('writeTurtle', () => {
+  it('declares all canonical @prefix lines', () => {
+    const g = new RdfGraph();
+    const out = writeTurtle(g);
+    expect(out).toContain('@prefix gloss: <https://www.glossarist.org/ontologies/> .');
+    expect(out).toContain('@prefix skos: <http://www.w3.org/2004/02/skos/core#> .');
+    expect(out).toContain('@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#> .');
+    expect(out).toContain('@prefix dcterms: <http://purl.org/dc/terms/> .');
+    expect(out).toContain('@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .');
+  });
+
+  it('writes types after `a` keyword', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: ['gloss:Concept', 'skos:Concept'] })
+      .literal('gloss:identifier', '1');
+    const out = writeTurtle(g);
+    expect(out).toMatch(/<https:\/\/ex\/c> a gloss:Concept, skos:Concept ;/);
+  });
+
+  it('terminates resources with full stops', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: ['gloss:Concept'] })
+      .literal('gloss:identifier', '1');
+    const out = writeTurtle(g);
+    expect(out).toMatch(/gloss:identifier "1" \./);
+    expect(out).not.toMatch(/gloss:identifier "1" ;/);
+  });
+
+  it('emits language-tagged literals', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('skos:prefLabel', 'atomic', { lang: 'en' });
+    const out = writeTurtle(g);
+    expect(out).toContain('skos:prefLabel "atomic"@en');
+  });
+
+  it('emits datatyped literals', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:value', '42', { datatype: 'xsd:integer' });
+    const out = writeTurtle(g);
+    expect(out).toContain('gloss:value "42"^^xsd:integer');
+  });
+
+  it('emits inline blank nodes with bracket syntax', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .blank('gloss:hasSource', [
+        triple('rdf:value', lit('ISO 123')),
+        triple('dcterms:title', lit('Standard')),
+      ]);
+    const out = writeTurtle(g);
+    expect(out).toMatch(/gloss:hasSource \[ rdf:value "ISO 123" ; dcterms:title "Standard" \]/);
+  });
+
+  it('wraps absolute IRIs in angle brackets', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .iri('gloss:related', 'https://example.org/other');
+    const out = writeTurtle(g);
+    expect(out).toContain('gloss:related <https://example.org/other>');
+  });
+
+  it('escapes slash in prefixed local names (Turtle 1.1 PN_LOCAL rule)', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .iri('gloss:hasStatus', 'gloss:status/valid');
+    const out = writeTurtle(g);
+    expect(out).toContain('gloss:hasStatus gloss:status\\/valid');
+    expect(out).not.toContain('gloss:hasStatus <gloss:status');
+  });
+
+  it('wraps relative IRIs (paths without scheme) in angle brackets', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .iri('gloss:image', 'fig_A.23.svg');
+    const out = writeTurtle(g);
+    expect(out).toContain('gloss:image <fig_A.23.svg>');
+  });
+
+  it('escapes special characters in literals', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: [] })
+      .literal('gloss:note', 'She said "hi"\nand left');
+    const out = writeTurtle(g);
+    expect(out).toContain('"She said \\"hi\\"\\nand left"');
+  });
+
+  it('separates resources with blank lines', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/a', { types: [] }).literal('gloss:x', '1');
+    g.declare('https://ex/b', { types: [] }).literal('gloss:x', '2');
+    const out = writeTurtle(g);
+    expect(out).toMatch(/\.\n\n<https:\/\/ex\/b>/);
+  });
+
+  it('handles a resource with no triples', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', { types: ['gloss:Concept'] });
+    const out = writeTurtle(g);
+    expect(out).toMatch(/<https:\/\/ex\/c> a gloss:Concept \./);
+  });
+
+  it('handles a resource with no types', () => {
+    const g = new RdfGraph();
+    g.declare('https://ex/c', {}).literal('gloss:x', '1');
+    const out = writeTurtle(g);
+    expect(out).toMatch(/<https:\/\/ex\/c> gloss:x "1" \./);
+  });
+});