@ogygie/core 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Ogygie framework core: manifest/spec/error schemas, generic tenancy and gate tooling. Ships TypeScript sources — Ogygie products run tsx/vitest by construction (D1).",
   "license": "MIT",
   "type": "module",

package/src/vocabulary-audit.test.ts

@@ -67,6 +67,32 @@ describe("auditProductVocabulary — B3 : les alias interdits dans le code produ
     ).toEqual([]);
   });
 
+  it("la prose des TITRES DE TESTS est libre — le framework impose de reprendre la spec en français", () => {
+    expect(
+      auditProductVocabulary({
+        vocabulary: VOCABULARY,
+        sourceFiles: [
+          {
+            path: "apps/api/src/features/stock/service.test.ts",
+            content: 'it("ÉTANT DONNÉ un widget QUAND on le pose ALORS il tient", () => {});',
+          },
+        ],
+        governedFiles: [],
+      }),
+    ).toEqual([]);
+  });
+
+  it("un nom de table dans une chaîne reste attrapé (B3 juge les identifiants, où qu'ils soient)", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [
+        { path: "apps/api/src/features/stock/db.schema.ts", content: 'pgTable("widget_codes")' },
+      ],
+      governedFiles: [],
+    });
+    expect(violations.map((v) => v.match.identifier)).toEqual(["widget_codes"]);
+  });
+
   it("la prose des commentaires est libre dans le code produit", () => {
     expect(
       auditProductVocabulary({

package/src/vocabulary-audit.ts

@@ -6,8 +6,10 @@
  *
  * Two rules, and they do not read the same text:
  * - PRODUCT SOURCE (B3): only forbidden ALIASES are hunted, and only in the
- *   machine identifiers — comments are blanked out first. The business prose
- *   of the project keeps its own words; the code has one term per concept.
+ *   machine identifiers — comments AND the prose held in string literals are
+ *   blanked out first (a test title repeats the spec's French sentence by
+ *   requirement). The business prose of the project keeps its own words; the
+ *   code has one term per concept.
  * - GOVERNED FILES (B4): the CANONICAL terms are hunted in the RAW text,
  *   comments and all. A governed file is identical in every Ogygie project, so
  *   it may know no product's domain at all, not even in a comment. That is the
@@ -24,7 +26,12 @@
  * is a pure function proven in memory with its mutations.
  */
 import type { ProductVocabulary } from "./manifest.schema.js";
-import { findProductVocabulary, stripComments, type VocabularyMatch } from "./vocabulary.js";
+import {
+  findProductVocabulary,
+  stripComments,
+  stripProseStrings,
+  type VocabularyMatch,
+} from "./vocabulary.js";
 
 /** One file handed to the audit, already read by the caller. */
 export interface ScannedFile {
@@ -86,7 +93,8 @@ export function auditProductVocabulary(
   const violations: VocabularyViolation[] = [];
 
   for (const file of input.sourceFiles) {
-    for (const match of findProductVocabulary(stripComments(file.content), forbiddenAliases)) {
+    const judged = stripProseStrings(stripComments(file.content));
+    for (const match of findProductVocabulary(judged, forbiddenAliases)) {
       violations.push({
         kind: "FORBIDDEN_ALIAS",
         filePath: file.path,

package/src/vocabulary.test.ts

@@ -11,6 +11,7 @@ import {
   findProductVocabulary,
   segmentsOfIdentifier,
   stripComments,
+  stripProseStrings,
 } from "./vocabulary.js";
 
 describe("findProductVocabulary — semantique de l'appariement", () => {
@@ -108,3 +109,34 @@ describe("stripComments — la prose des commentaires est libre", () => {
     ]);
   });
 });
+
+describe("stripProseStrings — la prose des chaînes est libre, les tokens sont jugés", () => {
+  it("ÉTANT DONNÉ un titre de test en français QUAND il nomme un alias ALORS il n'est PAS jugé", () => {
+    // Le framework EXIGE que le titre reprenne la phrase de la spec, en
+    // français : un produit dont le domaine parle français était condamné à
+    // signaler ses propres tests (FAILURES.md).
+    const source = 'it("ÉTANT DONNÉ un widget QUAND on le pose ALORS il tient", () => {});';
+    expect(findProductVocabulary(stripProseStrings(source), ["widget"])).toEqual([]);
+  });
+
+  it("un token machine dans une chaîne reste jugé — c'est là que vivent tables et clés", () => {
+    const source = 'pgTable("widget_codes"); t("widget.create.title");';
+    expect(
+      findProductVocabulary(stripProseStrings(source), ["widget"]).map((m) => m.identifier),
+    ).toEqual(["widget_codes", "widget"]);
+  });
+
+  it("un template littéral de prose est effacé, sans déplacer les lignes", () => {
+    const source = ["const a = 1;", "const label = `Un widget de ${n} cases`;", "const b = 2;"].join("\n");
+    const stripped = stripProseStrings(source);
+    expect(stripped.split("\n")).toHaveLength(3);
+    expect(findProductVocabulary(stripped, ["widget"])).toEqual([]);
+  });
+
+  it("l'identifiant HORS chaîne reste jugé, même sur la ligne d'une prose", () => {
+    const source = 'const widgetId = t("le widget est prêt");';
+    expect(
+      findProductVocabulary(stripProseStrings(source), ["widget"]).map((m) => m.identifier),
+    ).toEqual(["widgetId"]);
+  });
+});

package/src/vocabulary.ts

@@ -116,8 +116,46 @@ export function findProductVocabulary(
  * one.
  */
 export function stripComments(sourceText: string): string {
-  const blankKeepingNewlines = (text: string): string => text.replace(/[^\n]/g, " ");
   return sourceText
     .replace(/\/\*[\s\S]*?\*\//g, blankKeepingNewlines)
     .replace(/\/\/[^\n]*/g, blankKeepingNewlines);
 }
+
+/** Blanks a run of text, keeping line count and column positions intact. */
+function blankKeepingNewlines(text: string): string {
+  return text.replace(/[^\n]/g, " ");
+}
+
+/**
+ * What a string literal may hold and still be judged: a MACHINE token — a
+ * table name, a route path, a translation key, an enum value. Anything with a
+ * space, an accent or punctuation beyond these is prose.
+ */
+const MACHINE_STRING_CONTENT = /^[A-Za-z0-9_$\-./:@]+$/;
+
+/**
+ * Blanks out the PROSE held in string literals, keeping the machine tokens.
+ *
+ * The gate judges identifiers, not language (spec B3). But a test title is
+ * prose inside a string — and the framework REQUIRES those titles to repeat
+ * the spec's French Given/When/Then verbatim, so a product whose domain word
+ * appears in its own spec was condemned to flag its own tests forever
+ * (FAILURES.md). Blanking whole strings would be too coarse the other way:
+ * `pgTable("vendor_codes")` and a translation key are exactly the identifiers
+ * the gate exists to catch, and they live in strings too.
+ *
+ * So the cut is on the CONTENT: one machine token is judged, anything else is
+ * prose. Deliberately lexical, like the comment stripper — a mis-parsed
+ * literal can only ever hide a violation, never invent one.
+ */
+export function stripProseStrings(sourceText: string): string {
+  const blankProse = (literal: string): string => {
+    const content = literal.slice(1, -1);
+    if (MACHINE_STRING_CONTENT.test(content)) return literal;
+    return literal[0] + blankKeepingNewlines(content) + literal[literal.length - 1];
+  };
+  return sourceText
+    .replace(/`(?:[^`\\]|\\[\s\S])*`/g, blankProse)
+    .replace(/"(?:[^"\\\n]|\\.)*"/g, blankProse)
+    .replace(/'(?:[^'\\\n]|\\.)*'/g, blankProse);
+}