Class GodSwitchTransformRule

Transform rule that converts large switch statements into maintainable Factory Pattern implementations.

Problem: Large switch statements (10+ cases) violate SOLID principles:

• Open/Closed Principle: Adding new cases requires modifying the switch
• Single Responsibility: Switch handles multiple concerns
• Difficult to test, maintain, and extend

Solution: Transforms God Switch into Factory Pattern using Strategy pattern:

1. Extract each case into a separate Strategy class
2. Generate a Factory class to create strategy instances
3. Replace switch statement with factory call

Before:

switch (type) {
  case 'A':
    return handleA();
  case 'B':
    return handleB();
  // ... 10+ more cases
}
Copy

After:

interface TypeStrategy {
  execute(): Result;
}

class AStrategy implements TypeStrategy {
  execute(): Result { return handleA(); }
}

class TypeFactory {
  createStrategy(type: string): TypeStrategy {
    const strategies = { A: AStrategy, B: BStrategy, ... };
    return new strategies[type]();
  }
}

const strategy = factory.createStrategy(type);
return strategy.execute();
Copy

Configuration:

{
  "transformationType": "god-switch-transform",
  "godSwitch": {
    "minCaseCount": 10,
    "generateInterfaces": true,
    "generateFactory": true,
    "strategyNamingPattern": "{CaseValue}Strategy",
    "factoryNamingPattern": "{SwitchExpression}Factory"
  }
}
Copy