SimpleEventStoreManager\Infrastructure\Persistence\InMemoryEventStoreRepository

Complexity

Total Complexity

11

Size/Duplication

Total Lines	98
Duplicated Lines	18.37 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	buildEventAggregateAsArray()	17	17	2
A	count()	0	3	2
A	buildEventAggregateAsObject()	0	3	1
A	save()	0	8	1
A	__construct()	0	3	1
A	buildEventAggregate()	0	7	2
A	byUuid()	0	3	2

<?php
/**
 * This file is part of the Simple EventStore Manager package.
 *
 * (c) Mauro Cassani<https://github.com/mauretto78>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace SimpleEventStoreManager\Infrastructure\Persistence;

use SimpleEventStoreManager\Domain\Model\Contracts\EventInterface;
use SimpleEventStoreManager\Domain\Model\Contracts\EventStoreRepositoryInterface;
use SimpleEventStoreManager\Domain\Model\Event;
use SimpleEventStoreManager\Domain\Model\AggregateUuid;

class InMemoryEventStoreRepository implements EventStoreRepositoryInterface
{
    /**
     * @var array
     */
    private $events;

    /**
     * InMemoryEventRepository constructor.
     */
    public function __construct()
    {
        $this->events = [];
    }

    /**
     * @param AggregateUuid $uuid
     * @param int $returnType
     *
     * @return array|mixed|null
     */
    public function byUuid(AggregateUuid $uuid, $returnType = self::RETURN_AS_ARRAY)
    {
        return (isset($this->events[(string) $uuid])) ? $this->buildEventAggregate($uuid, $returnType) : null;
    }

    /**
     * @param AggregateUuid $uuid
     * @param $returnType
     *
     * @return array|mixed
     */
    private function buildEventAggregate(AggregateUuid $uuid, $returnType)
    {
        if ($returnType === self::RETURN_AS_ARRAY) {
            return $this->buildEventAggregateAsArray($uuid);
        }

        return $this->buildEventAggregateAsObject($uuid);
    }

    /**
     * @param AggregateUuid $uuid
     *
     * @return array
     */
    private function buildEventAggregateAsArray(AggregateUuid $uuid)

This method seems to be duplicated in your project.

    {
        $returnArray = [];

        /** @var Event $event */
        foreach ($this->events[(string) $uuid] as $event) {
            $returnArray[] = [
                'uuid' => $event->uuid(),
                'version' => $event->version(),
                'payload' => $event->payload(),
                'type' => $event->type(),
                'body' => $event->body(),
                'occurred_on' => $event->occurredOn(),
            ];
        }

        return $returnArray;
    }

    /**
     * @param AggregateUuid $uuid
     *
     * @return mixed
     */
    private function buildEventAggregateAsObject(AggregateUuid $uuid)
    {
        return $this->events[(string) $uuid];
    }

    /**
     * @param AggregateUuid $uuid
     *
     * @return int
     */
    public function count(AggregateUuid $uuid)
    {
        return (isset($this->events[(string) $uuid])) ? count($this->events[(string) $uuid]) : 0;
    }

    /**
     * @param EventInterface $event
     *
     * @return mixed
     */
    public function save(EventInterface $event)
    {
        $this->events[(string) $event->uuid()][] = new $event(
            $event->uuid(),

The call to SimpleEventStoreManager\Domain\Model\Contracts\EventInterface::__construct() has too many arguments starting with $event->uuid().

            $event->type(),
            $event->body(),
            $this->count($event->uuid()),
            $event->occurredOn()->format('Y-m-d H:i:s.u')
        );
    }
}