@cuzfrog/pi-module-gates 0.17.2 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuzfrog/pi-module-gates",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "pi extension that controls the entropy of the codebase by enforcing code module boundaries.",
   "keywords": [
     "pi-package"

package/src/gates/checkers/go.ts

@@ -13,7 +13,33 @@ const goChecker: ExportChecker = {
 registerChecker(goChecker);
 
 function extractExports(src: string): Signature[] {
-  return [...src.matchAll(
-    /^(?:func\s+(?!\()|type\s+|var\s+|const\s+)([\p{Lu}]\w*)/gmu,
-  )].map((m) => ({ name: m[1] }));
+  const out: Signature[] = [];
+
+  for (const m of src.matchAll(
+    /^(?:func\s+(?:\([^)]*\)\s+)?|type\s+|var\s+|const\s+)([\p{Lu}]\w*)/gmu,
+  )) {
+    out.push({ name: m[1] });
+  }
+
+  for (const block of src.matchAll(/(?:^|\n)(?:var|const)\s*\(([\s\S]*?)\)/g)) {
+    const inner = block[1];
+    for (const line of inner.split(/\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const m = /^([\p{Lu}]\w*)(?:\s*(?::\s*[\w.\[\]any, |]+)?=\s*[\s\S]*|\s*$)/u.exec(trimmed);
+      if (m) out.push({ name: m[1] });
+    }
+  }
+
+  for (const iface of src.matchAll(/(?:^|\n)type\s+[\p{Lu}]\w*\s+interface\s*\{([\s\S]*?)\}/gu)) {
+    const inner = iface[1];
+    for (const line of inner.split(/\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const m = /^([\p{Lu}]\w*)\s*\(/u.exec(trimmed);
+      if (m) out.push({ name: m[1] });
+    }
+  }
+
+  return out;
 }

package/src/gates/checkers/java.ts

@@ -14,6 +14,6 @@ registerChecker(javaChecker);
 
 function extractExports(src: string): Signature[] {
   return [...src.matchAll(
-    /^public\s+(?:class|interface|enum|@interface|record)\s+(\w+)/gm,
-  )].map((m) => ({ modifier: "public", name: m[1] }));
+    /^(?:@\w+(?:\([^)]*\))?\s+)*public\s+(?:(?:abstract|final|sealed|non-sealed|static)\s+)*(class|interface|enum|@interface|record)\s+(\w+)/gm,
+  )].map((m) => ({ modifier: "public", name: m[2] }));
 }

package/src/gates/checkers/kotlin.ts

@@ -13,14 +13,26 @@ const kotlinChecker: ExportChecker = {
 registerChecker(kotlinChecker);
 
 function extractExports(src: string): Signature[] {
-  const re = /^(?:(public|internal|protected|private)\s+)?(?:(?:data|sealed|enum|abstract|open)\s+)?(?:class|interface|object|fun|val|var|typealias)\s+(\w+)/gm;
+  const declRe = /^(?:@\w+(?:\([^)]*\))?\s+)*(?:(public|internal|private)\s+)?(?:(?:data|sealed|enum|abstract|open|final|inline|value|annotation|expect|actual|external)\s+)*(?:companion\s+)?(?:class|interface|object|fun|val|var|typealias)\s+(\w+)/m;
   const results: Signature[] = [];
-  for (const m of src.matchAll(re)) {
-    if (m[1] === "private") continue;
-    results.push({
-      modifier: m[1] || undefined,
-      name: m[2],
-    });
+  let depth = 0;
+  for (const rawLine of src.split("\n")) {
+    const line = rawLine.replace(/\/\/.*$/, "").replace(/\/\*.*?\*\//g, "");
+    if (depth === 0) {
+      const m = declRe.exec(line);
+      if (m) {
+        const visibility = m[1];
+        const name = m[2];
+        if (visibility === "private") {
+          // skip
+        } else {
+          results.push({ modifier: visibility, name });
+        }
+      }
+    }
+    depth += (line.match(/\{/g) || []).length;
+    depth -= (line.match(/\}/g) || []).length;
+    if (depth < 0) depth = 0;
   }
   return results;
 }

package/src/gates/checkers/rust.ts

@@ -5,8 +5,12 @@ import type { Signature } from "../../types.ts";
 const rustChecker: ExportChecker = {
   extensions: [".rs"],
   getNewExports(before: string, after: string): Signature[] {
-    const beforeNames = new Set(extractPubItems(before).map((s) => s.name));
-    return extractPubItems(after).filter((sig) => !beforeNames.has(sig.name));
+    const beforeNames = new Set(
+      [...extractPubItems(before), ...extractPubUses(before)].map((s) => s.name),
+    );
+    return [...extractPubItems(after), ...extractPubUses(after)].filter(
+      (sig) => !beforeNames.has(sig.name),
+    );
   },
 };
 
@@ -14,6 +18,71 @@ registerChecker(rustChecker);
 
 function extractPubItems(src: string): Signature[] {
   return [...src.matchAll(
-    /^(pub(?:\([^)]*\))?)\s+(?:fn|struct|enum|trait|type|const|mod)\s+(\w+)/gm,
+    /^(pub(?:\([^)]*\))?)(?:\s+(?:unsafe|async|const|extern(?:\s+"[^"]+")?))*\s+(?:fn|struct|enum|trait|type|const|mod|static)\s+(\w+)/gm,
   )].map((m) => ({ modifier: m[1], name: m[2] }));
 }
+
+function extractPubUses(src: string): Signature[] {
+  const out: Signature[] = [];
+  const re = /^(pub(?:\([^)]*\))?)\s+use\s+([\s\S]*?);/gm;
+  for (const m of src.matchAll(re)) {
+    const modifier = m[1];
+    const body = m[2];
+    for (const name of extractUseNames(body)) {
+      out.push({ modifier, name });
+    }
+  }
+  return out;
+}
+
+function extractUseNames(body: string): string[] {
+  const trimmed = body.trim();
+  const groupMatch = /^(.+?)::\s*\{([\s\S]*)\}\s*$/.exec(trimmed);
+  if (groupMatch) {
+    const prefix = groupMatch[1].split("::").pop() ?? "";
+    return extractGroupItems(groupMatch[2], prefix);
+  }
+  const last = trimmed.split("::").pop() ?? "";
+  if (last === "self") {
+    const segments = trimmed.split("::");
+    segments.pop();
+    const fallback = segments.pop() ?? "";
+    return fallback ? [fallback] : [];
+  }
+  const parsed = parseRenamed(last);
+  return parsed && parsed !== "*" ? [parsed] : [];
+}
+
+function extractGroupItems(inner: string, prefix: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let buf = "";
+  for (const ch of inner) {
+    if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+    if (ch === "," && depth === 0) {
+      pushItem(buf, out, prefix);
+      buf = "";
+    } else {
+      buf += ch;
+    }
+  }
+  pushItem(buf, out, prefix);
+  return out;
+}
+
+function pushItem(raw: string, out: string[], prefix: string): void {
+  const item = raw.trim();
+  if (!item || item === "*") return;
+  if (item === "self") {
+    if (prefix) out.push(prefix);
+    return;
+  }
+  out.push(parseRenamed(item));
+}
+
+function parseRenamed(item: string): string {
+  const asIdx = item.lastIndexOf(" as ");
+  const tail = asIdx >= 0 ? item.slice(asIdx + 4) : item;
+  return tail.split("::").pop() ?? "";
+}

package/src/gates/checkers/scala.ts

@@ -13,14 +13,26 @@ const scalaChecker: ExportChecker = {
 registerChecker(scalaChecker);
 
 function extractExports(src: string): Signature[] {
-  const re = /^(?:(private(?:\[[^\]]*\])?|protected(?:\[[^\]]*\])?)\s+)?(?:class|object|trait|def|val|var|type|given|extension)\s+(\w+)/gm;
+  const declRe = /^(?:@\w+(?:\([^)]*\))?\s+)*(?:(private(?:\[[^\]]*\])?|protected(?:\[[^\]]*\])?|public)\s+)?(?:(?:sealed|final|abstract|lazy|opaque|implicit)\s+)*(?:case\s+)?(?:class|object|trait|def|val|var|type|enum|given|extension)\s+(\w+)/m;
   const results: Signature[] = [];
-  for (const m of src.matchAll(re)) {
-    if (m[1] === "private" || m[1] === "protected") continue;
-    results.push({
-      modifier: m[1] || undefined,
-      name: m[2],
-    });
+  let depth = 0;
+  for (const rawLine of src.split("\n")) {
+    const line = rawLine.replace(/\/\/.*$/, "");
+    if (depth === 0) {
+      const m = declRe.exec(line);
+      if (m) {
+        const visibility = m[1];
+        const name = m[2];
+        if (visibility === "private" || visibility === "protected") {
+          // skip bare private/protected
+        } else {
+          results.push({ modifier: visibility, name });
+        }
+      }
+    }
+    depth += (line.match(/\{/g) || []).length;
+    depth -= (line.match(/\}/g) || []).length;
+    if (depth < 0) depth = 0;
   }
   return results;
 }

package/src/gates/checkers/typescript.ts

@@ -12,39 +12,55 @@ const tsChecker: ExportChecker = {
 
 registerChecker(tsChecker);
 
+const ANNOTATION_PREFIX = String.raw`(?:@[^\n]*\n)*[ \t]*`;
+const DECL_KEYWORD = String.raw`(?:function(?:\s*\*)?|class|const|let|var|type|interface|enum)`;
+const DECL_KEYWORD_NEG = String.raw`(?:function\s*\*?|class|const|let|var|type|interface|enum|abstract|async|declare)`;
+
 function extractExports(src: string): Signature[] {
-  const results: Signature[] = [
-    ...src.matchAll(
-      /^export\s+(?:default\s+)?(?:\w+\s+)*(?:function(?:\s*\*)?|class|const|let|var|type|interface|enum)\s+(\w+)/gm,
-    ),
-  ].map((m) => ({ name: m[1] }));
+  const results: Signature[] = [];
+
+  for (const m of src.matchAll(
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s+(?:default\\s+)?(?:\\w+\\s+)*${DECL_KEYWORD}\\s+(\\w+)`, "gm"),
+  )) {
+    results.push({ name: m[1] });
+  }
 
   for (const m of src.matchAll(
-    /^export\s*(?:type\s+)?\{\s*([^}]+)\s*\}\s*from/gm,
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s*(?:type\\s+)?\\{\\s*([^}]+?)\\s*\\}(?:\\s+from\\b)?`, "gm"),
   )) {
     const inner = m[1];
     for (const entry of inner.split(",")) {
-      const trimmed = entry.trim();
+      let trimmed = entry.trim();
       if (!trimmed) continue;
-      const asMatch = trimmed.match(/^(\w+)\s+as\s+(\w+)$/);
-      if (asMatch) {
-        results.push({ name: asMatch[2] });
-      } else {
-        results.push({ name: trimmed });
+      if (trimmed.startsWith("type ")) {
+        trimmed = trimmed.slice(5).trim();
+        if (!trimmed) continue;
       }
+      const asMatch = trimmed.match(/^(\w+)\s+as\s+(\w+)$/);
+      results.push({ name: asMatch ? asMatch[2] : trimmed });
     }
   }
 
-  for (const m of src.matchAll(/^export\s*\*\s*as\s+(\w+)\s+from/gm)) {
+  for (const m of src.matchAll(
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s+(?:type\\s+)?\\*\\s+from`, "gm"),
+  )) {
+    results.push({ name: "*" });
+  }
+
+  for (const m of src.matchAll(
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s*\\*\\s+as\\s+(\\w+)\\s+from`, "gm"),
+  )) {
     results.push({ name: m[1] });
   }
 
-  for (const m of src.matchAll(/^export\s*\*\s+from/gm)) {
-    results.push({ name: "*" });
+  for (const m of src.matchAll(
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s*=\\s*(\\w+)`, "gm"),
+  )) {
+    results.push({ name: m[1] });
   }
 
   for (const m of src.matchAll(
-    /^export\s+default\s+(?!function|class|const|let|var|type|interface|enum|abstract|async|declare)([a-zA-Z_]\w*)/gm,
+    new RegExp(`^${ANNOTATION_PREFIX}export\\s+default\\s+(?!${DECL_KEYWORD_NEG})([a-zA-Z_]\\w*)`, "gm"),
   )) {
     results.push({ name: m[1] });
   }