object-calisthenics

name	object-calisthenics
description	Object Calisthenics — 9 rules for encapsulation and OOP simplicity.

Object Calisthenics

9 rules for better object-oriented code. Apply as many as the project's context justifies — they are constraints, not commandments.

The 9 Rules

Rule 1 — Only One Level of Indentation per Method

Each method should have at most one if, for, while nesting level. Extract deeper logic into private methods.

// Bad
function processOrders($orders) {
    foreach ($orders as $order) {
        if ($order->isActive()) {
            foreach ($order->items as $item) {
                // logic here
            }
        }
    }
}

// Good
function processOrders($orders) {
    foreach ($orders as $order) {
        $this->processActiveOrder($order);
    }
}

Rule 2 — Don't Use the else Keyword

Use early returns, guard clauses, or strategy pattern instead.

// Bad
if ($user->isAdmin()) {
    return $this->adminView();
} else {
    return $this->guestView();
}

// Good
if ($user->isAdmin()) {
    return $this->adminView();
}
return $this->guestView();

Rule 3 — Wrap All Primitives and Strings

Primitives that have behavior or validation belong in a Value Object.

// Bad: string passed around, validated in multiple places
function sendEmail(string $email) { ... }

// Good: validation lives in the Value Object
function sendEmail(Email $email) { ... }

Apply when the primitive has: validation rules, formatting, or business meaning.

Rule 4 — Use First-Class Collections

A class that contains a collection should have no other instance variables.

// Bad: array mixed with other data
class Order {
    private array $items;
    private string $status;
}

// Good: collection has its own class
class OrderItems {
    private array $items;
    public function totalPrice(): Money { ... }
    public function count(): int { ... }
}

Rule 5 — One Dot per Line (Law of Demeter)

Don't chain calls through multiple objects. Talk only to your immediate neighbors.

// Bad: violates LoD
$city = $order->getCustomer()->getAddress()->getCity();

// Good: ask, don't reach
$city = $order->customerCity();

Rule 6 — Don't Abbreviate

Names should be clear and complete. Abbreviations hide intent.

// Bad
$ord, $usr, $mgr, $calc

// Good
$order, $user, $manager, $calculator

If a name is too long, the class might be doing too much.

Rule 7 — Keep All Entities Small

• Classes: max ~50 lines of behavior (excluding blank lines and comments)
• Methods: max ~5 lines
• Files: max ~100 lines

If a class grows beyond this, extract responsibilities.

Rule 8 — No Classes with More Than Two Instance Variables

Classes with fewer instance variables have stronger cohesion. This forces decomposition into smaller, focused objects.

// Bad
class Customer {
    private string $name;
    private string $email;
    private string $street;
    private string $city;
    private string $country;
}

// Good
class Customer {
    private Name $name;
    private Email $email;
    private Address $address;
}

Rule 9 — No Getters/Setters (Tell, Don't Ask)

Don't expose internals. Tell objects to do things rather than asking for their data.

// Bad: asking for data, processing outside the object
$discount = $product->getPrice() * $product->getDiscountRate();

// Good: tell the object to calculate its own discount
$discount = $product->calculateDiscount();

---

Applying the Rules

Start with Rules 1, 2, and 6 — they have the highest impact with the least resistance.

Rules 3, 4, and 8 are most valuable in domain-heavy code (business logic, entities, value objects).

Rules 5, 7, and 9 guide long-term architecture — apply gradually.

In code reviews, flag violations by rule number: [OC-Rule-2] Else clause can be removed with early return.