Refactor Method to Reduce Cognitive Complexity
Objective
Refactor the method ${input:methodName}, to reduce its cognitive complexity to ${input:complexityThreshold} or below, by extracting logic into focused helper methods.
Instructions
- Analyze the current method to identify sources of cognitive complexity:
- Nested conditional statements - Multiple if-else or switch chains - Repeated code blocks - Multiple loops with conditions - Complex boolean expressions
- Identify extraction opportunities:
- Validation logic that can be extracted into a separate method - Type-specific or case-specific processing that repeats - Complex transformations or calculations - Common patterns that appear multiple times
- Extract focused helper methods:
- Each helper should have a single, clear responsibility - Extract validation into separate Validate* methods - Extract type-specific logic into handler methods - Create utility methods for common operations - Use appropriate access levels (static, private, async)
- Simplify the main method:
- Reduce nesting depth - Replace massive if-else chains with smaller orchestrated calls - Use switch statements where appropriate for cleaner dispatch - Ensure the main method reads as a high-level flow
- Preserve functionality:
- Maintain the same input/output behavior - Keep all validation and error handling - Preserve exception types and error messages - Ensure all parameters are properly passed to helpers
- Best practices:
- Make helper methods static when they don't need instance state - Use null checks and guard clauses early - Avoid creating unnecessary local variables - Consider using tuples for multiple return values - Group related helper methods together
Implementation Approach
- Extract helper methods before refactoring the main flow
- Test incrementally to ensure no regressions
- Use meaningful names that describe the extracted responsibility
- Keep extracted methods close to where they're used
- Consider making repeated code patterns into generic methods
Result
The refactored method should:
- Have cognitive complexity reduced to the target threshold of
${input:complexityThreshold}or below - Be more readable and maintainable
- Have clear separation of concerns
- Be easier to test and debug
- Retain all original functionality
Testing and Validation
CRITICAL: After completing the refactoring, you MUST:
- Run all existing tests related to the refactored method and its surrounding functionality
- MANDATORY: Explicitly verify test results show "failed=0"
- NEVER assume tests passed - always examine the actual test output - Search for the summary line containing pass/fail counts (e.g., "passed=X failed=Y") - If the summary shows any number other than "failed=0", tests have FAILED - If test output is in a file, read the entire file to locate and verify the failure count - Running tests is NOT the same as verifying tests passed - Do not proceed until you have explicitly confirmed zero failures
- If any tests fail (failed > 0):
- State clearly how many tests failed - Analyze each failure to understand what functionality was broken - Common causes: null handling, empty collection checks, condition logic errors - Identify the root cause in the refactored code - Correct the refactored code to restore the original behavior - Re-run tests and verify "failed=0" in the output - Repeat until all tests pass (failed=0)
- Verify compilation - Ensure there are no compilation errors
- Check cognitive complexity - Confirm the metric is at or below the target threshold of
${input:complexityThreshold}
Confirmation Checklist
- Code compiles without errors
- Test results explicitly state "failed=0" (verified by reading the output)
- All test failures analyzed and corrected (if any occurred)
- Cognitive complexity is at or below the target threshold of
${input:complexityThreshold} - All original functionality is preserved
- Code follows project conventions and standards