eslint-plugin-unslop 0.5.1 → 0.5.3

package/README.md

@@ -42,11 +42,12 @@ export default [
 ]
 ```
 
-Architecture rules (`import-control`, `export-control`, `no-false-sharing`, `no-single-use-constants`) require a reachable `tsconfig.json`. Set `compilerOptions.rootDir`, and if you use aliases, configure `compilerOptions.paths`.
+Architecture rules (`import-control`, `no-whitebox-testing`, `export-control`, `no-false-sharing`, `no-single-use-constants`) require a reachable `tsconfig.json`. Set `compilerOptions.rootDir`, and if you use aliases, configure `compilerOptions.paths`.
 
 | Rule                             | What it does                                                           |
 | -------------------------------- | ---------------------------------------------------------------------- |
 | `unslop/import-control`          | Enforces module boundaries and forbids local namespace imports         |
+| `unslop/no-whitebox-testing`     | Keeps tests on module entrypoints instead of same-folder internals     |
 | `unslop/export-control`          | Restricts export patterns and forbids `export *` in module entrypoints |
 | `unslop/no-false-sharing`        | Flags shared entrypoint symbols with fewer than two consumer groups    |
 | `unslop/no-single-use-constants` | Flags module-scope constants used once or never across the project     |
@@ -71,6 +72,7 @@ All architecture rules read from `settings.unslop.architecture`. Each key is a m
 {
   imports?: string[]  // module matchers this module may import from; '*' allows all
   exports?: string[]  // regex patterns symbols exported from index.ts/types.ts must match
+  entrypoints?: string[] // public files allowed for external and test imports
   shared?: boolean    // marks module as shared; enables no-false-sharing
 }
 ```
@@ -92,6 +94,12 @@ Deny-by-default for cross-module imports, so forgetting to declare a dependency
 
 Alias imports are resolved via `compilerOptions.paths` from `tsconfig.json`.
 
+### `unslop/no-whitebox-testing`
+
+Keeps test files black-boxed. When a recognized test file lives beside a module's implementation, it must import that module through its public entrypoint (`.`, `./index`, or a configured `entrypoints` file) instead of reaching into sibling files like `./model.ts`.
+
+This rule only checks recognized test filenames (`*.test.*`, `*.spec.*`, `*.*-test.*`, `*.*-spec.*`). Child submodule imports and cross-module imports are left to `unslop/import-control`.
+
 ### `unslop/export-control`
 
 The customs declaration form for the other direction: what are you actually exporting from your module's public entrypoints?

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.5.1",
+  version: "0.5.3",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -523,8 +523,13 @@ function parseModulePolicy(rawPolicy) {
   if (!isRecord(rawPolicy)) return void 0;
   const imports = readStringList(rawPolicy.imports);
   const exports2 = readStringList(rawPolicy.exports);
+  const entrypoints = readEntrypoints(rawPolicy.entrypoints);
   const shared = rawPolicy.shared === true;
-  return { imports, exports: exports2, shared };
+  return { imports, exports: exports2, entrypoints, shared };
+}
+function readEntrypoints(value) {
+  const configured = readStringList(value);
+  return configured.length > 0 ? configured : ["index.ts"];
 }
 function readStringList(value) {
   if (!Array.isArray(value)) return [];
@@ -556,7 +561,7 @@ function makeDefaultModule(relativePath) {
   return {
     matcher: key,
     instance: key,
-    policy: { imports: [], exports: [], shared: false },
+    policy: { imports: [], exports: [], entrypoints: ["index.ts"], shared: false },
     order: 0
   };
 }
@@ -716,7 +721,7 @@ function reportUnsharedSymbols(context, node, options) {
   for (const symbol of exportedSymbols) {
     const consumerGroups = consumerGroupsBySymbol.get(symbol.exportedName);
     if (consumerGroups === void 0) continue;
-    if (consumerGroups.size >= MIN_CONSUMER_GROUPS) continue;
+    if (consumerGroups.size >= 2) continue;
     context.report({
       node,
       messageId: "notTrulyShared",
@@ -924,7 +929,6 @@ function getSingleConsumerGroup(groups) {
   const [single] = [...groups];
   return ` (group: ${single})`;
 }
-var MIN_CONSUMER_GROUPS = 2;
 
 // src/rules/read-friendly-order/ast-utils.ts
 function getDeclName(node) {
@@ -1620,13 +1624,13 @@ var import_control_default = {
   meta: {
     type: "problem",
     docs: {
-      description: "Enforce module import boundaries and public entrypoint imports",
+      description: "Enforce module import boundaries and configured entrypoint imports",
       recommended: false
     },
     schema: [],
     messages: {
       notAllowed: "Import denied: module {{from}} cannot import module {{to}}.",
-      nonEntrypoint: "Import denied: cross-module imports must target index.ts or types.ts.",
+      nonEntrypoint: "Import denied: cross-module imports must target a configured module entrypoint (offending import: {{specifier}}).",
       namespaceLocalForbidden: "Import denied: local cross-module namespace imports are not allowed.",
       tooDeep: "Import denied: same-module imports can only go one level deeper."
     }
@@ -1687,7 +1691,7 @@ function checkModuleEdge(options) {
     context.report({ node, messageId: "namespaceLocalForbidden" });
     return;
   }
-  if (isShallowRelativeEntrypoint(specifier, targetFile)) return;
+  if (isShallowRelativeEntrypoint(specifier, targetFile, importee.policy)) return;
   if (!allowsImport(importer.policy, importee.matcher)) {
     context.report({
       node,
@@ -1696,15 +1700,22 @@ function checkModuleEdge(options) {
     });
     return;
   }
-  if (isPublicEntrypoint(targetFile)) return;
-  context.report({ node, messageId: "nonEntrypoint" });
+  if (isAllowedModuleEntrypoint(targetFile, importee.policy)) return;
+  context.report({
+    node,
+    messageId: "nonEntrypoint",
+    data: { specifier }
+  });
 }
 function isLocalNamespaceImport(node) {
   if (node.type !== "ImportDeclaration") return false;
   return node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
 }
-function isShallowRelativeEntrypoint(specifier, targetFile) {
-  return !isRelativeTooDeep(specifier) && specifier.startsWith("./") && isPublicEntrypoint(targetFile);
+function isShallowRelativeEntrypoint(specifier, targetFile, policy) {
+  return !isRelativeTooDeep(specifier) && specifier.startsWith("./") && isAllowedModuleEntrypoint(targetFile, policy);
+}
+function isAllowedModuleEntrypoint(targetFile, policy) {
+  return policy.entrypoints.includes(import_node_path5.default.basename(targetFile));
 }
 function reportDeepSameModuleImport(context, node, importerFile, targetFile) {
   if (!isSameModuleImportTooDeep(importerFile, targetFile)) return;
@@ -1731,7 +1742,78 @@ function isRelativeTooDeep(specifier) {
   return depth > 1;
 }
 function allowsImport(policy, targetMatcher) {
-  return policy.imports.includes("*") || policy.imports.includes(targetMatcher);
+  if (policy.imports.includes("*")) return true;
+  return policy.imports.some((pattern) => importPatternMatches(pattern, targetMatcher));
+}
+function importPatternMatches(pattern, target) {
+  const patternSegs = pattern.split("/").filter(Boolean);
+  const targetSegs = target.split("/").filter(Boolean);
+  if (patternSegs.length !== targetSegs.length) return false;
+  return patternSegs.every((seg, i) => seg === "*" || seg === targetSegs[i]);
+}
+
+// src/rules/no-whitebox-testing/index.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var no_whitebox_testing_default = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require tests to import a module through its public entrypoint",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      usePublicEntrypoint: "White-box test import denied: tests must import this module through its public entrypoint (offending import: {{specifier}})."
+    }
+  },
+  create(context) {
+    if (!isRecognizedTestFile(context.filename)) return {};
+    const state = getArchitectureRuleState(context);
+    if (state === void 0) return {};
+    return {
+      ImportDeclaration(node) {
+        checkImportDeclaration(context, node, state);
+      }
+    };
+  }
+};
+function checkImportDeclaration(context, node, state) {
+  const resolvedImport = resolveImport(node, state);
+  if (resolvedImport === void 0) return;
+  if (resolvedImport.targetModule.instance !== state.moduleMatch.instance) return;
+  if (!isSameDirectoryImport(state.filename, resolvedImport.targetFile)) return;
+  if (isAllowedModuleEntrypoint2(resolvedImport.targetFile, state.moduleMatch.policy.entrypoints))
+    return;
+  context.report({
+    node,
+    messageId: "usePublicEntrypoint",
+    data: { specifier: resolvedImport.specifier }
+  });
+}
+function resolveImport(node, state) {
+  const specifier = getSpecifier2(node);
+  if (specifier === void 0) return void 0;
+  const resolvedTarget = resolveImportTarget(state.filename, state.policy.projectContext, specifier);
+  if (resolvedTarget === void 0) return void 0;
+  const targetFile = normalizeResolvedPath2(resolvedTarget);
+  const targetModule = matchFileToArchitectureModule(targetFile, state.policy);
+  if (targetModule === void 0) return void 0;
+  return { specifier, targetFile, targetModule };
+}
+function getSpecifier2(node) {
+  const value = node.source.value;
+  return typeof value === "string" ? value : void 0;
+}
+function isRecognizedTestFile(filename) {
+  if (filename.length === 0) return false;
+  const basename = import_node_path6.default.basename(filename);
+  return /^.+\.test\..+$/.test(basename) || /^.+\.spec\..+$/.test(basename) || /^.+\.[^.]+-test\..+$/.test(basename) || /^.+\.[^.]+-spec\..+$/.test(basename);
+}
+function isSameDirectoryImport(importerFile, targetFile) {
+  return isSamePath(import_node_path6.default.dirname(importerFile), import_node_path6.default.dirname(targetFile));
+}
+function isAllowedModuleEntrypoint2(targetFile, entrypoints) {
+  return entrypoints.includes(import_node_path6.default.basename(targetFile));
 }
 
 // src/rules/export-control/index.ts
@@ -2024,6 +2106,7 @@ var rules_default = {
   "no-false-sharing": no_false_sharing_default,
   "read-friendly-order": read_friendly_order_default,
   "import-control": import_control_default,
+  "no-whitebox-testing": no_whitebox_testing_default,
   "export-control": export_control_default,
   "no-single-use-constants": no_single_use_constants_default
 };
@@ -2052,6 +2135,7 @@ var full = {
     "unslop/no-special-unicode": "error",
     "unslop/no-unicode-escape": "error",
     "unslop/import-control": "error",
+    "unslop/no-whitebox-testing": "error",
     "unslop/export-control": "error",
     "unslop/no-false-sharing": "error",
     "unslop/no-single-use-constants": "error",