Bernard\Queue\SyncQueue

Complexity

Total Complexity

6

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	enqueue()	0	21	2
A	dequeue()	0	7	1
A	peek()	0	7	1
A	count()	0	7	1

<?php

namespace Bernard\Queue;

use Bernard\BernardEvents;
use Bernard\Envelope;
use Bernard\Event\EnvelopeEvent;
use Bernard\Event\PingEvent;
use Bernard\Event\RejectEnvelopeEvent;
use Bernard\Exception\InvalidOperationException;
use Bernard\Router;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class SyncQueue extends AbstractQueue
{
    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * @var Router
     */
    protected $router;

    public function __construct($name, EventDispatcherInterface $dispatcher, Router $router)
    {
        parent::__construct($name);
        $this->dispatcher = $dispatcher;
        $this->router = $router;
    }

    /**
     * Copy-pasted from Consumer::invoke() and modified
     * @param Envelope $envelope
     * @throws \Exception
     * @throws \Throwable
     */
    public function enqueue(Envelope $envelope)
    {
        $this->errorIfClosed();

        $queue = $this;
        try {
            $this->dispatcher->dispatch(BernardEvents::PING, new PingEvent($queue));
            $this->dispatcher->dispatch(BernardEvents::INVOKE, new EnvelopeEvent($envelope, $queue));

            // for 5.3 support where a function name is not a callable
            call_user_func($this->router->map($envelope), $envelope->getMessage());

            // We successfully processed the message.
            $queue->acknowledge($envelope);

            $this->dispatcher->dispatch(BernardEvents::ACKNOWLEDGE, new EnvelopeEvent($envelope, $queue));
        } catch (\Throwable $e) {

The class Throwable does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $this->dispatcher->dispatch(BernardEvents::REJECT, new RejectEnvelopeEvent($envelope, $queue, $e));
            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function dequeue()
    {
        $this->errorIfClosed();

        // Sync queue is always empty
        return;
    }

    /**
     * {@inheritdoc}
     */
    public function peek($index = 0, $limit = 20)
    {
        $this->errorIfClosed();

        // Sync queue is always empty
        return [];
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        $this->errorIfClosed();

        // Sync queue is always empty
        return 0;
    }

}