Grasp Knowledge

GRASP Principles Knowledge Base

Overview

GRASP (General Responsibility Assignment Software Patterns) provides guidelines for assigning responsibilities to classes and objects in object-oriented design.

Quick Detection Patterns

Information Expert Violations

# Feature Envy: Class uses other class's data more
Grep: "->get.*->get.*->get" --glob "**/*.php"

# Train wreck calls
Grep: "->.*()->.*()->.*()->" --glob "**/*.php"

Signs: Method accesses other object's data extensively, data and behavior separated.

Creator Violations

# Random creation locations
Grep: "new\s\+[A-Z][a-z]*[A-Z]" --glob "**/*.php"

Signs: Objects created in unexpected places, no clear creation ownership.

Controller Violations

# Fat controllers (>100 lines)
find . -path "*/Controller/*.php" -exec wc -l {} \; | awk '$1 > 100'

# Business logic in controllers
Grep: "if.*&&.*||" --glob "*Controller.php"

Signs: Controller has >100 lines, business logic in controller.

Low Coupling Violations

# High dependency count (>7)
Grep: "__construct" --glob "**/*.php" -A 15

# Concrete type dependencies
Grep: "function.*([A-Z][a-z]*[A-Z]" --glob "**/*.php"

Signs: Class has >7 dependencies, depends on concrete classes.

High Cohesion Violations

# Unrelated method names
Grep: "public function" --glob "**/*.php" | grep -E "And[A-Z]|Or[A-Z]"

# Multiple responsibilities in class name
Grep: "class.*Manager|class.*Handler|class.*Processor" --glob "**/*.php"

Signs: Methods don't relate to each other, class does many unrelated things.

Quick PHP 8.4 Examples

Information Expert

// BAD: Logic outside of object with data
final class OrderService
{
    public function calculateTotal(Order $order): Money
    {
        $total = Money::zero();
        foreach ($order->getLines() as $line) {
            $total = $total->add($line->getProduct()->getPrice()->multiply($line->getQuantity()));
        }
        return $total;
    }
}

// GOOD: Logic in class that has the data
final class Order
{
    public function total(): Money
    {
        return array_reduce(
            $this->lines,
            fn(Money $sum, OrderLine $line) => $sum->add($line->total()),
            Money::zero(),
        );
    }
}

Low Coupling

// BAD: Depends on concrete classes
final class ReportGenerator
{
    public function __construct(
        private DoctrineOrderRepository $orders,
        private SymfonyMailer $mailer,
    ) {}
}

// GOOD: Depends on abstractions
final readonly class ReportGenerator
{
    public function __construct(
        private OrderReader $orders,
        private Mailer $mailer,
    ) {}
}

High Cohesion

// BAD: Low cohesion - unrelated responsibilities
final class UserManager
{
    public function register(array $data): User { }
    public function sendEmail(User $user): void { }
    public function generateReport(): string { }
}

// GOOD: High cohesion - focused responsibilities
final readonly class UserRegistrationService
{
    public function register(RegistrationData $data): User { }
    public function confirmEmail(Token $token): void { }
}

GRASP & DDD Integration

References

For detailed patterns and examples, see references/:

• information-expert.md — Tell Don't Ask, calculations in owner
• creator.md — Factory patterns, aggregation rules
• controller.md — Use case handlers, thin controllers
• low-coupling.md — Dependency injection, abstractions
• high-cohesion.md — Focused responsibilities
• polymorphism.md — Strategy pattern, type variations
• pure-fabrication.md — Repositories, specifications
• indirection.md — Adapters, mediators
• protected-variations.md — Stable interfaces
• antipatterns.md — Common GRASP violations

Assets

• assets/report-template.md — GRASP audit report format