Burrow\Handler\HandlerBuilder

Complexity

Total Complexity

9

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	sync()	0	6	1
A	async()	0	6	1
A	doNotRequeueOnFailure()	0	6	1
A	continueOnFailure()	0	6	1
A	log()	0	6	1
A	build()	0	19	3

<?php

namespace Burrow\Handler;

use Assert\Assertion;
use Burrow\Driver;
use Burrow\QueueConsumer;
use Burrow\QueueHandler;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

class HandlerBuilder
{
    /** @var Driver */
    private $driver;

    /** @var bool */
    private $sync;

    /** @var bool */
    private $requeueOnFailure;

    /** @var bool */
    private $stopOnFailure;

    /** @var LoggerInterface */
    private $logger;

    /**
     * HandlerBuilder constructor.
     *
     * @param Driver $driver
     */
    public function __construct(Driver $driver)
    {
        $this->driver = $driver;
        $this->consumer = null;

The property consumer does not exist. Did you maybe forget to declare it?

        $this->sync = null;
        $this->requeueOnFailure = true;
        $this->stopOnFailure = true;

        $this->logger = new NullLogger();
    }

    /**
     * Build a sync Handler.
     *
     * @return $this
     */
    public function sync()
    {
        $this->sync = true;

        return $this;
    }

    /**
     * Build an async Handler.
     *
     * @return $this
     */
    public function async()
    {
        $this->sync = false;

        return $this;
    }

    /**
     * Must the failed message be requeued.
     *
     * @return $this
     */
    public function doNotRequeueOnFailure()
    {
        $this->requeueOnFailure = false;

        return $this;
    }

    /**
     * Must the handler continue on failure
     *
     * @return $this
     */
    public function continueOnFailure()
    {
        $this->stopOnFailure = false;

        return $this;
    }

    /**
     * Set a logger.
     *
     * @param LoggerInterface $logger
     *
     * @return $this
     */
    public function log(LoggerInterface $logger)
    {
        $this->logger = $logger;

        return $this;
    }

    /**
     * Build the Handler.
     *
     * @param QueueConsumer $consumer
     *
     * @return QueueHandler
     */
    public function build(QueueConsumer $consumer)
    {
        Assertion::notNull($this->sync, 'You must specify if the handler must be sync or async');

        $syncAsync = ($this->sync) ?
            new SyncConsumerHandler($consumer, $this->driver) :
            new AsyncConsumerHandler($consumer);

        $ackHandler = new AckHandler($syncAsync, $this->driver, $this->requeueOnFailure);

        $handler = ($this->stopOnFailure) ?
            new StopOnExceptionHandler($ackHandler) :
            new ContinueOnExceptionHandler($ackHandler);

        $syncAsync->setLogger($this->logger);
        $handler->setLogger($this->logger);

        return $handler;
    }
}