@sylix/coworker 2.0.10 → 2.0.12

package/dist/skills/defaults/refactoring/code-refactoring.md

@@ -0,0 +1,349 @@
+---
+name: code-refactoring-patterns
+description: Master code refactoring techniques to improve code quality, reduce complexity, and apply SOLID principles. Use when improving existing code, reducing technical debt, or applying design patterns.
+---
+
+# Code Refactoring Patterns
+
+Master code refactoring techniques to improve code quality, reduce complexity, and apply SOLID principles.
+
+## When to Use This Skill
+
+- Improving existing codebases
+- Reducing technical debt
+- Applying SOLID principles
+- Extracting complex logic into smaller functions
+- Converting procedural code to object-oriented
+- Improving testability
+
+## Core Refactoring Techniques
+
+### 1. Extract Method
+
+**Before:**
+```python
+def process_order(order):
+    # Validate order
+    if order.customer_id is None:
+        return False
+    if not order.items:
+        return False
+    
+    # Calculate total
+    total = 0
+    for item in order.items:
+        total += item.price * item.quantity
+    
+    # Apply discount
+    if total > 100:
+        total *= 0.9
+    
+    # Save order
+    order.total = total
+    db.save(order)
+    
+    return True
+```
+
+**After:**
+```python
+def process_order(order):
+    if not validate_order(order):
+        return False
+    
+    total = calculate_total(order)
+    total = apply_discount(total)
+    
+    order.total = total
+    db.save(order)
+    
+    return True
+
+def validate_order(order):
+    return order.customer_id is not None and bool(order.items)
+
+def calculate_total(order):
+    return sum(item.price * item.quantity for item in order.items)
+
+def apply_discount(total):
+    return total * 0.9 if total > 100 else total
+```
+
+### 2. Replace Conditional with Polymorphism
+
+**Before:**
+```python
+class Employee:
+    def calculate_pay(self):
+        if self.type == "hourly":
+            return self.hours * self.rate
+        elif self.type == "salary":
+            return self.salary / 12
+        elif self.type == "commission":
+            return self.salary + self.commission
+```
+
+**After:**
+```python
+from abc import ABC, abstractmethod
+
+class Employee(ABC):
+    @abstractmethod
+    def calculate_pay(self):
+        pass
+
+class HourlyEmployee(Employee):
+    def calculate_pay(self):
+        return self.hours * self.rate
+
+class SalariedEmployee(Employee):
+    def calculate_pay(self):
+        return self.salary / 12
+```
+
+### 3. Introduce Parameter Object
+
+**Before:**
+```python
+def create_report(start_date, end_date, include_charts, include_summary, 
+                  include_details, department, region):
+    # Report creation logic
+    pass
+```
+
+**After:**
+```python
+from dataclasses import dataclass
+
+@dataclass
+class ReportParams:
+    start_date: date
+    end_date: date
+    include_charts: bool = False
+    include_summary: bool = True
+    include_details: bool = False
+    department: str = None
+    region: str = None
+
+def create_report(params: ReportParams):
+    # Report creation logic
+    pass
+```
+
+### 4. Replace Magic Numbers with Constants
+
+**Before:**
+```python
+def calculate_tax(amount):
+    return amount * 1.2
+
+if status == 1:  # What is 1?
+    pass
+```
+
+**After:**
+```python
+TAX_RATE = Decimal('1.20')
+class Status:
+    ACTIVE = 1
+    INACTIVE = 2
+    PENDING = 3
+
+def calculate_tax(amount):
+    return amount * TAX_RATE
+```
+
+### 5. Extract Interface
+
+**Before:**
+```python
+class OrderService:
+    def create_order(self, data):
+        # validation + creation logic
+    
+    def cancel_order(self, order_id):
+        # cancellation logic
+
+class CustomerService:
+    def create_customer(self, data):
+        # validation + creation logic
+```
+
+**After:**
+```python
+from abc import ABC, abstractmethod
+
+class Creatable(ABC):
+    @abstractmethod
+    def create(self, data):
+        pass
+
+class OrderService(Creatable):
+    def create(self, data):
+        # creation logic
+
+class CustomerService(Creatable):
+    def create(self, data):
+        # creation logic
+```
+
+## SOLID Principles
+
+### Single Responsibility Principle (SRP)
+
+Each class should have only one reason to change:
+
+```python
+# BAD: Multiple responsibilities
+class User:
+    def authenticate(self, password):
+        pass
+    
+    def save_to_database(self):
+        pass
+    
+    def send_email(self):
+        pass
+
+# GOOD: Separate responsibilities
+class User:
+    pass
+
+class Authenticator:
+    def authenticate(self, user, password):
+        pass
+
+class UserRepository:
+    def save(self, user):
+        pass
+
+class EmailService:
+    def send(self, user, message):
+        pass
+```
+
+### Open/Closed Principle (OCP)
+
+Open for extension, closed for modification:
+
+```python
+# BAD: Need to modify to add new types
+class AreaCalculator:
+    def calculate(self, shape):
+        if isinstance(shape, Circle):
+            return math.pi * shape.radius ** 2
+        elif isinstance(shape, Rectangle):
+            return shape.width * shape.height
+        # Need to modify for new shapes
+
+# GOOD: Add new shapes without modification
+from abc import ABC, abstractmethod
+
+class Shape(ABC):
+    @abstractmethod
+    def area(self):
+        pass
+
+class Circle(Shape):
+    def area(self):
+        return math.pi * self.radius ** 2
+
+class Rectangle(Shape):
+    def area(self):
+        return self.width * self.height
+```
+
+### Liskov Substitution Principle (LSP)
+
+Subtypes must be substitutable for their base types:
+
+```python
+# BAD: Square violates LSP
+class Rectangle:
+    def set_width(self, width):
+        self.width = width
+    
+    def set_height(self, height):
+        self.height = height
+
+class Square(Rectangle):
+    def set_width(self, width):
+        self.width = width
+        self.height = width  # Violates expectation
+    
+    def set_height(self, height):
+        self.height = height
+        self.width = height
+
+# GOOD: Separate hierarchies
+class Shape(ABC):
+    @abstractmethod
+    def area(self):
+        pass
+
+class Rectangle(Shape):
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+    
+    def area(self):
+        return self.width * self.height
+
+class Square(Shape):
+    def __init__(self, side):
+        self.side = side
+    
+    def area(self):
+        return self.side ** 2
+```
+
+### Dependency Inversion Principle (DIP)
+
+Depend on abstractions, not concretions:
+
+```python
+# BAD: Direct dependency on concrete class
+class OrderService:
+    def __init__(self):
+        self.db = PostgreSQLDatabase()
+    
+    def save(self, order):
+        self.db.save(order)
+
+# GOOD: Depend on abstraction
+class Database(ABC):
+    @abstractmethod
+    def save(self, entity):
+        pass
+
+class OrderService:
+    def __init__(self, db: Database):
+        self.db = db
+    
+    def save(self, order):
+        self.db.save(order)
+```
+
+## Code Smells to Fix
+
+| Smell | Solution |
+|-------|----------|
+| Long methods | Extract to smaller methods |
+| Large classes | Split into focused classes |
+| Duplicated code | Extract to shared method |
+| Feature envy | Move method to data class |
+| Data clumps | Introduce parameter object |
+| Primitive obsession | Replace with value objects |
+| Switch statements | Use polymorphism |
+| Parallel inheritance | Merge hierarchies |
+| Lazy class | Remove or inline |
+| Speculative generality | Remove unused abstractions |
+
+## Refactoring Checklist
+
+1. [ ] Tests exist before refactoring
+2. [ ] Small, incremental changes
+3. [ ] Commit after each successful refactor
+4. [ ] Run tests after each change
+5. [ ] Use IDE refactoring tools
+6. [ ] Check code coverage maintained