Refactoring

What this skill does

# Refactoring

Comprehensive refactoring skill for safe code restructuring, migrations, and modernization.

## Core Capabilities

### Safe Renaming

Rename identifiers across the codebase:

**Rename workflow:**

1. **Find all references**: Search for all usages
2. **Identify scope**: Module-local, package-wide, or public API
3. **Check dependencies**: External code that might break
4. **Perform rename**: Update all occurrences
5. **Verify**: Run tests, check imports

**Search patterns:**

```bash
# Find all references to a function
grep -rn "function_name" --include="*.py"

# Find class usages
grep -rn "ClassName" --include="*.py"

# Find imports
grep -rn "from .* import.*function_name" --include="*.py"
```

**Renaming considerations:**

- Update docstrings mentioning the old name
- Update comments referencing the name
- Update configuration files
- Update tests
- Consider deprecation period for public APIs

### Method Extraction

Extract code into separate functions:

**When to extract:**

- Code block is too long (> 20 lines)
- Code is duplicated elsewhere
- Code has a clear single purpose
- Code can be tested independently

**Extraction process:**

1. Identify the code block to extract
2. Determine inputs (parameters)
3. Determine outputs (return values)
4. Create new function with clear name
5. Replace original code with function call
6. Add tests for new function

**Before:**

```python
def process_order(order):
    # Validate order (candidate for extraction)
    if not order.items:
        raise ValueError("Empty order")
    if order.total < 0:
        raise ValueError("Invalid total")
    for item in order.items:
        if item.quantity <= 0:
            raise ValueError("Invalid quantity")

    # Process payment
    payment_result = gateway.charge(order.total)
    return payment_result
```

**After:**

```python
def validate_order(order: Order) -> None:
    """Validate order has valid items and total."""
    if not order.items:
        raise ValueError("Empty order")
    if order.total < 0:
        raise ValueError("Invalid total")
    for item in order.items:
        if item.quantity <= 0:
            raise ValueError("Invalid quantity")

def process_order(order: Order) -> PaymentResult:
    validate_order(order)
    return gateway.charge(order.total)
```

### Class Splitting

Split large classes into focused components:

**When to split:**

- Class has multiple responsibilities
- Class has > 500 lines
- Groups of methods work on different data
- Testing requires excessive mocking

**Splitting strategies:**

**Extract class:**

```python
# Before: God class
class OrderManager:
    def create_order(self): ...
    def validate_order(self): ...
    def calculate_tax(self): ...
    def calculate_shipping(self): ...
    def send_confirmation_email(self): ...
    def send_shipping_notification(self): ...

# After: Focused classes
class OrderService:
    def create_order(self): ...
    def validate_order(self): ...

class PricingService:
    def calculate_tax(self): ...
    def calculate_shipping(self): ...

class NotificationService:
    def send_confirmation_email(self): ...
    def send_shipping_notification(self): ...
```

### Complexity Reduction

Reduce cyclomatic complexity:

**Replace conditionals with polymorphism:**

```python
# Before: Complex switch
def calculate_price(product_type, base_price):
    if product_type == "physical":
        return base_price + shipping_cost
    elif product_type == "digital":
        return base_price
    elif product_type == "subscription":
        return base_price * 12 * 0.9
    else:
        raise ValueError("Unknown type")

# After: Polymorphism
class Product(ABC):
    @abstractmethod
    def calculate_price(self, base_price): ...

class PhysicalProduct(Product):
    def calculate_price(self, base_price):
        return base_price + self.shipping_cost

class DigitalProduct(Product):
    def calculate_price(self, base_price):
        return base_price

class Subscription(Product):
    def calculate_price(self, base_price):
        return base_price * 12 * 0.9
```

**Extract guard clauses:**

```python
# Before: Nested conditionals
def process(data):
    if data:
        if data.is_valid:
            if data.is_ready:
                return do_processing(data)
    return None

# After: Guard clauses
def process(data):
    if not data:
        return None
    if not data.is_valid:
        return None
    if not data.is_ready:
        return None
    return do_processing(data)
```

### Code Migration

Migrate code between patterns or versions:

**Migration types:**

- Python 2 to 3
- Sync to async
- ORM migrations
- API version upgrades
- Framework migrations

**Migration workflow:**

1. **Assess scope**: What needs to change
2. **Create compatibility layer**: If gradual migration
3. **Migrate in phases**: Start with low-risk areas
4. **Maintain tests**: Ensure behavior preserved
5. **Remove old code**: Clean up after migration

**Example: Sync to Async**

```python
# Before: Synchronous
def fetch_user(user_id: int) -> User:
    response = requests.get(f"/users/{user_id}")
    return User.from_dict(response.json())

# After: Asynchronous
async def fetch_user(user_id: int) -> User:
    async with aiohttp.ClientSession() as session:
        async with session.get(f"/users/{user_id}") as response:
            data = await response.json()
            return User.from_dict(data)
```

## Refactoring Workflow

### Safe Refactoring Process

1. **Ensure test coverage**: Add tests if missing
2. **Run tests**: Verify green baseline
3. **Make small change**: One refactoring at a time
4. **Run tests again**: Verify still green
5. **Commit**: Save progress
6. **Repeat**: Continue with next change

### Pre-Refactoring Checklist

```
[ ] Tests exist for affected code
[ ] All tests pass
[ ] Change is well understood
[ ] Impact scope identified
[ ] Rollback plan exists
```

### Post-Refactoring Verification

```
[ ] All tests still pass
[ ] No new linting errors
[ ] Type checking passes
[ ] Functionality unchanged
[ ] Performance acceptable
```

## Common Refactorings

### Remove Dead Code

```python
# Find and remove:
# - Unused imports
# - Unused variables
# - Unreachable code
# - Commented-out code
# - Deprecated functions

# Tools:
# - vulture (Python)
# - autoflake (Python)
# - eslint (JavaScript)
```

### Simplify Expressions

```python
# Before
if condition == True:
    return True
else:
    return False

# After
return condition
```

### Introduce Explaining Variables

```python
# Before
if user.age >= 18 and user.country in ['US', 'CA'] and user.verified:
    allow_purchase()

# After
is_adult = user.age >= 18
is_supported_country = user.country in ['US', 'CA']
is_verified = user.verified
can_purchase = is_adult and is_supported_country and is_verified

if can_purchase:
    allow_purchase()
```

## Safety Guidelines

### Breaking Changes

When refactoring public APIs:

1. Add deprecation warnings first
2. Maintain backwards compatibility
3. Document migration path
4. Remove after deprecation period

### Database Migrations

When refactoring data models:

1. Create migration scripts
2. Test migrations on copy of data
3. Plan for rollback
4. Consider zero-downtime migrations

### Performance Impact

After refactoring:

1. Run performance benchmarks
2. Compare with baseline
3. Profile if regression found
4. Optimize if necessary

## Integration

Coordinate with other skills:

- **code-quality skill**: Measure improvement
- **test-coverage skill**: Ensure test coverage
- **architecture-review skill**: Validate structural changes
- **git-workflows skill**: Proper commit messages for refactors