@sprig-and-prose/sprig-universe 0.3.3 → 0.4.0

package/src/scanner.js

@@ -25,6 +25,7 @@ const KEYWORDS = new Set([
   'concept',
   'in',
   'relates',
+  'relationship',
   'and',
   'describe',
   'from',

package/test/aliases.test.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Tests for scoped aliases
+ */
+
+import { test } from 'node:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { parseFiles } from '../src/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, 'fixtures');
+
+function loadGraph(fixtureName) {
+  const file = join(fixturesDir, fixtureName);
+  const text = readFileSync(file, 'utf-8');
+  return parseFiles([{ file, text }]);
+}
+
+test('basic alias in anthology resolves kind and preserves spelling', () => {
+  const graph = loadGraph('aliases-basic.prose');
+  const node = graph.nodes['Test:book:FrontendTeam'];
+  assert(node !== undefined, 'FrontendTeam node should exist');
+  assert(node.kind === 'book', 'FrontendTeam kind should resolve to book');
+  assert(node.spelledKind === 'team', 'FrontendTeam spelledKind should preserve alias');
+});
+
+test('aliases do not leak to sibling containers', () => {
+  const graph = loadGraph('aliases-no-leak.prose');
+  const t1 = graph.nodes['Test:book:T1'];
+  assert(t1 !== undefined, 'T1 should resolve via alias in anthology A');
+  const t2 = graph.nodes['Test:book:T2'];
+  assert(t2 === undefined, 'T2 should not resolve via alias from anthology A');
+});
+
+test('alias shadowing is scoped and does not affect siblings', () => {
+  const graph = loadGraph('aliases-shadowing.prose');
+  const outer = graph.nodes['Test:book:Outer'];
+  const inner = graph.nodes['Test:series:Inner'];
+  const anotherOuter = graph.nodes['Test:book:AnotherOuter'];
+
+  assert(outer !== undefined, 'Outer should resolve to book');
+  assert(outer.kind === 'book', 'Outer kind should be book');
+  assert(outer.spelledKind === 'team', 'Outer spelledKind should preserve alias');
+
+  assert(inner !== undefined, 'Inner should resolve to series in nested scope');
+  assert(inner.kind === 'series', 'Inner kind should be series');
+  assert(inner.spelledKind === 'team', 'Inner spelledKind should preserve alias');
+
+  assert(anotherOuter !== undefined, 'AnotherOuter should resolve to book in outer scope');
+  assert(anotherOuter.kind === 'book', 'AnotherOuter kind should be book');
+  assert(anotherOuter.spelledKind === 'team', 'AnotherOuter spelledKind should preserve alias');
+});
+
+test('single-line alias syntax matches block form', () => {
+  const graph = loadGraph('aliases-single-line.prose');
+  const node = graph.nodes['Test:book:X'];
+  assert(node !== undefined, 'X should resolve via single-line alias');
+  assert(node.kind === 'book', 'X kind should resolve to book');
+  assert(node.spelledKind === 'team', 'X spelledKind should preserve alias');
+});
+
+test('alias conflicts with built-in kind keyword errors clearly', () => {
+  const file = join(fixturesDir, 'aliases-conflict.prose');
+  const text = readFileSync(file, 'utf-8');
+  let error = null;
+  try {
+    parseFiles([{ file, text }]);
+  } catch (err) {
+    error = err;
+  }
+  assert(error, 'Expected alias conflict to throw');
+  assert(
+    String(error.message).includes('conflicts with built-in kind'),
+    'Error message should explain the conflict',
+  );
+});
+
+/**
+ * Simple assertion helper
+ * @param {boolean} condition
+ * @param {string} message
+ */
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+

package/test/fixtures/aliases-basic.prose

@@ -0,0 +1,7 @@
+universe Test {
+  anthology Organization {
+    aliases { team { book } }
+    team FrontendTeam { }
+  }
+}
+

package/test/fixtures/aliases-conflict.prose

@@ -0,0 +1,6 @@
+universe Test {
+  anthology Org {
+    aliases { book { concept } }
+  }
+}
+

package/test/fixtures/aliases-no-leak.prose

@@ -0,0 +1,5 @@
+universe Test {
+  anthology A { aliases { team { book } } team T1 { } }
+  anthology B { team T2 { } }
+}
+

package/test/fixtures/aliases-shadowing.prose

@@ -0,0 +1,11 @@
+universe Test {
+  anthology Org {
+    aliases { team { book } }
+    team Outer {
+      aliases { team { series } }
+      team Inner { }
+    }
+    team AnotherOuter { }
+  }
+}
+

package/test/fixtures/aliases-single-line.prose

@@ -0,0 +1,7 @@
+universe Test {
+  anthology Org {
+    alias team { book }
+    team X { }
+  }
+}
+

package/test/fixtures/relationship-errors.prose

@@ -0,0 +1,20 @@
+universe TestErrors {
+  relationship duplicateId {
+    describe { First }
+  }
+
+  relationship duplicateId {
+    describe { Second }
+  }
+
+  series Teams {
+    team FrontendTeam {
+      relationships {
+        undeclaredRel { BackendTeam }
+      }
+    }
+
+    team BackendTeam { }
+  }
+}
+

package/test/fixtures/relationship-paired.prose

@@ -0,0 +1,28 @@
+universe TestPaired {
+  relationship owns and ownedBy {
+    describe {
+      Ownership expresses long-term responsibility and stewardship.
+    }
+
+    from ownedBy {
+      label { 'owned by' }
+      describe {
+        Services are usually owned by a single team.
+      }
+    }
+  }
+
+  series TeamsPaired {
+    team FrontendTeam {
+      relationships {
+        owns { PaymentsApi WebApp }
+      }
+    }
+  }
+
+  series ServicesPaired {
+    service PaymentsApi { }
+    service WebApp { }
+  }
+}
+

package/test/fixtures/relationship-scoped.prose

@@ -0,0 +1,23 @@
+universe TestScoped {
+  relationship outerRel {
+    describe { Outer relationship }
+  }
+
+  anthology Inner {
+    relationship innerRel {
+      describe { Inner relationship }
+    }
+
+    series TeamsScoped {
+      team FrontendTeam {
+        relationships {
+          outerRel { BackendTeam }
+          innerRel { BackendTeam }
+        }
+      }
+
+      team BackendTeam { }
+    }
+  }
+}
+

package/test/fixtures/relationship-symmetric.prose

@@ -0,0 +1,18 @@
+universe TestSymmetric {
+  relationship friend {
+    describe {
+      Teams have a peer relationship with no hierarchy.
+    }
+  }
+
+  series Teams {
+    team FrontendTeam {
+      relationships {
+        friend { BackendTeam }
+      }
+    }
+
+    team BackendTeam { }
+  }
+}
+

package/test/fixtures/relationship-usage.prose

@@ -0,0 +1,31 @@
+universe TestUsage {
+  relationship ledBy and leads {
+    describe {
+      Teams are led by a single point of contact.
+    }
+  }
+
+  relationship hasMember and memberOf {
+    from memberOf {
+      label { 'is member of' }
+    }
+  }
+
+  series TeamsUsage {
+    team FrontendTeam {
+      relationships {
+        ledBy { Bryan }
+        hasMember {
+          Bryan
+          Michael { describe { Primary maintainer } }
+        }
+      }
+    }
+  }
+
+  series PeopleUsage {
+    person Bryan { }
+    person Michael { }
+  }
+}
+