feat: rename encapsulatedFolderNameForBarrelLess to `encapsulationP…

packages/core/src/lib/checks/has-encapsulation-violations.ts

@@ -2,6 +2,7 @@ import { FsPath } from '../file-info/fs-path';
 import { Configuration } from '../config/configuration';
 import { ProjectInfo } from '../main/init';
 import { FileInfo } from '../modules/file.info';
+import getFs from '../fs/getFs';
 
 /**
  * verifies if an existing file has imports which break
@@ -23,19 +24,30 @@ export function hasEncapsulationViolations(
       isSameModule(importedFileInfo, assignedFileInfo) ||
       isExcludedRootModule(rootDir, config, importedFileInfo) ||
       accessesBarrelFileForBarrelModules(importedFileInfo) ||
-      accessesExposedFileForBarrelLessModules(importedFileInfo, config.enableBarrelLess)
+      accessesExposedFileForBarrelLessModules(
+        importedFileInfo,
+        config.enableBarrelLess,
+        config.encapsulationPatternForBarrelLess,
+      )
     ) {
       // 👍 all good
     } else {
-      const rawImport = assignedFileInfo.getRawImportForImportedFileInfo(importedFileInfo.path);
+      const rawImport = assignedFileInfo.getRawImportForImportedFileInfo(
+        importedFileInfo.path,
+      );
       encapsulationViolations[rawImport] = importedFileInfo;
     }
   }
 
   return encapsulationViolations;
 }
 
-function accessesExposedFileForBarrelLessModules(fileInfo: FileInfo, enableBarrelLess: boolean) {
+function accessesExposedFileForBarrelLessModules(
+  fileInfo: FileInfo,
+  enableBarrelLess: boolean,
+  encapsulationPatternForBarrelLess: string,
+) {
+  const fs = getFs();
   if (!enableBarrelLess) {
     return false;
   }
@@ -44,13 +56,8 @@ function accessesExposedFileForBarrelLessModules(fileInfo: FileInfo, enableBarre
     return false;
   }
 
-  const possibleEncapsulatedFolderPath =
-    fileInfo.moduleInfo.getEncapsulatedFolder();
-  if (possibleEncapsulatedFolderPath === undefined) {
-    return true;
-  }
-
-  return !fileInfo.path.startsWith(possibleEncapsulatedFolderPath);
+  const relativePath = fs.relativeTo(fileInfo.moduleInfo.path, fileInfo.path);
+  return !relativePath.startsWith(encapsulationPatternForBarrelLess);
 }
 
 function accessesBarrelFileForBarrelModules(fileInfo: FileInfo) {
@@ -74,5 +81,5 @@ function isExcludedRootModule(
 }
 
 function isSameModule(importedFileInfo: FileInfo, assignedFileInfo: FileInfo) {
-  return importedFileInfo.moduleInfo.path === assignedFileInfo.moduleInfo.path
+  return importedFileInfo.moduleInfo.path === assignedFileInfo.moduleInfo.path;
 }

packages/core/src/lib/checks/tests/encapsulation-barrel-less.spec.ts

@@ -6,6 +6,68 @@ import { hasEncapsulationViolations } from '../has-encapsulation-violations';
 import { UserSheriffConfig } from '../../config/user-sheriff-config';
 import { traverseFileInfo } from '../../modules/traverse-file-info';
 
+function assertProject(config: Partial<UserSheriffConfig> = {}) {
+  return {
+    withCustomerRoute(customerFileTree: FileTree) {
+      return {
+        hasEncapsulationViolations(
+          encapsulationViolations: Record<string, string[]> = {},
+        ) {
+          const projectInfo = testInit('src/main.ts', {
+            'tsconfig.json': tsConfig(),
+            'sheriff.config.ts': sheriffConfig({
+              ...{
+                modules: {
+                  'src/app/<domain>/<type>': ['domain:<domain>', 'type:<type>'],
+                },
+                depRules: {},
+                enableBarrelLess: true,
+              },
+              ...config,
+            }),
+            src: {
+              'main.ts': ['./app/app.routes'],
+              app: {
+                'app.routes.ts': [
+                  './customer/feature/customer.component.ts',
+                  './customer/feature/customers.component.ts',
+                ],
+                customer: customerFileTree,
+              },
+            },
+          });
+
+          for (const { fileInfo } of traverseFileInfo(projectInfo.fileInfo)) {
+            expect(
+              fileInfo.hasUnresolvedImports(),
+              `${fileInfo.path} has unresolved imports`,
+            ).toBe(false);
+
+            const pathToLookup = fileInfo.path.replace(
+              '/project/src/app/customer/',
+              '',
+            );
+
+            const expectedDeepImports =
+              encapsulationViolations[pathToLookup] || [];
+            const violations = hasEncapsulationViolations(
+              fileInfo.path,
+              projectInfo,
+            );
+            const violatedImports = Object.keys(violations);
+            expect
+              .soft(
+                violatedImports,
+                `deep imports check failed for ${fileInfo.path}`,
+              )
+              .toEqual(expectedDeepImports);
+          }
+        },
+      };
+    },
+  };
+}
+
 describe('barrel-less', () => {
   it('should check for deep imports', () => {
     assertProject()
@@ -91,7 +153,7 @@ describe('barrel-less', () => {
 
   it('should be able to change the name of internals', () => {
     assertProject({
-      encapsulatedFolderNameForBarrelLess: 'private',
+      encapsulationPatternForBarrelLess: 'private',
     })
       .withCustomerRoute({
         feature: {
@@ -125,60 +187,51 @@ describe('barrel-less', () => {
         'feature/customers.component.ts': ['../data/open.service.ts'],
       });
   });
-});
 
-function assertProject(config: Partial<UserSheriffConfig> = {}) {
-  return {
-    withCustomerRoute(customerFileTree: FileTree) {
-      return {
-        hasEncapsulationViolations(encapsulationViolations: Record<string, string[]> = {}) {
-          const projectInfo = testInit('src/main.ts', {
-            'tsconfig.json': tsConfig(),
-            'sheriff.config.ts': sheriffConfig({
-              ...{
-                modules: {
-                  'src/app/<domain>/<type>': ['domain:<domain>', 'type:<type>'],
-                },
-                depRules: {},
-                enableBarrelLess: true,
-              },
-              ...config,
-            }),
-            src: {
-              'main.ts': ['./app/app.routes'],
-              app: {
-                'app.routes.ts': [
-                  './customer/feature/customer.component.ts',
-                  './customer/feature/customers.component.ts',
-                ],
-                customer: customerFileTree,
-              },
+  it('should be by default first level only', () => {
+    assertProject()
+      .withCustomerRoute({
+        feature: {
+          'customer.component.ts': [''],
+          'customers.component.ts': ['../data/sub1/internal/hidden.service.ts'],
+        },
+        data: {
+          sub1: {
+            internal: { 'hidden.service.ts': [] },
+          },
+        },
+      })
+      .hasEncapsulationViolations({});
+  });
+
+  it.skip('should support wildcards', () => {
+    assertProject({ encapsulationPatternForBarrelLess: '**/internal' })
+      .withCustomerRoute({
+        feature: {
+          'customer.component.ts': [],
+          'customers.component.ts': [
+            '../data/sub1/internal/hidden.service.ts',
+            '../data/sub2/sub3/internal/hidden.service.ts',
+          ],
+        },
+        data: {
+          sub1: {
+            internal: { 'hidden.service.ts': [] },
+          },
+          sub2: {
+            sub3: {
+              internal: { 'hidden.service.ts': [] },
             },
-          });
+          },
+        },
+      })
+      .hasEncapsulationViolations({
+        'feature/customers.component.ts': ['../data/open.service.ts'],
+      });
+  });
 
-          for (const { fileInfo } of traverseFileInfo(projectInfo.fileInfo)) {
-            expect(
-              fileInfo.hasUnresolvedImports(),
-              `${fileInfo.path} has unresolved imports`,
-            ).toBe(false);
+  it.skip('should support nested wildcards', () => {});
 
-            const pathToLookup = fileInfo.path.replace(
-              '/project/src/app/customer/',
-              '',
-            );
+  it.skip('should apply regex to path', () => {});
+});
 
-            const expectedDeepImports = encapsulationViolations[pathToLookup] || [];
-            const violations = hasEncapsulationViolations(fileInfo.path, projectInfo);
-            const violatedImports = Object.keys(violations);
-            expect
-              .soft(
-                violatedImports,
-                `deep imports check failed for ${fileInfo.path}`,
-              )
-              .toEqual(expectedDeepImports);
-          }
-        },
-      };
-    },
-  };
-}

packages/core/src/lib/config/configuration.ts

@@ -1,6 +1,13 @@
 import { UserSheriffConfig } from './user-sheriff-config';
 
-export type Configuration = Required<Omit<UserSheriffConfig, 'tagging'>> & {
+export type Configuration = Required<
+  Omit<
+    UserSheriffConfig,
+    | 'tagging'
+    | 'showWarningOnBarrelCollision'
+    | 'encapsulatedFolderNameForBarrelLess'
+  >
+> & {
   // dependency rules will skip if `isConfigFileMissing` is true
   isConfigFileMissing: boolean;
 };

packages/core/src/lib/config/default-config.ts

@@ -7,8 +7,7 @@ export const defaultConfig: Configuration = {
   depRules: {},
   excludeRoot: false,
   enableBarrelLess: false,
-  encapsulatedFolderNameForBarrelLess: 'internal',
-  showWarningOnBarrelCollision: true,
+  encapsulationPatternForBarrelLess: 'internal',
   log: false,
   entryFile: '',
   isConfigFileMissing: false,

packages/core/src/lib/config/parse-config.ts

@@ -4,6 +4,7 @@
 import getFs from '../fs/getFs';
 import { Configuration } from './configuration';
 import {
+  CollidingEncapsulationSettings,
   MissingModulesWithoutAutoTaggingError,
   TaggingAndModulesError,
 } from '../error/user-error';
@@ -24,12 +25,23 @@
   if (userSheriffConfig.tagging && userSheriffConfig.modules) {
     throw new TaggingAndModulesError();
   }
-
   if (userSheriffConfig.tagging) {
-    const {tagging, ...rest} = userSheriffConfig;
-    return { ...defaultConfig, ...rest, modules: tagging };
+    userSheriffConfig.modules = userSheriffConfig.tagging;
+  }
 
-  } else {
-    return { ...defaultConfig, ...userSheriffConfig };
+  if (
+    userSheriffConfig.encapsulationPatternForBarrelLess !== undefined &&
+    userSheriffConfig.encapsulatedFolderNameForBarrelLess !== undefined
+  ) {
+    throw new CollidingEncapsulationSettings();
   }
+
+  if (userSheriffConfig.encapsulatedFolderNameForBarrelLess) {
+    userSheriffConfig.encapsulationPatternForBarrelLess =
+      userSheriffConfig.encapsulatedFolderNameForBarrelLess;
+  }
+
+  const { tagging, encapsulatedFolderNameForBarrelLess, ...rest } =
+    userSheriffConfig;
+  return { ...defaultConfig, ...rest };
 };