README

Conteneur simple de services pour l'injection de dépendances en PHP. Permet l'enregistrement de services, la résolution automatique des dépendances, le chaînage entre services et l'injection de valeurs par défaut pour les types primitifs.

⭐ Utilisation

Créer un container

$container = new Container();

Enregistrer un nouveau service

interface PersonInterface
{
    public function getFirstname(): string;
    public function getLastname(): string;
}

class Person implements PersonInterface
{
    public function __construct(
        private readonly string $firstname,
        private readonly string $lastname
    ) {
    }

    // ...
}

$container->registry('person1', Person::class, [
    'firstname' => 'Adrien',
    'lastname' => 'RUIZ',
]);

Utiliser un service déjà enregistré

$person1 = $container->get('person1');

echo $person1->getFirstname(); // Affiche: Adrien
echo $person1->getLastname(); // Affiche: RUIZ

Chainer les services

interface IdentityInterface
{
    public function getName(): string;
    public function getEmail(): string;
    public function getGender(): string;
}

class Identity implements IdentityInterface
{
    public function __construct(
        private readonly PersonInterface $person,
        private readonly string $email,
        private readonly string $gender
    ) {
    }

    public function getName(): string
    {
        return $this->person->getFirstname() . ' ' . $this->person->getLastname();
    }

    // ...
}

$container->registry('identity1', Identity::class, [
    'person' => '@person1', // Clé déjà enregistrée
    'email' => 'un_email_qui_n_existe_pas@gmail.com',
    'gender' => 'M',
]);

$identity1 = $container->get('identity1');

echo $identity1->getName(); // Affiche: Adrien RUIZ
echo $identity1->getEmail(); // Affiche: un_email_qui_n_existe_pas@gmail.com
echo $identity1->getGender(); // Affiche: M

Résolution automatique des classes

interface MailerInterface
{
    public function sendMail(string $email, string $content): bool;
}

class Mailer implements MailerInterface
{
    // ...
}

interface AccountInterface
{
    public function setIdentity(IdentityInterface $identiy): self;
    public function getIdentity(): ?IdentityInterface;
    public function sendEmail(string $content): bool;
}

class Account implements AccountInterface
{
    private ?IdentityInterface $identity = null;

    public function __construct(
        private readonly MailerInterface $mailer
    ) {
    }

    public function setIdentity(IdentityInterface $identity): self
    {
        $this->identity = $identity;

        return $this;
    }

    public function getIdentity(): ?IdentityInterface
    {
        return $this->identity;
    }

    public function sendEmail(string $content): bool
    {
        if (!$this->identity instanceof IdentityInterface) {
            //...
            return false;
        }

        return $this->$mailer->sendEmail($this->identity->getEmail(), $content);
    }
}

$identity1 = $container->get('identity1');

// Le paramètre "MailerInterface $mailer" du constructeur est
// automatiquement résolu et instancié par le service lui-même. La
// dépendance est automatiquement injectée.
$container->registry('account1', Account::class);

$account1 = $container->get('account1');
$account1->setIdentity($identity1)->sendEmail('Hello, comment tu vas ?');

Valeurs par défaut

Lorsqu'un constructeur possède des paramètres de types primitifs, alors des valeurs par défaut peuvent être automatiquement injectées pour permettre l'instanciation du service.

class MaClass
{
    public function __construct(
        private readonly int $un_entier,     // Contiendra par défaut int(0)
        private readonly float $un_flottant, // Contiendra par défaut float(0.0)
        private readonly string $une_chaine  // Contiendra par défaut string('')
    ) {
    }

    public function getUnEntier(): int
    {
        return $this->un_entier;
    }

    // ...
}

$container->registry('test', MaClass:class);

echo $container->get('test')->getUnEntier(); // Affiche int(0)
// etc.

⭐ Tests

Lancer les tests unitaires :

php vendor/bin/phpunit

Lancer les tests unitaires avec des statistiques de couverture du code :

La commande aura pour effet de générer un fichier coverage.xml qui pourra ensuite être utilisé par SonarCloud, et un répertoire coverage contenant le HTML permettant de consulter le compte rendu depuis son navigateur.

php vendor/bin/phpunit --log-junit=tests.xml --coverage-clover=coverage.xml --coverage-html coverage

xdebug doit être installé et activé. Exemple avec un conteneur Docker :

# /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini

zend_extension=xdebug.so

[xdebug]
xdebug.mode=coverage