Code Refactoring Skill

Improve code quality through systematic refactoring.

1. Extract Method/Function

Before:

def process_order(order):
    # Calculate total
    total = 0
    for item in order.items:
        total += item.price * item.quantity
    tax = total * 0.08
    total += tax

    # Send email
    subject = f"Order #{order.id} Confirmation"
    body = f"Your order total is ${total}"
    send_email(order.customer.email, subject, body)

After:

def process_order(order):
    total = calculate_total_with_tax(order.items)
    send_order_confirmation_email(order, total)

def calculate_total_with_tax(items, tax_rate=0.08):
    subtotal = sum(item.price * item.quantity for item in items)
    return subtotal * (1 + tax_rate)

def send_order_confirmation_email(order, total):
    subject = f"Order #{order.id} Confirmation"
    body = f"Your order total is ${total:.2f}"
    send_email(order.customer.email, subject, body)

2. Replace Magic Numbers

Before:

function calculateDiscount(price) {
    if (price > 100) {
        return price * 0.15;
    }
    return price * 0.05;
}

After:

const DISCOUNT_THRESHOLD = 100;
const REGULAR_DISCOUNT_RATE = 0.05;
const PREMIUM_DISCOUNT_RATE = 0.15;

function calculateDiscount(price) {
    const rate = price > DISCOUNT_THRESHOLD
        ? PREMIUM_DISCOUNT_RATE
        : REGULAR_DISCOUNT_RATE;
    return price * rate;
}

3. Simplify Conditional Logic

Before:

def get_user_status(user):
    if user.is_active:
        if user.subscription:
            if user.subscription.is_paid:
                return "premium"
            else:
                return "active"
        else:
            return "active"
    else:
        return "inactive"

After:

def get_user_status(user):
    if not user.is_active:
        return "inactive"

    if user.subscription and user.subscription.is_paid:
        return "premium"

    return "active"

4. Replace Nested Conditionals with Guard Clauses

Before:

function processPayment(payment) {
    if (payment) {
        if (payment.amount > 0) {
            if (payment.method) {
                // Process payment
                return chargeCard(payment);
            } else {
                throw new Error("No payment method");
            }
        } else {
            throw new Error("Invalid amount");
        }
    } else {
        throw new Error("No payment provided");
    }
}

After:

function processPayment(payment) {
    if (!payment) {
        throw new Error("No payment provided");
    }
    if (payment.amount <= 0) {
        throw new Error("Invalid amount");
    }
    if (!payment.method) {
        throw new Error("No payment method");
    }

    return chargeCard(payment);
}

5. Extract Class

Before:

class Order:
    def __init__(self):
        self.items = []
        self.customer_name = ""
        self.customer_email = ""
        self.customer_address = ""
        self.shipping_method = ""
        self.shipping_cost = 0

After:

class Customer:
    def __init__(self, name, email, address):
        self.name = name
        self.email = email
        self.address = address

class Shipping:
    def __init__(self, method, cost):
        self.method = method
        self.cost = cost

class Order:
    def __init__(self, customer, shipping):
        self.items = []
        self.customer = customer
        self.shipping = shipping

6. Replace Type Code with Polymorphism

Before:

class Animal {
    constructor(type) {
        this.type = type;
    }

    makeSound() {
        if (this.type === 'dog') {
            return 'Woof!';
        } else if (this.type === 'cat') {
            return 'Meow!';
        }
    }
}

After:

class Animal {
    makeSound() {
        throw new Error('Must implement makeSound');
    }
}

class Dog extends Animal {
    makeSound() {
        return 'Woof!';
    }
}

class Cat extends Animal {
    makeSound() {
        return 'Meow!';
    }
}

7. Dependency Injection

Before:

class UserService:
    def __init__(self):
        self.db = Database()  # Hard-coded dependency

    def get_user(self, id):
        return self.db.query(f"SELECT * FROM users WHERE id={id}")

After:

class UserService:
    def __init__(self, database):
        self.db = database  # Injected dependency

    def get_user(self, id):
        return self.db.query_user(id)

# Usage
db = Database()
service = UserService(db)

8. Remove Duplication

Before:

def send_welcome_email(user):
    subject = "Welcome!"
    body = f"Hello {user.name}"
    send_email(user.email, subject, body)

def send_reset_email(user):
    subject = "Password Reset"
    body = f"Hello {user.name}, click here to reset"
    send_email(user.email, subject, body)

After:

def send_user_email(user, subject, message_template):
    body = message_template.format(name=user.name)
    send_email(user.email, subject, body)

def send_welcome_email(user):
    send_user_email(user, "Welcome!", "Hello {name}")

def send_reset_email(user):
    send_user_email(user, "Password Reset",
                   "Hello {name}, click here to reset")

9. SOLID Principles

Single Responsibility:

# Before: Class does too much
class User:
    def save(self):
        # Database logic
        pass

    def send_email(self):
        # Email logic
        pass

# After: Separate responsibilities
class User:
    pass

class UserRepository:
    def save(self, user):
        pass

class EmailService:
    def send_welcome_email(self, user):
        pass

Open/Closed Principle:

# Before: Must modify class to add new shapes
class AreaCalculator:
    def calculate(self, shape):
        if shape.type == 'circle':
            return 3.14 * shape.radius ** 2
        elif shape.type == 'square':
            return shape.side ** 2

# After: Open for extension, closed for modification
class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

10. Modern Patterns

Use List Comprehensions:

# Before
result = []
for item in items:
    if item.is_valid:
        result.append(item.name.upper())

# After
result = [item.name.upper() for item in items if item.is_valid]

Use Destructuring:

// Before
const name = user.name;
const email = user.email;

// After
const { name, email } = user;

Use Arrow Functions:

// Before
users.map(function(user) {
    return user.name;
});

// After
users.map(user => user.name);

When to Use This Skill

Use /refactor when:

• Code is difficult to understand
• Functions are too long
• Classes have too many responsibilities
• Code has duplication
• Preparing for new features
• Improving test coverage
• Modernizing legacy code
• Applying design patterns