@archest/vitest 1.0.1 → 1.0.2

package/src/core/slices/sliceCheckHaveMaxDistanceFromMainSequence.ts

@@ -1,110 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { SliceLocatorData } from './types';
-
-export function sliceCheckHaveMaxDistanceFromMainSequence(
-  locator: SliceLocatorData,
-  max: number,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-
-  const ceMap = new Map<string, Set<string>>(); // Slices this slice depends on
-  const caMap = new Map<string, Set<string>>(); // Slices depending on this slice
-
-  for (const slice of locator.sliceIds) {
-    ceMap.set(slice, new Set());
-    caMap.set(slice, new Set());
-  }
-
-  for (const [sliceId, files] of locator.sliceFiles.entries()) {
-    for (const sf of files) {
-      ts.forEachChild(sf, (node) => {
-        if (
-          ts.isImportDeclaration(node) &&
-          node.moduleSpecifier &&
-          ts.isStringLiteral(node.moduleSpecifier)
-        ) {
-          const importPath = node.moduleSpecifier.text;
-          const resolved = ts.resolveModuleName(
-            importPath,
-            sf.fileName,
-            locator.program.getCompilerOptions(),
-            ts.sys,
-          );
-          if (resolved.resolvedModule?.resolvedFileName) {
-            const targetMatch = resolved.resolvedModule.resolvedFileName.match(
-              locator.slicePattern,
-            );
-            if (targetMatch?.[1]) {
-              const targetSlice = targetMatch[1];
-              if (
-                targetSlice !== sliceId &&
-                locator.sliceIds.has(targetSlice)
-              ) {
-                ceMap.get(sliceId)?.add(targetSlice);
-                caMap.get(targetSlice)?.add(sliceId);
-              }
-            }
-          }
-        }
-      });
-    }
-  }
-
-  for (const sliceId of locator.sliceIds) {
-    const ce = ceMap.get(sliceId)?.size;
-    const ca = caMap.get(sliceId)?.size;
-
-    // biome-ignore lint/style/noNonNullAssertion: Safe map lookup
-    const files = locator.sliceFiles.get(sliceId)!;
-    let na = 0; // abstract classes + interfaces
-    let nc = 0; // all classes + interfaces
-
-    for (const sf of files) {
-      const visit = (node: ts.Node) => {
-        if (ts.isClassDeclaration(node)) {
-          nc++;
-          const modifiers = ts.canHaveModifiers(node)
-            ? ts.getModifiers(node)
-            : undefined;
-          if (
-            modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)
-          ) {
-            na++;
-          }
-        } else if (ts.isInterfaceDeclaration(node)) {
-          nc++;
-          na++;
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(sf);
-    }
-
-    const I = ce + ca === 0 ? 0 : ce / (ca + ce);
-    const A = nc === 0 ? 0 : na / nc;
-
-    const D = Math.abs(A + I - 1);
-    const exceeds = D > max;
-
-    if (isNot && exceeds) {
-      violations.push(
-        `Slice ${sliceId} has a Distance from the Main Sequence of ${D.toFixed(2)}, which exceeds the maximum of ${max}, but it shouldn't.`,
-      );
-    } else if (!isNot && exceeds) {
-      violations.push(
-        `Slice ${sliceId} has a Distance from the Main Sequence of ${D.toFixed(2)}, which exceeds the maximum of ${max}.`,
-      );
-    }
-  }
-
-  return {
-    pass: isNot ? violations.length > 0 : violations.length === 0,
-    message: () =>
-      violations.join('\n') ||
-      (isNot
-        ? 'Expected some slices to exceed maximum distance from main sequence, but none did.'
-        : ''),
-  };
-}

package/src/core/slices/types.ts

@@ -1,9 +0,0 @@
-import type * as ts from 'typescript';
-
-export interface SliceLocatorData {
-  type: 'SliceLocator';
-  slicePattern: RegExp;
-  sliceIds: Set<string>;
-  sliceFiles: Map<string, ts.SourceFile[]>;
-  program: ts.Program;
-}

package/src/core/testUtils.ts

@@ -1,61 +0,0 @@
-import * as ts from 'typescript';
-
-export function createSourceFile(
-  code: string,
-  fileName = 'test.ts',
-): ts.SourceFile {
-  return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true);
-}
-
-export function createMockProgram(sourceFiles: ts.SourceFile[]): ts.Program {
-  const compilerOptions = {};
-  const host = ts.createCompilerHost(compilerOptions);
-
-  host.getSourceFile = (fileName) => {
-    return sourceFiles.find((sf) => sf.fileName === fileName) || undefined;
-  };
-
-  return ts.createProgram({
-    rootNames: sourceFiles.map((sf) => sf.fileName),
-    options: compilerOptions,
-    host: host,
-  });
-}
-
-export function getClasses(sourceFile: ts.SourceFile): ts.ClassDeclaration[] {
-  const classes: ts.ClassDeclaration[] = [];
-  ts.forEachChild(sourceFile, (node) => {
-    if (ts.isClassDeclaration(node)) classes.push(node);
-  });
-  return classes;
-}
-
-export function getFunctions(
-  sourceFile: ts.SourceFile,
-): ts.FunctionLikeDeclaration[] {
-  const functions: ts.FunctionLikeDeclaration[] = [];
-  ts.forEachChild(sourceFile, (node) => {
-    if (
-      ts.isFunctionDeclaration(node) ||
-      ts.isMethodDeclaration(node) ||
-      ts.isArrowFunction(node)
-    ) {
-      functions.push(node as ts.FunctionLikeDeclaration);
-    }
-  });
-  return functions;
-}
-
-export function getProperties(
-  sourceFile: ts.SourceFile,
-): ts.PropertyDeclaration[] {
-  const properties: ts.PropertyDeclaration[] = [];
-  ts.forEachChild(sourceFile, (node) => {
-    if (ts.isClassDeclaration(node)) {
-      node.members.forEach((member) => {
-        if (ts.isPropertyDeclaration(member)) properties.push(member);
-      });
-    }
-  });
-  return properties;
-}

package/src/core/types.ts

@@ -1,19 +0,0 @@
-import type { ClassLocatorData } from './classes/types';
-import type { FileLocatorData } from './files/types';
-import type { FunctionLocatorData } from './functions/types';
-import type { LayeredArchitectureData } from './layers/types';
-import type { PropertyLocatorData } from './properties/types';
-import type { SliceLocatorData } from './slices/types';
-
-export interface RuleResult {
-  pass: boolean;
-  message: () => string;
-}
-
-export type LocatorData =
-  | FileLocatorData
-  | ClassLocatorData
-  | FunctionLocatorData
-  | PropertyLocatorData
-  | SliceLocatorData
-  | LayeredArchitectureData;

package/src/core/utils/ruleBuilder.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ruleBuilder } from './ruleBuilder';
-
-describe('ruleBuilder edge cases', () => {
-  it('should pass if items array is empty', () => {
-    const result = ruleBuilder([], false, () => ({
-      passes: false,
-      failMessage: '',
-      failNotMessage: '',
-    }));
-    expect(result.pass).toBe(true);
-  });
-
-  it('should generate correct violation message with NOT', () => {
-    const items = [{ name: 'A' }];
-    const result = ruleBuilder(items, true, () => ({
-      passes: true,
-      failMessage: '',
-      failNotMessage: 'Item A should NOT be nice',
-    }));
-    expect(result.pass).toBe(false);
-    expect(result.message()).toContain('Item A should NOT be nice');
-  });
-});

package/src/core/utils/ruleBuilder.ts

@@ -1,28 +0,0 @@
-import type { RuleResult } from '../types';
-
-export function ruleBuilder<T>(
-  items: T[],
-  isNot: boolean,
-  evaluate: (item: T) => {
-    passes: boolean;
-    failMessage: string;
-    failNotMessage: string;
-  },
-): RuleResult {
-  const violations: string[] = [];
-
-  for (const item of items) {
-    const { passes, failMessage, failNotMessage } = evaluate(item);
-
-    if (isNot && passes) {
-      if (failNotMessage) violations.push(failNotMessage);
-    } else if (!isNot && !passes) {
-      if (failMessage) violations.push(failMessage);
-    }
-  }
-
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/index.ts

@@ -1,35 +0,0 @@
-export * from './core/classes/classCheckExtendClass';
-export * from './core/classes/classCheckHaveMaxCyclomaticComplexity';
-export * from './core/classes/classCheckHaveModifier';
-export * from './core/classes/classCheckHaveNameMatchingFileName';
-export * from './core/classes/classCheckImplementInterface';
-export * from './core/classes/classCheckMatchNamePattern';
-export * from './core/classes/classCheckResideInFolder';
-export * from './core/classes/locateClasses';
-export * from './core/files/checkDependOnFilesInFolder';
-export * from './core/files/fileCheckBeFreeOfCycles';
-export * from './core/files/fileCheckHaveMaxCyclomaticComplexity';
-export * from './core/files/fileCheckHaveMaxExportedFunctions';
-export * from './core/files/fileCheckHaveMinMaintainabilityIndex';
-export * from './core/files/fileCheckMatchNamePattern';
-export * from './core/files/locateFiles';
-export * from './core/functions/functionCheckHaveExplicitReturnType';
-export * from './core/functions/functionCheckHaveMaxCyclomaticComplexity';
-export * from './core/functions/functionCheckHaveMinMaintainabilityIndex';
-export * from './core/functions/functionCheckHaveModifier';
-export * from './core/functions/functionCheckHaveNameMatchingFileName';
-export * from './core/functions/functionCheckMatchNamePattern';
-export * from './core/functions/locateFunctions';
-export * from './core/layers/checkLayeredArchitecture';
-export * from './core/layers/createLayeredArchitecture';
-export * from './core/layers/layer';
-export * from './core/layers/layerShouldNotBeAccessedByAnyLayer';
-export * from './core/layers/layerShouldOnlyBeAccessedBy';
-export { parseProject } from './core/project/parseProject';
-export * from './core/properties/locateProperties';
-export * from './core/properties/propertyCheckBeReadonly';
-export * from './core/slices/locateSlices';
-export * from './core/slices/sliceCheckBeFreeOfCycles';
-export * from './core/slices/sliceCheckHaveMaxDistanceFromMainSequence';
-export * from './core/types';
-export { setupMatchers } from './matchers';

package/src/matchers/index.ts

@@ -1,331 +0,0 @@
-import { expect } from 'vitest';
-import { classCheckExtendClass } from '../core/classes/classCheckExtendClass';
-import { classCheckHaveMaxCyclomaticComplexity } from '../core/classes/classCheckHaveMaxCyclomaticComplexity';
-import { classCheckHaveModifier } from '../core/classes/classCheckHaveModifier';
-import { classCheckHaveNameMatchingFileName } from '../core/classes/classCheckHaveNameMatchingFileName';
-import { classCheckImplementInterface } from '../core/classes/classCheckImplementInterface';
-import { classCheckMatchNamePattern } from '../core/classes/classCheckMatchNamePattern';
-import { classCheckResideInFolder } from '../core/classes/classCheckResideInFolder';
-import { checkDependOnFilesInFolder } from '../core/files/checkDependOnFilesInFolder';
-import { fileCheckBeFreeOfCycles } from '../core/files/fileCheckBeFreeOfCycles';
-import { fileCheckHaveMaxCyclomaticComplexity } from '../core/files/fileCheckHaveMaxCyclomaticComplexity';
-import { fileCheckHaveMaxExportedFunctions } from '../core/files/fileCheckHaveMaxExportedFunctions';
-import { fileCheckHaveMinMaintainabilityIndex } from '../core/files/fileCheckHaveMinMaintainabilityIndex';
-import { fileCheckMatchNamePattern } from '../core/files/fileCheckMatchNamePattern';
-import { functionCheckHaveExplicitReturnType } from '../core/functions/functionCheckHaveExplicitReturnType';
-import { functionCheckHaveMaxCyclomaticComplexity } from '../core/functions/functionCheckHaveMaxCyclomaticComplexity';
-import { functionCheckHaveMinMaintainabilityIndex } from '../core/functions/functionCheckHaveMinMaintainabilityIndex';
-import { functionCheckHaveModifier } from '../core/functions/functionCheckHaveModifier';
-import { functionCheckHaveNameMatchingFileName } from '../core/functions/functionCheckHaveNameMatchingFileName';
-import { functionCheckMatchNamePattern } from '../core/functions/functionCheckMatchNamePattern';
-import { checkLayeredArchitecture } from '../core/layers/checkLayeredArchitecture';
-
-import { propertyCheckBeReadonly } from '../core/properties/propertyCheckBeReadonly';
-
-import { sliceCheckBeFreeOfCycles } from '../core/slices/sliceCheckBeFreeOfCycles';
-import { sliceCheckHaveMaxDistanceFromMainSequence } from '../core/slices/sliceCheckHaveMaxDistanceFromMainSequence';
-import type { LocatorData, RuleResult } from '../core/types';
-
-export function setupMatchers() {
-  expect.extend({
-    // biome-ignore lint/suspicious/noExplicitAny: Matcher signature
-    toPass(received: any) {
-      let result: RuleResult;
-
-      if (received?.data && received.data.type === 'LayeredArchitecture') {
-        result = checkLayeredArchitecture(received.data);
-      } else {
-        result = received as RuleResult;
-      }
-
-      const { pass, message } = result;
-      return {
-        pass: this.isNot ? !pass : pass,
-        message: pass ? () => 'Expected rule not to pass' : () => message(),
-      };
-    },
-
-    toResideInFolder(received: LocatorData, folder: string) {
-      let result: RuleResult;
-      if (received.type === 'ClassLocator') {
-        result = classCheckResideInFolder(received, folder, this.isNot);
-      } else {
-        throw new Error(
-          `toResideInFolder matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveModifier(received: LocatorData, modifier: string) {
-      let result: RuleResult;
-      if (received.type === 'ClassLocator') {
-        result = classCheckHaveModifier(received, modifier, this.isNot);
-      } else if (received.type === 'FunctionLocator') {
-        result = functionCheckHaveModifier(received, modifier, this.isNot);
-      } else {
-        throw new Error(
-          `toHaveModifier matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toExtendClass(received: LocatorData, className: string) {
-      let result: RuleResult;
-      if (received.type === 'ClassLocator') {
-        result = classCheckExtendClass(received, className, this.isNot);
-      } else {
-        throw new Error(
-          `toExtendClass matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toImplementInterface(received: LocatorData, interfaceName: string) {
-      let result: RuleResult;
-      if (received.type === 'ClassLocator') {
-        result = classCheckImplementInterface(
-          received,
-          interfaceName,
-          this.isNot,
-        );
-      } else {
-        throw new Error(
-          `toImplementInterface matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveExplicitReturnType(received: LocatorData) {
-      let result: RuleResult;
-      if (received.type === 'FunctionLocator') {
-        result = functionCheckHaveExplicitReturnType(received, this.isNot);
-      } else {
-        throw new Error(
-          `toHaveExplicitReturnType matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toBeReadonly(received: LocatorData) {
-      let result: RuleResult;
-      if (received.type === 'PropertyLocator') {
-        result = propertyCheckBeReadonly(received, this.isNot);
-      } else {
-        throw new Error(
-          `toBeReadonly matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toDependOnFilesInFolder(received: LocatorData, folder: string) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = checkDependOnFilesInFolder(received, folder, this.isNot);
-      } else {
-        throw new Error(
-          `toDependOnFilesInFolder matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toBeFreeOfCycles(received: LocatorData) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = fileCheckBeFreeOfCycles(received, this.isNot);
-      } else if (received.type === 'SliceLocator') {
-        result = sliceCheckBeFreeOfCycles(received, this.isNot);
-      } else {
-        throw new Error(
-          `toBeFreeOfCycles matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toMatchNamePattern(received: LocatorData, pattern: string | RegExp) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = fileCheckMatchNamePattern(received, pattern, this.isNot);
-      } else if (received.type === 'ClassLocator') {
-        result = classCheckMatchNamePattern(received, pattern, this.isNot);
-      } else if (received.type === 'FunctionLocator') {
-        result = functionCheckMatchNamePattern(received, pattern, this.isNot);
-      } else {
-        throw new Error(
-          `toMatchNamePattern matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveMaxCyclomaticComplexity(received: LocatorData, max: number) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = fileCheckHaveMaxCyclomaticComplexity(
-          received,
-          max,
-          this.isNot,
-        );
-      } else if (received.type === 'ClassLocator') {
-        result = classCheckHaveMaxCyclomaticComplexity(
-          received,
-          max,
-          this.isNot,
-        );
-      } else if (received.type === 'FunctionLocator') {
-        result = functionCheckHaveMaxCyclomaticComplexity(
-          received,
-          max,
-          this.isNot,
-        );
-      } else {
-        throw new Error(
-          `toHaveMaxCyclomaticComplexity matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveMinMaintainabilityIndex(received: LocatorData, min: number) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = fileCheckHaveMinMaintainabilityIndex(
-          received,
-          min,
-          this.isNot,
-        );
-      } else if (received.type === 'FunctionLocator') {
-        result = functionCheckHaveMinMaintainabilityIndex(
-          received,
-          min,
-          this.isNot,
-        );
-      } else {
-        throw new Error(
-          `toHaveMinMaintainabilityIndex matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveMaxDistanceFromMainSequence(received: LocatorData, max: number) {
-      let result: RuleResult;
-      if (received.type === 'SliceLocator') {
-        result = sliceCheckHaveMaxDistanceFromMainSequence(
-          received,
-          max,
-          this.isNot,
-        );
-      } else {
-        throw new Error(
-          `toHaveMaxDistanceFromMainSequence matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveNameMatchingFileName(received: LocatorData) {
-      let result: RuleResult;
-      if (received.type === 'FunctionLocator') {
-        result = functionCheckHaveNameMatchingFileName(received, this.isNot);
-      } else if (received.type === 'ClassLocator') {
-        result = classCheckHaveNameMatchingFileName(received, this.isNot);
-      } else {
-        throw new Error(
-          `toHaveNameMatchingFileName matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-
-    toHaveMaxExportedFunctions(received: LocatorData, max: number) {
-      let result: RuleResult;
-      if (received.type === 'FileLocator') {
-        result = fileCheckHaveMaxExportedFunctions(received, max, this.isNot);
-      } else {
-        throw new Error(
-          `toHaveMaxExportedFunctions matcher does not support ${received.type}`,
-        );
-      }
-      return {
-        pass: this.isNot ? !result.pass : result.pass,
-        message: result.message,
-      };
-    },
-  });
-}
-
-declare module 'vitest' {
-  // biome-ignore lint/suspicious/noExplicitAny: Matcher signature
-  interface Assertion<T = any> {
-    toPass(): void;
-    toResideInFolder(folder: string): void;
-    toHaveModifier(
-      modifier:
-        | 'export'
-        | 'default'
-        | 'abstract'
-        | 'async'
-        | 'private'
-        | 'public',
-    ): void;
-    toExtendClass(className: string): void;
-    toImplementInterface(interfaceName: string): void;
-    toHaveExplicitReturnType(): void;
-    toBeReadonly(): void;
-    toDependOnFilesInFolder(folder: string): void;
-    toBeFreeOfCycles(): void;
-    toMatchNamePattern(pattern: string | RegExp): void;
-    toHaveMaxCyclomaticComplexity(max: number): void;
-    toHaveMinMaintainabilityIndex(min: number): void;
-    toHaveMaxDistanceFromMainSequence(max: number): void;
-    toHaveNameMatchingFileName(): void;
-    toHaveMaxExportedFunctions(max: number): void;
-  }
-}