SmoothPhp\EventSourcing\AggregateRoot

Complexity

Total Complexity

10

Size/Duplication

Total Lines	98
Duplicated Lines	8.16 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	apply()	0	12	1
A	handle()	8	8	2
A	handleRecursively()	0	9	2
A	getApplyMethod()	0	6	1
A	getUncommittedEvents()	0	8	1
A	initializeState()	0	7	2
A	addChildEntity()	0	4	1

<?php
namespace SmoothPhp\EventSourcing;

use SmoothPhp\Contracts\EventSourcing\AggregateRoot as AggregateRootInterface;
use SmoothPhp\Contracts\EventSourcing\Entity;

This use statement conflicts with another class in this namespace, SmoothPhp\EventSourcing\Entity.

use SmoothPhp\Contracts\EventSourcing\Event;
use SmoothPhp\Domain\DomainEventStream;
use SmoothPhp\Domain\DomainMessage;
use SmoothPhp\Domain\Metadata;

/**
 * Class AggregateRoot
 * @author Simon Bennett <simon@smoothphp.im>
 */
abstract class AggregateRoot implements AggregateRootInterface
{
    /**
     * @var []
     */
    private $uncommittedEvents = [];

    private $playHead = -1;

    /** @var Entity[] */
    private $children = [];

    /**
     * @param Event $event
     */
    public function apply(Event $event)
    {
        $this->handleRecursively($event);

        $this->playHead++;
        $this->uncommittedEvents[] = DomainMessage::recordNow(
            $this->getAggregateRootId(),
            $this->playHead,
            new Metadata(array()),
            $event
        );
    }


    /**
     * Handles event if capable.
     *
     * @param $event
     */
    protected function handle(Event $event)

This method seems to be duplicated in your project.

    {
        $method = $this->getApplyMethod($event);
        if (!method_exists($this, $method)) {
            return;
        }
        $this->$method($event);
    }

    /**
     * @param Event $event
     */
    protected function handleRecursively(Event $event)
    {
        $this->handle($event);

        foreach ($this->children as $child) {
            $child->registerAggregateRoot($this);
            $child->handleRecursively($event);
        }
    }

    /**
     * @param Event $event
     * @return string
     */
    private function getApplyMethod(Event $event)
    {
        $classParts = explode('\\', get_class($event));

        return 'apply' . end($classParts);
    }

    /**
     * @return DomainEventStream
     */
    public function getUncommittedEvents()
    {
        $stream = new DomainEventStream($this->uncommittedEvents);

        $this->uncommittedEvents = [];

        return $stream;
    }

    /**
     * @param DomainEventStream $stream
     */
    public function initializeState(DomainEventStream $stream)
    {
        foreach ($stream as $message) {
            $this->playHead++;
            $this->handle($message->getPayload());
        }
    }

    /**
     * @param Entity $entity
     */
    public function addChildEntity(Entity $entity)
    {
        $this->children[] = $entity;
    }
}