PolderKnowledge\EntityService\Repository\Doctrine\CollectionRepository

Complexity

Total Complexity

13

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

65%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	delete()	0	5	1
A	deleteBy()	0	11	2
A	countBy()	0	6	1
A	find()	0	8	1
A	findAll()	0	4	1
A	findBy()	0	6	1
A	findOneBy()	0	6	1
A	persist()	0	9	3
A	getPersisted()	0	4	1

<?php

namespace PolderKnowledge\EntityService\Repository\Doctrine;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use PolderKnowledge\EntityService\Repository\EntityRepositoryInterface;
use PolderKnowledge\EntityService\Repository\Feature\DeletableInterface;
use PolderKnowledge\EntityService\Repository\Feature\ReadableInterface;
use PolderKnowledge\EntityService\Repository\Feature\TransactionAwareInterface;
use PolderKnowledge\EntityService\Repository\Feature\WritableInterface;
use PolderKnowledge\EntityService\Repository\Util;
use UnexpectedValueException;

class CollectionRepository implements
    EntityRepositoryInterface,
    DeletableInterface,
    ReadableInterface,
    WritableInterface
{
    private $allItems;

    private $persisted;

    public function __construct(array $initialItems = [])
    {
        $this->allItems = new ArrayCollection($initialItems);
        $this->persisted = new ArrayCollection;
    }

    public function delete($entity)
    {
        $this->allItems->removeElement($entity);
        $this->persisted->removeElement($entity);
    }

    public function deleteBy($criteria)
    {
        $criteria = Util::normalizeCriteria($criteria);

        $itemsToDelete = $this->allItems->matching($criteria);

        foreach ($itemsToDelete as $item) {
            $this->allItems->removeElement($item);
            $this->persisted->removeElement($item);
        }
    }

    public function countBy($criteria)
    {
        $criteria = Util::normalizeCriteria($criteria);

        return $this->allItems->matching($criteria)->count();
    }

    public function find($id)
    {
        return $this->allItems->filter(
            function ($entity) use ($id) {
                return $entity->getId() === $id;
            }
        )->first();
    }

    public function findAll()
    {
        return $this->allItems->toArray();
    }

    public function findBy($criteria)
    {
        $criteria = Util::normalizeCriteria($criteria);

        return $this->allItems->matching($criteria)->toArray();
    }

    public function findOneBy($criteria)
    {
        $criteria = Util::normalizeCriteria($criteria);

        return $this->allItems->matching($criteria)->first();
    }

    public function persist($entity)
    {
        if (!$this->allItems->contains($entity)) {
            $this->allItems->add($entity);
        }
        if (!$this->persisted->contains($entity)) {
            $this->persisted->add($entity);
        }
    }

    /**
     * Method outside of the standard interface, for testing purposes
     */
    public function getPersisted(): ArrayCollection
    {
        return clone $this->persisted;
    }
}