refactoring-patterns

# Refactoring Patterns Skill

Systematic refactoring with safety checks and verification.

## When to Use

- Extracting methods, classes, or modules
- Renaming identifiers safely across codebase
- Moving code between files or modules
- Simplifying complex code
- Modernizing legacy patterns

## Reference Documents

- [Extract Patterns](./references/extract-patterns.md) - Extract method/class/module patterns
- [Rename Patterns](./references/rename-patterns.md) - Safe renaming across codebase
- [Move Patterns](./references/move-patterns.md) - Moving code between files/modules
- [Simplify Patterns](./references/simplify-patterns.md) - Reducing complexity patterns

## Core Principles

### 1. Never Refactor Without Tests

```markdown
BEFORE refactoring:
1. Ensure tests exist for code being changed
2. Run tests to confirm they pass
3. Note coverage percentage

DURING refactoring:
4. Run tests after each small change
5. Keep changes atomic and reversible

AFTER refactoring:
6. Run full test suite
7. Verify coverage didn't decrease
```

### 2. Small, Incremental Changes

```
BAD:  One massive PR that changes everything
GOOD: Series of small PRs, each working state

Commit 1: Add new class
Commit 2: Add tests for new class
Commit 3: Migrate first usage
Commit 4: Migrate remaining usages
Commit 5: Remove old code
```

### 3. Preserve Behavior

Refactoring changes structure, not behavior.

```python
# BEFORE
def calculate_total(items):
    total = 0
    for item in items:
        total += item.price * item.quantity
    return total

# AFTER (same behavior, different structure)
def calculate_total(items):
    return sum(item.price * item.quantity for item in items)
```

## Refactoring Workflow

### Step 1: Identify the Smell

| Code Smell | Refactoring |
|------------|-------------|
| Long method | Extract Method |
| Large class | Extract Class |
| Duplicated code | Extract Method/Class |
| Long parameter list | Introduce Parameter Object |
| Data clumps | Extract Class |
| Prim