@archest/vitest 1.0.1 → 1.0.3

package/src/core/classes/classCheckHaveMaxCyclomaticComplexity.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { classCheckHaveMaxCyclomaticComplexity } from './classCheckHaveMaxCyclomaticComplexity';
-
-describe('classCheckHaveMaxCyclomaticComplexity', () => {
-  it('should exist and be callable', () => {
-    expect(typeof classCheckHaveMaxCyclomaticComplexity).toBe('function');
-  });
-});

package/src/core/classes/classCheckHaveMaxCyclomaticComplexity.ts

@@ -1,35 +0,0 @@
-import * as ts from 'typescript';
-import { calculateCyclomaticComplexity } from '../metrics/calculateCyclomaticComplexity';
-import { sharedCheckHaveMaxCyclomaticComplexity } from '../shared/sharedCheckHaveMaxCyclomaticComplexity';
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckHaveMaxCyclomaticComplexity(
-  locator: ClassLocatorData,
-  max: number,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveMaxCyclomaticComplexity(
-    locator.classes,
-    (c) => c.name?.text,
-    (c) => {
-      let complexity = 0;
-      const visit = (node: ts.Node) => {
-        if (
-          ts.isMethodDeclaration(node) ||
-          ts.isConstructorDeclaration(node) ||
-          ts.isGetAccessor(node) ||
-          ts.isSetAccessor(node)
-        ) {
-          complexity += calculateCyclomaticComplexity(node);
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(c);
-      return complexity;
-    },
-    'Class',
-    max,
-    isNot,
-  );
-}

package/src/core/classes/classCheckHaveModifier.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getClasses } from '../testUtils';
-import { classCheckHaveModifier } from './classCheckHaveModifier';
-import type { ClassLocatorData } from './types';
-
-describe('classCheckHaveModifier', () => {
-  it('should pass if class has modifier', () => {
-    const sourceFile = createSourceFile(`export class Test {}`);
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckHaveModifier(data, 'export', false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if class does not have modifier', () => {
-    const sourceFile = createSourceFile(`class Test {}`);
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckHaveModifier(data, 'export', false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/classes/classCheckHaveModifier.ts

@@ -1,17 +0,0 @@
-import { sharedCheckHaveModifier } from '../shared/sharedCheckHaveModifier';
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckHaveModifier(
-  locator: ClassLocatorData,
-  modifierStr: string,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveModifier(
-    locator.classes,
-    (c) => c.name?.text,
-    'Class',
-    modifierStr,
-    isNot,
-  );
-}

package/src/core/classes/classCheckHaveNameMatchingFileName.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getClasses } from '../testUtils';
-import { classCheckHaveNameMatchingFileName } from './classCheckHaveNameMatchingFileName';
-import type { ClassLocatorData } from './types';
-
-describe('classCheckHaveNameMatchingFileName', () => {
-  it('should pass if class matches filename', () => {
-    const sourceFile = createSourceFile(`class Test {}`, 'Test.ts');
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckHaveNameMatchingFileName(data, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if class does not match filename', () => {
-    const sourceFile = createSourceFile(`class Test {}`, 'Other.ts');
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckHaveNameMatchingFileName(data, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/classes/classCheckHaveNameMatchingFileName.ts

@@ -1,15 +0,0 @@
-import { sharedCheckHaveNameMatchingFileName } from '../shared/sharedCheckHaveNameMatchingFileName';
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckHaveNameMatchingFileName(
-  locator: ClassLocatorData,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveNameMatchingFileName(
-    locator.classes,
-    (c) => c.name?.text,
-    'Class',
-    isNot,
-  );
-}

package/src/core/classes/classCheckImplementInterface.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getClasses } from '../testUtils';
-import { classCheckImplementInterface } from './classCheckImplementInterface';
-import type { ClassLocatorData } from './types';
-
-describe('classCheckImplementInterface', () => {
-  it('should pass if class implements interface', () => {
-    const sourceFile = createSourceFile(`class Test implements IBase {}`);
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckImplementInterface(data, 'IBase', false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if class does not implement interface', () => {
-    const sourceFile = createSourceFile(`class Test {}`);
-    const data: ClassLocatorData = {
-      type: 'ClassLocator',
-      classes: getClasses(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = classCheckImplementInterface(data, 'IBase', false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/classes/classCheckImplementInterface.ts

@@ -1,43 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckImplementInterface(
-  locator: ClassLocatorData,
-  interfaceName: string,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  for (const c of locator.classes) {
-    const name = c.name?.text || 'Anonymous';
-    let matches = false;
-    if (c.heritageClauses) {
-      for (const clause of c.heritageClauses) {
-        if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-          for (const type of clause.types) {
-            if (
-              ts.isIdentifier(type.expression) &&
-              type.expression.text === interfaceName
-            ) {
-              matches = true;
-              break;
-            }
-          }
-        }
-      }
-    }
-    if (isNot && matches) {
-      violations.push(
-        `Class ${name} implements ${interfaceName}, but it shouldn't.`,
-      );
-    } else if (!isNot && !matches) {
-      violations.push(
-        `Class ${name} does not implement ${interfaceName}, but it should.`,
-      );
-    }
-  }
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/classes/classCheckMatchNamePattern.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { classCheckMatchNamePattern } from './classCheckMatchNamePattern';
-
-describe('classCheckMatchNamePattern', () => {
-  it('should exist and be callable', () => {
-    expect(typeof classCheckMatchNamePattern).toBe('function');
-  });
-});

package/src/core/classes/classCheckMatchNamePattern.ts

@@ -1,17 +0,0 @@
-import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckMatchNamePattern(
-  locator: ClassLocatorData,
-  pattern: string | RegExp,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckMatchNamePattern(
-    locator.classes,
-    (c) => c.name?.text,
-    'Class',
-    pattern,
-    isNot,
-  );
-}

package/src/core/classes/classCheckResideInFolder.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { classCheckResideInFolder } from './classCheckResideInFolder';
-
-describe('classCheckResideInFolder', () => {
-  it('should exist and be callable', () => {
-    expect(typeof classCheckResideInFolder).toBe('function');
-  });
-});

package/src/core/classes/classCheckResideInFolder.ts

@@ -1,31 +0,0 @@
-import type { RuleResult } from '../types';
-import type { ClassLocatorData } from './types';
-
-export function classCheckResideInFolder(
-  locator: ClassLocatorData,
-  targetFolder: string,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  for (const c of locator.classes) {
-    const className = c.name?.text || 'Anonymous Class';
-    const sourceFile = c.getSourceFile();
-    const inTargetFolder =
-      sourceFile.fileName.includes(`/${targetFolder}/`) ||
-      sourceFile.fileName.includes(`\\${targetFolder}\\`);
-
-    if (isNot && inTargetFolder) {
-      violations.push(
-        `Class ${className} resides in ${targetFolder}, but it shouldn't.`,
-      );
-    } else if (!isNot && !inTargetFolder) {
-      violations.push(
-        `Class ${className} does not reside in ${targetFolder}, but it should.`,
-      );
-    }
-  }
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/classes/locateClasses.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getClasses } from '../testUtils';
-import { locateClasses } from './locateClasses';
-
-describe('locateClasses', () => {
-  it('should filter classes by inFolder', () => {
-    const file1 = createSourceFile('class A {}', 'src/domain/A.ts');
-    const classes = getClasses(file1);
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const result = locateClasses(classes, {} as any, { inFolder: 'infra' });
-    expect(result.classes.length).toBe(0);
-  });
-});

package/src/core/classes/locateClasses.ts

@@ -1,127 +0,0 @@
-import * as ts from 'typescript';
-import type { ClassLocatorData, ClassQueryOptions } from './types';
-
-export function locateClasses(
-  classes: ts.ClassDeclaration[],
-  program: ts.Program,
-  options?: ClassQueryOptions,
-): ClassLocatorData {
-  let filtered = classes;
-
-  if (options?.inFolder) {
-    filtered = filtered.filter((c) => {
-      const sourceFile = c.getSourceFile
-        ? c.getSourceFile()
-        : c.parent
-          ? ts.getSourceFileOfNode(c)
-          : undefined;
-      if (!sourceFile) return false;
-      return (
-        sourceFile.fileName.includes(`/${options.inFolder}/`) ||
-        sourceFile.fileName.includes(`\\${options.inFolder}\\`)
-      );
-    });
-  }
-  if (options?.matchNamePattern) {
-    const regex =
-      typeof options.matchNamePattern === 'string'
-        ? new RegExp(options.matchNamePattern)
-        : options.matchNamePattern;
-    filtered = filtered.filter((c) => {
-      const name = c.name?.text;
-      return name && regex.test(name);
-    });
-  }
-  if (options?.withDecorator) {
-    filtered = filtered.filter((c) => {
-      const decorators = ts.canHaveDecorators(c)
-        ? ts.getDecorators(c)
-        : undefined;
-      let hasDecorator = false;
-      if (decorators) {
-        for (const dec of decorators) {
-          const exp = dec.expression;
-          let name = '';
-          if (ts.isIdentifier(exp)) {
-            name = exp.text;
-          } else if (
-            ts.isCallExpression(exp) &&
-            ts.isIdentifier(exp.expression)
-          ) {
-            name = exp.expression.text;
-          }
-          if (name === options.withDecorator) {
-            hasDecorator = true;
-          }
-        }
-      }
-      return hasDecorator;
-    });
-  }
-  if (options?.extending) {
-    filtered = filtered.filter((c) => {
-      if (c.heritageClauses) {
-        for (const clause of c.heritageClauses) {
-          if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-            for (const type of clause.types) {
-              if (
-                ts.isIdentifier(type.expression) &&
-                type.expression.text === options.extending
-              ) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-      return false;
-    });
-  }
-  if (options?.implementing) {
-    filtered = filtered.filter((c) => {
-      if (c.heritageClauses) {
-        for (const clause of c.heritageClauses) {
-          if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-            for (const type of clause.types) {
-              if (
-                ts.isIdentifier(type.expression) &&
-                type.expression.text === options.implementing
-              ) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-      return false;
-    });
-  }
-  if (options?.havingModifier) {
-    let targetKind: ts.SyntaxKind;
-    switch (options.havingModifier) {
-      case 'export':
-        targetKind = ts.SyntaxKind.ExportKeyword;
-        break;
-      case 'default':
-        targetKind = ts.SyntaxKind.DefaultKeyword;
-        break;
-      case 'abstract':
-        targetKind = ts.SyntaxKind.AbstractKeyword;
-        break;
-      default:
-        throw new Error(
-          `Modifier ${options.havingModifier} is not fully supported.`,
-        );
-    }
-    filtered = filtered.filter((c) => {
-      const modifiers = ts.canHaveModifiers(c) ? ts.getModifiers(c) : undefined;
-      return modifiers?.some((m: ts.Modifier) => m.kind === targetKind);
-    });
-  }
-
-  return {
-    type: 'ClassLocator',
-    classes: filtered,
-    program,
-  };
-}

package/src/core/classes/types.ts

@@ -1,16 +0,0 @@
-import type * as ts from 'typescript';
-
-export interface ClassLocatorData {
-  type: 'ClassLocator';
-  classes: ts.ClassDeclaration[];
-  program: ts.Program;
-}
-
-export interface ClassQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-  withDecorator?: string;
-  extending?: string;
-  implementing?: string;
-  havingModifier?: string;
-}

package/src/core/files/checkDependOnFilesInFolder.test.ts

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-describe('checkDependOnFilesInFolder', () => {
-  it('is thoroughly integration tested in architecture.test.ts', () => {
-    expect(true).toBe(true);
-  });
-});

package/src/core/files/checkDependOnFilesInFolder.ts

@@ -1,36 +0,0 @@
-import type { RuleResult } from '../types';
-import { getFileDependencies } from './getFileDependencies';
-import type { FileLocatorData } from './types';
-
-export function checkDependOnFilesInFolder(
-  locator: FileLocatorData,
-  targetFolder: string,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-
-  for (const file of locator.files) {
-    const dependencies = getFileDependencies(file, locator.program);
-
-    const dependsOnTarget = dependencies.some(
-      (depPath) =>
-        depPath.includes(`/${targetFolder}/`) ||
-        depPath.includes(`\\${targetFolder}\\`),
-    );
-
-    if (isNot && dependsOnTarget) {
-      violations.push(
-        `File ${file.fileName} depends on files in ${targetFolder}, but it shouldn't.`,
-      );
-    } else if (!isNot && !dependsOnTarget) {
-      violations.push(
-        `File ${file.fileName} does not depend on files in ${targetFolder}, but it should.`,
-      );
-    }
-  }
-
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/files/fileCheckBeFreeOfCycles.test.ts

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-describe('fileCheckBeFreeOfCycles', () => {
-  it('is thoroughly integration tested in architecture.test.ts', () => {
-    expect(true).toBe(true);
-  });
-});

package/src/core/files/fileCheckBeFreeOfCycles.ts

@@ -1,72 +0,0 @@
-import type { RuleResult } from '../types';
-import { getFileDependencies } from './getFileDependencies';
-import type { FileLocatorData } from './types';
-
-export function fileCheckBeFreeOfCycles(
-  locator: FileLocatorData,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  const targetedFilePaths = new Set<string>(
-    locator.files.map((f) => f.fileName),
-  );
-  const graph = new Map<string, string[]>();
-
-  for (const file of locator.files) {
-    const filePath = file.fileName;
-    const dependencies = getFileDependencies(file, locator.program).filter(
-      (p) => targetedFilePaths.has(p),
-    );
-
-    graph.set(filePath, dependencies);
-  }
-
-  const visited = new Set<string>();
-  const recStack = new Set<string>();
-  const cycles: string[][] = [];
-
-  const isCyclicUtil = (node: string, path: string[]) => {
-    if (recStack.has(node)) {
-      const cycleStartIndex = path.indexOf(node);
-      const cycleStr = [...path.slice(cycleStartIndex), node].join('->');
-      if (!cycles.some((c) => c.join('->') === cycleStr)) {
-        cycles.push([...path.slice(cycleStartIndex), node]);
-      }
-      return true;
-    }
-
-    if (visited.has(node)) return false;
-
-    visited.add(node);
-    recStack.add(node);
-    path.push(node);
-
-    const neighbors = graph.get(node) || [];
-    for (const neighbor of neighbors) {
-      isCyclicUtil(neighbor, path);
-    }
-
-    recStack.delete(node);
-    path.pop();
-    return false;
-  };
-
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      isCyclicUtil(node, []);
-    }
-  }
-
-  if (isNot && cycles.length === 0) {
-    violations.push('Expected cyclic dependencies, but found none.');
-  } else if (!isNot && cycles.length > 0) {
-    for (const cycle of cycles) {
-      violations.push(`Cycle detected: ${cycle.join(' -> ')}`);
-    }
-  }
-
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/files/fileCheckHaveMaxCyclomaticComplexity.test.ts

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { fileCheckHaveMaxCyclomaticComplexity } from './fileCheckHaveMaxCyclomaticComplexity';
-
-describe('fileCheckHaveMaxCyclomaticComplexity', () => {
-  it('should exist and be callable', () => {
-    expect(typeof fileCheckHaveMaxCyclomaticComplexity).toBe('function');
-  });
-});

package/src/core/files/fileCheckHaveMaxCyclomaticComplexity.ts

@@ -1,35 +0,0 @@
-import * as ts from 'typescript';
-import { calculateCyclomaticComplexity } from '../metrics/calculateCyclomaticComplexity';
-import { sharedCheckHaveMaxCyclomaticComplexity } from '../shared/sharedCheckHaveMaxCyclomaticComplexity';
-import type { RuleResult } from '../types';
-import type { FileLocatorData } from './types';
-
-export function fileCheckHaveMaxCyclomaticComplexity(
-  locator: FileLocatorData,
-  max: number,
-  isNot: boolean,
-): RuleResult {
-  return sharedCheckHaveMaxCyclomaticComplexity(
-    locator.files,
-    (f) => f.fileName,
-    (file) => {
-      let complexity = 0;
-      const visit = (node: ts.Node) => {
-        if (
-          ts.isFunctionDeclaration(node) ||
-          ts.isMethodDeclaration(node) ||
-          ts.isArrowFunction(node) ||
-          ts.isFunctionExpression(node)
-        ) {
-          complexity += calculateCyclomaticComplexity(node);
-        }
-        ts.forEachChild(node, visit);
-      };
-      visit(file);
-      return complexity;
-    },
-    'File',
-    max,
-    isNot,
-  );
-}

package/src/core/files/fileCheckHaveMaxExportedFunctions.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile } from '../testUtils';
-import { fileCheckHaveMaxExportedFunctions } from './fileCheckHaveMaxExportedFunctions';
-import type { FileLocatorData } from './types';
-
-describe('fileCheckHaveMaxExportedFunctions', () => {
-  it('should pass if under max exports', () => {
-    const sourceFile = createSourceFile(`export function a() {}`);
-    const data: FileLocatorData = {
-      type: 'FileLocator',
-      files: [sourceFile],
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = fileCheckHaveMaxExportedFunctions(data, 1, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if over max exports', () => {
-    const sourceFile = createSourceFile(
-      `export function a() {} export function b() {}`,
-    );
-    const data: FileLocatorData = {
-      type: 'FileLocator',
-      files: [sourceFile],
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = fileCheckHaveMaxExportedFunctions(data, 1, false);
-    expect(result.pass).toBe(false);
-  });
-});