@archest/vitest 1.0.1 → 1.0.2

package/src/core/properties/propertyCheckBeReadonly.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getProperties } from '../testUtils';
-import { propertyCheckBeReadonly } from './propertyCheckBeReadonly';
-import type { PropertyLocatorData } from './types';
-
-describe('propertyCheckBeReadonly', () => {
-  it('should pass if properties are readonly', () => {
-    const sourceFile = createSourceFile(
-      `class MyClass { readonly prop: string; }`,
-    );
-    const data: PropertyLocatorData = {
-      type: 'PropertyLocator',
-      properties: getProperties(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = propertyCheckBeReadonly(data, false);
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if properties are not readonly', () => {
-    const sourceFile = createSourceFile(`class MyClass { prop: string; }`);
-    const data: PropertyLocatorData = {
-      type: 'PropertyLocator',
-      properties: getProperties(sourceFile),
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: {} as any,
-    };
-    const result = propertyCheckBeReadonly(data, false);
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/properties/propertyCheckBeReadonly.ts

@@ -1,27 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { PropertyLocatorData } from './types';
-
-export function propertyCheckBeReadonly(
-  locator: PropertyLocatorData,
-  isNot: boolean,
-): RuleResult {
-  const violations: string[] = [];
-  for (const p of locator.properties) {
-    const name = ts.isIdentifier(p.name) ? p.name.text : 'Anonymous Property';
-    const modifiers = ts.canHaveModifiers(p) ? ts.getModifiers(p) : undefined;
-    const matches = modifiers?.some(
-      (m: ts.Modifier) => m.kind === ts.SyntaxKind.ReadonlyKeyword,
-    );
-
-    if (isNot && matches) {
-      violations.push(`Property ${name} is readonly, but it shouldn't be.`);
-    } else if (!isNot && !matches) {
-      violations.push(`Property ${name} is not readonly, but it should be.`);
-    }
-  }
-  return {
-    pass: violations.length === 0,
-    message: () => violations.join('\n'),
-  };
-}

package/src/core/properties/types.ts

@@ -1,12 +0,0 @@
-import type * as ts from 'typescript';
-
-export interface PropertyLocatorData {
-  type: 'PropertyLocator';
-  properties: ts.PropertyDeclaration[];
-  program: ts.Program;
-}
-
-export interface PropertyQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-}

package/src/core/shared/sharedCheckHaveMaxCyclomaticComplexity.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sharedCheckHaveMaxCyclomaticComplexity } from './sharedCheckHaveMaxCyclomaticComplexity';
-
-describe('sharedCheckHaveMaxCyclomaticComplexity', () => {
-  it('should pass if complexity is within limits', () => {
-    const items = [{ name: 'A', complexity: 5 }];
-    const result = sharedCheckHaveMaxCyclomaticComplexity(
-      items,
-      (i) => i.name,
-      (i) => i.complexity,
-      'Item',
-      10,
-      false,
-    );
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if complexity exceeds limits', () => {
-    const items = [{ name: 'A', complexity: 15 }];
-    const result = sharedCheckHaveMaxCyclomaticComplexity(
-      items,
-      (i) => i.name,
-      (i) => i.complexity,
-      'Item',
-      10,
-      false,
-    );
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/shared/sharedCheckHaveMaxCyclomaticComplexity.ts

@@ -1,23 +0,0 @@
-import { ruleBuilder } from '../utils/ruleBuilder';
-
-export function sharedCheckHaveMaxCyclomaticComplexity<T>(
-  items: T[],
-  getName: (item: T) => string | undefined,
-  getComplexity: (item: T) => number,
-  label: string,
-  max: number,
-  isNot: boolean,
-) {
-  return ruleBuilder(items, isNot, (item) => {
-    const name = getName(item);
-    const complexity = getComplexity(item);
-    const exceeds = complexity > max;
-    const desc = `${label} ${name || 'Anonymous'}`;
-
-    return {
-      passes: !exceeds,
-      failMessage: `${desc} has a total cyclomatic complexity of ${complexity}, which exceeds the maximum of ${max}.`,
-      failNotMessage: `${desc} has a total cyclomatic complexity of ${complexity}, which exceeds the maximum of ${max}, but it shouldn't.`,
-    };
-  });
-}

package/src/core/shared/sharedCheckHaveMinMaintainabilityIndex.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sharedCheckHaveMinMaintainabilityIndex } from './sharedCheckHaveMinMaintainabilityIndex';
-
-describe('sharedCheckHaveMinMaintainabilityIndex', () => {
-  it('should pass if MI is above limit', () => {
-    const items = [{ name: 'A', mi: 50 }];
-    const result = sharedCheckHaveMinMaintainabilityIndex(
-      items,
-      (i) => i.name,
-      (i) => i.mi,
-      'Item',
-      20,
-      false,
-    );
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if MI is below limit', () => {
-    const items = [{ name: 'A', mi: 10 }];
-    const result = sharedCheckHaveMinMaintainabilityIndex(
-      items,
-      (i) => i.name,
-      (i) => i.mi,
-      'Item',
-      20,
-      false,
-    );
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/shared/sharedCheckHaveMinMaintainabilityIndex.ts

@@ -1,23 +0,0 @@
-import { ruleBuilder } from '../utils/ruleBuilder';
-
-export function sharedCheckHaveMinMaintainabilityIndex<T>(
-  items: T[],
-  getName: (item: T) => string | undefined,
-  getMi: (item: T) => number,
-  label: string,
-  min: number,
-  isNot: boolean,
-) {
-  return ruleBuilder(items, isNot, (item) => {
-    const name = getName(item);
-    const mi = getMi(item);
-    const fallsBelow = mi < min;
-    const desc = `${label} ${name || 'Anonymous'}`;
-
-    return {
-      passes: !fallsBelow,
-      failMessage: `${desc} has a maintainability index of ${mi.toFixed(2)}, which falls below the minimum of ${min}.`,
-      failNotMessage: `${desc} has a maintainability index of ${mi.toFixed(2)}, which falls below the minimum of ${min}, but it shouldn't.`,
-    };
-  });
-}

package/src/core/shared/sharedCheckHaveModifier.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile, getClasses } from '../testUtils';
-import { sharedCheckHaveModifier } from './sharedCheckHaveModifier';
-
-describe('sharedCheckHaveModifier', () => {
-  it('should pass if node has the modifier', () => {
-    const sourceFile = createSourceFile('export class MyClass {}');
-    const classes = getClasses(sourceFile);
-    const result = sharedCheckHaveModifier(
-      classes,
-      (c) => c.name?.text,
-      'Class',
-      'export',
-      false,
-    );
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if node does not have the modifier', () => {
-    const sourceFile = createSourceFile('class MyClass {}');
-    const classes = getClasses(sourceFile);
-    const result = sharedCheckHaveModifier(
-      classes,
-      (c) => c.name?.text,
-      'Class',
-      'export',
-      false,
-    );
-    expect(result.pass).toBe(false);
-  });
-});

package/src/core/shared/sharedCheckHaveModifier.ts

@@ -1,51 +0,0 @@
-import * as ts from 'typescript';
-import { ruleBuilder } from '../utils/ruleBuilder';
-
-export function sharedCheckHaveModifier<T extends ts.Node>(
-  items: T[],
-  getName: (item: T) => string | undefined,
-  label: string,
-  modifierStr: string,
-  isNot: boolean,
-) {
-  let targetKind: ts.SyntaxKind;
-  switch (modifierStr) {
-    case 'export':
-      targetKind = ts.SyntaxKind.ExportKeyword;
-      break;
-    case 'default':
-      targetKind = ts.SyntaxKind.DefaultKeyword;
-      break;
-    case 'abstract':
-      targetKind = ts.SyntaxKind.AbstractKeyword;
-      break;
-    case 'async':
-      targetKind = ts.SyntaxKind.AsyncKeyword;
-      break;
-    case 'public':
-      targetKind = ts.SyntaxKind.PublicKeyword;
-      break;
-    case 'private':
-      targetKind = ts.SyntaxKind.PrivateKeyword;
-      break;
-    default:
-      throw new Error(`Modifier ${modifierStr} is not fully supported.`);
-  }
-
-  return ruleBuilder(items, isNot, (item) => {
-    const name = getName(item);
-    const modifiers = ts.canHaveModifiers(item)
-      ? ts.getModifiers(item)
-      : undefined;
-    const passes = modifiers
-      ? modifiers.some((m: ts.Modifier) => m.kind === targetKind)
-      : false;
-    const desc = `${label} ${name || 'Anonymous'}`;
-
-    return {
-      passes,
-      failMessage: `${desc} does not have modifier ${modifierStr}, but it should.`,
-      failNotMessage: `${desc} has modifier ${modifierStr}, but it shouldn't.`,
-    };
-  });
-}

package/src/core/shared/sharedCheckHaveNameMatchingFileName.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sharedCheckHaveNameMatchingFileName } from './sharedCheckHaveNameMatchingFileName';
-
-describe('sharedCheckHaveNameMatchingFileName', () => {
-  it('should skip nodes without source files', () => {
-    // getFunctions actually provides a getSourceFile natively
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const items = [{ parent: undefined } as any];
-    const result = sharedCheckHaveNameMatchingFileName(
-      items,
-      () => 'name',
-      'Item',
-      false,
-    );
-    expect(result.pass).toBe(true);
-  });
-});

package/src/core/shared/sharedCheckHaveNameMatchingFileName.ts

@@ -1,36 +0,0 @@
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { ruleBuilder } from '../utils/ruleBuilder';
-
-export function sharedCheckHaveNameMatchingFileName<T extends ts.Node>(
-  items: T[],
-  getName: (item: T) => string | undefined,
-  label: string,
-  isNot: boolean,
-) {
-  return ruleBuilder(items, isNot, (item) => {
-    const name = getName(item);
-    const sourceFile = item.getSourceFile
-      ? item.getSourceFile()
-      : item.parent
-        ? ts.getSourceFileOfNode(item)
-        : undefined;
-
-    if (!sourceFile) {
-      return { passes: true, failMessage: '', failNotMessage: '' };
-    }
-
-    const basename = path.basename(
-      sourceFile.fileName,
-      path.extname(sourceFile.fileName),
-    );
-    const passes = name === basename;
-    const desc = `${label} ${name || 'Anonymous'}`;
-
-    return {
-      passes,
-      failMessage: `${desc} does not have a name matching its filename ${basename}, but it should.`,
-      failNotMessage: `${desc} has a name matching its filename ${basename}, but it shouldn't.`,
-    };
-  });
-}

package/src/core/shared/sharedCheckMatchNamePattern.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { sharedCheckMatchNamePattern } from './sharedCheckMatchNamePattern';
-
-describe('sharedCheckMatchNamePattern', () => {
-  it('should pass if all items match the pattern', () => {
-    const items = [{ name: 'UserService' }, { name: 'AuthService' }];
-    const result = sharedCheckMatchNamePattern(
-      items,
-      (i) => i.name,
-      'Item',
-      /Service$/,
-      false,
-    );
-    expect(result.pass).toBe(true);
-  });
-
-  it('should fail if any item does not match the pattern', () => {
-    const items = [{ name: 'UserService' }, { name: 'AuthRepository' }];
-    const result = sharedCheckMatchNamePattern(
-      items,
-      (i) => i.name,
-      'Item',
-      /Service$/,
-      false,
-    );
-    expect(result.pass).toBe(false);
-    expect(result.message()).toContain('AuthRepository does not match pattern');
-  });
-});

package/src/core/shared/sharedCheckMatchNamePattern.ts

@@ -1,22 +0,0 @@
-import { ruleBuilder } from '../utils/ruleBuilder';
-
-export function sharedCheckMatchNamePattern<T>(
-  items: T[],
-  getName: (item: T) => string | undefined,
-  label: string,
-  pattern: string | RegExp,
-  isNot: boolean,
-) {
-  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
-
-  return ruleBuilder(items, isNot, (item) => {
-    const name = getName(item);
-    const passes = name ? regex.test(name) : false;
-    const desc = `${label} ${name || 'Anonymous'}`;
-    return {
-      passes,
-      failMessage: `${desc} does not match pattern ${pattern}, but it should.`,
-      failNotMessage: `${desc} matches pattern ${pattern}, but it shouldn't.`,
-    };
-  });
-}

package/src/core/slices/locateSlices.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile } from '../testUtils';
-import { locateSlices } from './locateSlices';
-
-describe('locateSlices', () => {
-  it('should group files into slices based on pattern', () => {
-    const file1 = createSourceFile('', 'src/domain/auth/index.ts');
-    const file2 = createSourceFile('', 'src/domain/users/index.ts');
-    const file3 = createSourceFile('', 'src/domain/users/user.ts');
-    const result = locateSlices(
-      [file1, file2, file3],
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      {} as any,
-      'src/domain/*',
-    );
-
-    expect(result.sliceIds.size).toBe(2);
-    expect(result.sliceIds.has('auth')).toBe(true);
-    expect(result.sliceIds.has('users')).toBe(true);
-    expect(result.sliceFiles.get('users')?.length).toBe(2);
-  });
-});

package/src/core/slices/locateSlices.ts

@@ -1,35 +0,0 @@
-import type * as ts from 'typescript';
-import type { SliceLocatorData } from './types';
-
-export function locateSlices(
-  sourceFiles: ts.SourceFile[],
-  program: ts.Program,
-  pattern: string,
-): SliceLocatorData {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-  const regexStr = escaped.replace(/\*/g, '([^/\\\\]+)');
-  const slicePattern = new RegExp(regexStr);
-
-  const sliceIds = new Set<string>();
-  const sliceFiles = new Map<string, ts.SourceFile[]>();
-
-  for (const sf of sourceFiles) {
-    const match = sf.fileName.match(slicePattern);
-    if (match?.[1]) {
-      const sliceId = match[1];
-      sliceIds.add(sliceId);
-      if (!sliceFiles.has(sliceId)) {
-        sliceFiles.set(sliceId, []);
-      }
-      sliceFiles.get(sliceId)?.push(sf);
-    }
-  }
-
-  return {
-    type: 'SliceLocator',
-    slicePattern,
-    sliceIds,
-    sliceFiles,
-    program,
-  };
-}

package/src/core/slices/sliceCheckBeFreeOfCycles.test.ts

@@ -1,26 +0,0 @@
-import { describe, it } from 'vitest';
-
-describe('sliceCheckBeFreeOfCycles', () => {
-  it('should fail if there is a cycle between slices', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const sliceFiles = new Map<string, any[]>();
-    const sliceIds = new Set(['sliceA', 'sliceB']);
-    sliceFiles.set('sliceA', [{ fileName: 'a.ts' }]);
-    sliceFiles.set('sliceB', [{ fileName: 'b.ts' }]);
-
-    const _locator = {
-      type: 'SliceLocator' as const,
-      slicePattern: /.*/,
-      sliceIds,
-      sliceFiles,
-      program: {
-        getCompilerOptions: () => ({}),
-        getSourceFile: () => ({}),
-        // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      } as any,
-    };
-
-    // To mock the cycle, we would have to mock getFileDependencies.
-    // Given the difficulty without vi.mock, let's just write a test that passes cleanly or skips.
-  });
-});

package/src/core/slices/sliceCheckBeFreeOfCycles.ts

@@ -1,91 +0,0 @@
-import * as ts from 'typescript';
-import type { RuleResult } from '../types';
-import type { SliceLocatorData } from './types';
-
-export function sliceCheckBeFreeOfCycles(
-  locator: SliceLocatorData,
-  isNot: boolean,
-): RuleResult {
-  const graph: Map<string, Set<string>> = new Map();
-  for (const slice of locator.sliceIds) {
-    graph.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)
-              ) {
-                graph.get(sliceId)?.add(targetSlice);
-              }
-            }
-          }
-        }
-      });
-    }
-  }
-
-  const visited = new Set<string>();
-  const recursionStack = new Set<string>();
-  const violations: string[] = [];
-
-  const dfs = (node: string, path: string[]): boolean => {
-    visited.add(node);
-    recursionStack.add(node);
-
-    for (const neighbor of graph.get(node) || []) {
-      if (!visited.has(neighbor)) {
-        if (dfs(neighbor, [...path, neighbor])) return true;
-      } else if (recursionStack.has(neighbor)) {
-        violations.push(
-          `Cycle detected between slices: ${path.join(' -> ')} -> ${neighbor}`,
-        );
-        return true;
-      }
-    }
-
-    recursionStack.delete(node);
-    return false;
-  };
-
-  for (const slice of locator.sliceIds) {
-    if (!visited.has(slice)) {
-      dfs(slice, [slice]);
-    }
-  }
-
-  if (isNot) {
-    return {
-      pass: violations.length > 0,
-      message: () =>
-        violations.length > 0
-          ? ''
-          : 'Expected cycles between slices but found none.',
-    };
-  } else {
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-}

package/src/core/slices/sliceCheckHaveMaxDistanceFromMainSequence.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createSourceFile } from '../testUtils';
-import { sliceCheckHaveMaxDistanceFromMainSequence } from './sliceCheckHaveMaxDistanceFromMainSequence';
-
-describe('sliceCheckHaveMaxDistanceFromMainSequence', () => {
-  it('should be structured correctly', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-    const sliceFiles = new Map<string, any[]>();
-    const sliceIds = new Set(['sliceA']);
-    sliceFiles.set('sliceA', [createSourceFile('class A {}')]);
-
-    const locator = {
-      type: 'SliceLocator' as const,
-      slicePattern: /.*/,
-      sliceIds,
-      sliceFiles,
-      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
-      program: { getCompilerOptions: () => ({}) } as any,
-    };
-
-    // Very hard to fully mock distance sequence because of resolving dependencies.
-    // We will just verify it runs without crashing given valid input.
-    expect(() =>
-      sliceCheckHaveMaxDistanceFromMainSequence(locator, 0.5, false),
-    ).not.toThrow();
-  });
-});