README

Nexus

psr-14 event dispatcher implementation

(honoring psr-12)

Install

In most cases it should suffice to just install it via composer.

composer require scones/nexus "*@stable"

Usage

These exmaples are taken from the tests, so there is of course a bit of redundancy.

Messages

The usage is quite basic.

You define a Message class.
You provide a callable listener with one argument, which has to match the Message Type it should listen on.
You call the notfier with an instance of the Message you wish to propagate

use Psr\EventDispatcher\MessageInterface;
use Nexus\StandardListenerProvider;
use Nexus\SynchronousNotifier;

class SomeMessage implements MessageInterface
{
}

class SomeOtherMessage implements MessageInterface
{
}

$provider = new StandardListenerProvider();
$notifier = new SynchronousNotifier($provider);

$provider->addListener(function (SomeMessage $someMessage) {
    echo "some cool message reaction code goes here\n";
});
$provider->addListener(function (SomeMessage $someMessage) {
    echo "this message seems worth logging!\n";
});
$provider->addListener(function (SomeOtherMessage $someOtherMessage) {
    echo "oh, the other message was dispatched!\n";
});

$testMessage = new SomeMessage();
$notifier->notify($testMessage);

which would of course result in:

some cool message reaction code goes here
this message seems worth logging!

Tasks

Again the usage is quite simplistic.

You define a Task class.
You provide a callable listener with one argument, which has to match the Task Type it should listen on.
You call the processor with an instance of the Task you wish to propagate
After all Tasks have processed, the resulting modified task instance is returned.

use Nexus\StandardListenerProvider;
use Nexus\SynchronousProcessor;
use Psr\EventDispatcher\TaskInterface;

class SomeTask implements TaskInterface
{
    private $accessCounter = 0;

    public function increaseCounter(): void
    {
        $this->accessCounter++;
    }

    public function getCounter(): int
    {
        return $this->accessCounter;
    }
}

class SomeOtherTask implements TaskInterface
{
}

$provider = new StandardListenerProvider();
$processor = new SynchronousProcessor($provider);

$provider->addListener(function (SomeTask $someTask) {
    echo "some task working!\n";
    $someTask->increaseCounter();
    return $someTask;
});
$provider->addListener(function (SomeTask $someTask) {
    echo "some task working again!\n";
    $someTask->increaseCounter();
    $someTask->increaseCounter();
    return $someTask;
});
$provider->addListener(function (SomeOtherTask $someOtherTask) {
    echo "the other Task!";
    return $someOtherTask;
});

$testTask = new SomeTask();
$testTaskResult = $processor->process($testTask);

echo "task result was: {$testTaskResult->getCounter()}\n";