Framework Make Collection Skill

Description

Génère une classe Collection typée pour gérer des ensembles d'entités avec les traits et interfaces Atournayre.

La Collection offre des méthodes pour manipuler des ensembles d'objets de manière type-safe et respectant les principes Elegant Objects.

Usage

Use skill framework:make:collection

Vous serez invité à fournir :
- Le nom de l'entité (ex: Product, User, Order)

Templates

• Collection/UtilisateurCollection.php - Template de classe Collection

Variables requises

• {EntityName} - Nom de l'entité en PascalCase (ex: Utilisateur, Product)
• {entityName} - Nom de l'entité en camelCase (ex: utilisateur, product)
• {namespace} - Namespace du projet (défaut: App)

Dépendances

• Requiert que l'entité existe dans src/Entity/{EntityName}.php
• Requiert framework atournayre/framework

Outputs

• src/Collection/{EntityName}Collection.php

Workflow

1. Demander le nom de l'entité (EntityName)
2. Vérifier que l'entité existe dans src/Entity/{EntityName}.php
   • Si non : arrêter et demander de créer l'entité d'abord
3. Générer la classe Collection depuis le template :
   • Remplacer {EntityName} par le nom fourni
   • Remplacer {entityName} par la version camelCase
4. Afficher le fichier créé

Patterns appliqués

Classe Collection

• Classe final
• Implémente interfaces Atournayre :
  • AsListInterface
  • ToArrayInterface
  • CountInterface
  • CountByInterface
  • AtLeastOneElementInterface
  • HasSeveralElementsInterface
  • HasNoElementInterface
  • HasOneElementInterface
  • HasXElementsInterface
  • LoggableInterface
• Utilise traits Atournayre :
  • Collection
  • Collection\ToArray
  • Collection\Countable
• Méthode statique asList(array $collection)
• Méthode toLog() pour logging

Exemple

Use skill framework:make:collection

# Saisies utilisateur :
EntityName: Product

# Résultat :
✓ src/Collection/ProductCollection.php

Fichier généré :

<?php

declare(strict_types=1);

namespace App\Collection;

use App\Entity\Product;
use Atournayre\Contracts\Collection\AsListInterface;
use Atournayre\Contracts\Collection\AtLeastOneElementInterface;
use Atournayre\Contracts\Collection\CountByInterface;
use Atournayre\Contracts\Collection\CountInterface;
use Atournayre\Contracts\Collection\HasNoElementInterface;
use Atournayre\Contracts\Collection\HasOneElementInterface;
use Atournayre\Contracts\Collection\HasSeveralElementsInterface;
use Atournayre\Contracts\Collection\HasXElementsInterface;
use Atournayre\Contracts\Collection\ToArrayInterface;
use Atournayre\Contracts\Log\LoggableInterface;
use Atournayre\Primitives\Collection as PrimitiveCollection;
use Atournayre\Primitives\Traits\Collection;

final class ProductCollection implements AsListInterface, ToArrayInterface, CountInterface, CountByInterface, AtLeastOneElementInterface, HasSeveralElementsInterface, HasNoElementInterface, HasOneElementInterface, HasXElementsInterface, LoggableInterface
{
    use Collection;
    use Collection\ToArray;
    use Collection\Countable;

    public static function asList(array $collection): self
    {
        return new self(PrimitiveCollection::of($collection));
    }

    /**
     * @return array<string, mixed>
     */
    public function toLog(): array
    {
        return [
            'count' => $this->count()->value(),
            'items' => $this->collection->map(fn (Product $item) => $item->toLog()),
        ];
    }

    // UNIQUEMENT les méthodes EXPLICITEMENT demandées par l'utilisateur
    // PAS d'anticipation de besoins futurs
    // PAS de méthodes génériques (add, remove, filter, map, etc.)
}

Usage

Création d'une collection

$products = ProductCollection::asList([
    $product1,
    $product2,
    $product3,
]);

Méthodes disponibles (via traits)

// Comptage
$count = $products->count(); // Atournayre\Primitives\Number
$hasElements = $products->hasNoElement(); // bool
$hasOne = $products->hasOneElement(); // bool
$hasSeveral = $products->hasSeveralElements(); // bool
$hasAtLeastOne = $products->hasAtLeastOneElement(); // bool
$hasX = $products->hasXElements(5); // bool

// Conversion
$array = $products->toArray(); // array

// Comptage personnalisé
$activeCount = $products->countBy(fn (Product $p) => $p->isActive());

Ajout de méthodes métier (YAGNI)

N'ajouter que les méthodes explicitement demandées :

final class ProductCollection implements ...
{
    // ... traits ...

    public function active(): self
    {
        return new self(
            $this->collection->filter(fn (Product $p) => $p->isActive())
        );
    }

    public function totalPrice(): float
    {
        return $this->collection
            ->map(fn (Product $p) => $p->price())
            ->reduce(fn (float $sum, float $price) => $sum + $price, 0.0);
    }
}

Notes

• Respect du principe YAGNI : pas de méthodes génériques anticipées
• Seules les méthodes explicitement demandées doivent être ajoutées
• Les traits fournissent déjà beaucoup de fonctionnalités
• La collection est type-safe (typage sur l'entité)
• LoggableInterface permet le logging automatique