system-prompts-and-models-of-ai-tools/claude_skills/advanced-code-refactoring/reference.md

Advanced Code Refactoring Reference

Design Patterns Quick Reference

Creational Patterns

Factory Pattern

Purpose: Create objects without specifying exact class Use When: Object creation logic is complex or needs to be centralized

interface Product { use(): void; }
class ConcreteProductA implements Product { use() { /* ... */ } }
class ConcreteProductB implements Product { use() { /* ... */ } }

class ProductFactory {
  create(type: string): Product {
    if (type === 'A') return new ConcreteProductA();
    if (type === 'B') return new ConcreteProductB();
    throw new Error('Unknown type');
  }
}

Builder Pattern

Purpose: Construct complex objects step by step Use When: Object has many optional parameters

class QueryBuilder {
  private query = { select: [], where: [], orderBy: [] };

  select(fields: string[]) { this.query.select = fields; return this; }
  where(condition: string) { this.query.where.push(condition); return this; }
  orderBy(field: string) { this.query.orderBy.push(field); return this; }
  build() { return this.query; }
}

// Usage
const query = new QueryBuilder()
  .select(['id', 'name'])
  .where('age > 18')
  .orderBy('name')
  .build();

Singleton Pattern

Purpose: Ensure only one instance exists Use When: Need exactly one instance (database connection, config)

class Database {
  private static instance: Database;
  private constructor() { /* ... */ }

  static getInstance(): Database {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }
}

Structural Patterns

Adapter Pattern

Purpose: Convert interface of a class into another interface Use When: Want to use existing class with incompatible interface

interface ModernAPI { requestData(): Promise<Data>; }
class LegacyAPI { getData(callback: Function): void { /* ... */ } }

class LegacyAdapter implements ModernAPI {
  constructor(private legacy: LegacyAPI) {}

  requestData(): Promise<Data> {
    return new Promise((resolve) => {
      this.legacy.getData(resolve);
    });
  }
}

Decorator Pattern

Purpose: Add behavior to objects dynamically Use When: Need to add functionality without subclassing

interface Coffee { cost(): number; description(): string; }
class SimpleCoffee implements Coffee {
  cost() { return 5; }
  description() { return 'Simple coffee'; }
}

class MilkDecorator implements Coffee {
  constructor(private coffee: Coffee) {}
  cost() { return this.coffee.cost() + 2; }
  description() { return this.coffee.description() + ', milk'; }
}

const coffee = new MilkDecorator(new SimpleCoffee());

Facade Pattern

Purpose: Provide simplified interface to complex subsystem Use When: System is complex and you want simpler interface

class ComplexSystemA { operationA(): void { /* ... */ } }
class ComplexSystemB { operationB(): void { /* ... */ } }
class ComplexSystemC { operationC(): void { /* ... */ } }

class Facade {
  constructor(
    private systemA: ComplexSystemA,
    private systemB: ComplexSystemB,
    private systemC: ComplexSystemC
  ) {}

  simpleOperation(): void {
    this.systemA.operationA();
    this.systemB.operationB();
    this.systemC.operationC();
  }
}

Behavioral Patterns

Strategy Pattern

Purpose: Define family of algorithms, make them interchangeable Use When: Need different variants of an algorithm

interface SortStrategy { sort(data: number[]): number[]; }
class QuickSort implements SortStrategy { sort(data) { /* ... */ } }
class MergeSort implements SortStrategy { sort(data) { /* ... */ } }

class Sorter {
  constructor(private strategy: SortStrategy) {}
  sort(data: number[]) { return this.strategy.sort(data); }
}

Observer Pattern

Purpose: Define one-to-many dependency between objects Use When: Need to notify multiple objects of state changes

interface Observer { update(data: any): void; }

class Subject {
  private observers: Observer[] = [];

  attach(observer: Observer) { this.observers.push(observer); }
  detach(observer: Observer) { /* remove */ }
  notify(data: any) { this.observers.forEach(o => o.update(data)); }
}

Command Pattern

Purpose: Encapsulate request as an object Use When: Need to parameterize, queue, or log operations

interface Command { execute(): void; undo(): void; }

class CopyCommand implements Command {
  execute() { /* copy logic */ }
  undo() { /* undo copy */ }
}

class CommandInvoker {
  private history: Command[] = [];

  execute(command: Command) {
    command.execute();
    this.history.push(command);
  }

  undo() {
    const command = this.history.pop();
    command?.undo();
  }
}

SOLID Principles Detailed

Single Responsibility Principle (SRP)

Definition: A class should have one, and only one, reason to change

Bad Example:

class User {
  save() { /* database logic */ }
  sendEmail() { /* email logic */ }
  generateReport() { /* reporting logic */ }
}

Good Example:

class User { /* just user data */ }
class UserRepository { save(user: User) { /* database */ } }
class EmailService { send(user: User) { /* email */ } }
class ReportGenerator { generate(user: User) { /* report */ } }

Open/Closed Principle (OCP)

Definition: Open for extension, closed for modification

Bad Example:

class Rectangle { width: number; height: number; }
class Circle { radius: number; }

class AreaCalculator {
  calculate(shapes: any[]) {
    let area = 0;
    shapes.forEach(shape => {
      if (shape instanceof Rectangle) {
        area += shape.width * shape.height;
      } else if (shape instanceof Circle) {
        area += Math.PI * shape.radius ** 2;
      }
      // Need to modify this class for new shapes!
    });
    return area;
  }
}

Good Example:

interface Shape { area(): number; }

class Rectangle implements Shape {
  constructor(private width: number, private height: number) {}
  area() { return this.width * this.height; }
}

class Circle implements Shape {
  constructor(private radius: number) {}
  area() { return Math.PI * this.radius ** 2; }
}

class AreaCalculator {
  calculate(shapes: Shape[]) {
    return shapes.reduce((sum, shape) => sum + shape.area(), 0);
  }
  // No modification needed for new shapes!
}

Liskov Substitution Principle (LSP)

Definition: Derived classes must be substitutable for base classes

Bad Example:

class Bird {
  fly() { /* fly logic */ }
}

class Penguin extends Bird {
  fly() { throw new Error('Cannot fly'); } // Violates LSP!
}

Good Example:

class Bird { eat() { /* ... */ } }
class FlyingBird extends Bird { fly() { /* ... */ } }
class Penguin extends Bird { swim() { /* ... */ } }

Interface Segregation Principle (ISP)

Definition: Clients shouldn't depend on interfaces they don't use

Bad Example:

interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
}

class Robot implements Worker {
  work() { /* ... */ }
  eat() { throw new Error('Robots dont eat'); } // Forced to implement!
  sleep() { throw new Error('Robots dont sleep'); }
}

Good Example:

interface Workable { work(): void; }
interface Eatable { eat(): void; }
interface Sleepable { sleep(): void; }

class Human implements Workable, Eatable, Sleepable {
  work() { /* ... */ }
  eat() { /* ... */ }
  sleep() { /* ... */ }
}

class Robot implements Workable {
  work() { /* ... */ }
}

Dependency Inversion Principle (DIP)

Definition: Depend on abstractions, not concretions

Bad Example:

class MySQLDatabase {
  save(data: any) { /* MySQL specific */ }
}

class UserService {
  private db = new MySQLDatabase(); // Concrete dependency!

  createUser(data: any) {
    this.db.save(data);
  }
}

Good Example:

interface Database {
  save(data: any): Promise<void>;
}

class MySQLDatabase implements Database {
  save(data: any) { /* MySQL specific */ }
}

class PostgresDatabase implements Database {
  save(data: any) { /* Postgres specific */ }
}

class UserService {
  constructor(private db: Database) {} // Abstraction!

  createUser(data: any) {
    this.db.save(data);
  }
}

Code Smells & Refactorings

Long Method

Smell: Method has too many lines (>20-30) Refactoring: Extract Method

• Break into smaller, well-named methods
• Each method should do one thing

Large Class

Smell: Class has too many responsibilities Refactoring: Extract Class, Extract Subclass

• Identify separate responsibilities
• Create new classes for each

Long Parameter List

Smell: Method takes many parameters (>3-4) Refactoring: Introduce Parameter Object

• Group related parameters into object
• Pass object instead of individual parameters

Duplicated Code

Smell: Same code structure in multiple places Refactoring: Extract Method, Pull Up Method

• Extract duplicated code into shared method
• Place in common location

Feature Envy

Smell: Method uses more features of another class Refactoring: Move Method

• Move method to the class it's envious of

Primitive Obsession

Smell: Using primitives instead of small objects Refactoring: Replace Data Value with Object

// Before
function distance(x1: number, y1: number, x2: number, y2: number) { /* ... */ }

// After
class Point { constructor(public x: number, public y: number) {} }
function distance(p1: Point, p2: Point) { /* ... */ }

Switch Statements

Smell: Complex switch/if-else chains Refactoring: Replace Conditional with Polymorphism

• Create subclass for each case
• Use polymorphic behavior instead

Refactoring Checklist

Before refactoring:

• Ensure comprehensive test coverage exists
• All tests are passing
• Understand the code's current behavior
• Identify specific code smells or issues
• Plan the refactoring approach
• Commit current working state

During refactoring:

• Make small, incremental changes
• Run tests after each change
• Commit frequently with clear messages
• Don't add features while refactoring
• Keep system fully functional at all times

After refactoring:

• All tests still pass
• Code is more readable
• Complexity reduced (measured)
• No duplication
• Documentation updated
• Performance maintained or improved
• Peer review conducted