Arp\EventDispatcher\Listener\LazyListenerConfig

Complexity

Total Complexity

9

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	getListener()	0	28	4
A	__construct()	0	25	5

<?php

declare(strict_types=1);

namespace Arp\EventDispatcher\Listener;

use Arp\EventDispatcher\Listener\Exception\EventListenerException;
use Arp\Factory\Exception\FactoryException;
use Arp\Factory\FactoryInterface;

/**
 * @author  Alex Patterson <alex.patterson.webdev@gmail.com>
 * @package Arp\EventDispatcher\Listener
 */
final class LazyListenerConfig extends ListenerConfig
{
    /**
     * @var string|callable|FactoryInterface
     */
    private $factory;

    /**
     * @var array
     */
    private $options;

    /**
     * @param FactoryInterface|string $factory
     * @param string                  $eventName
     * @param int                     $priority
     * @param array                   $options
     *
     * @throws EventListenerException
     */
    public function __construct($factory, string $eventName, int $priority = 1, array $options = [])
    {
        if (
            is_callable($factory)
            && !$factory instanceof FactoryInterface
            && !is_a($factory, FactoryInterface::class, true)
        ) {
            throw new EventListenerException(
                sprintf(
                    'The \'listener\' argument must be a \'string\', \'callable\' or an object of type \'%s\'; '
                    . '\'%s\' provided in \'%s\'',
                    FactoryInterface::class,
                    is_object($factory) ? get_class($factory) : gettype($factory),

The condition is_object($factory) is always false.

                    static::class
                )
            );
        }

        $this->factory = $factory;
        $this->options = $options;

        $listener = static function () {
        };

        parent::__construct($listener, $eventName, $priority);

$listener of type callable is incompatible with the type string expected by parameter $eventName of Arp\EventDispatcher\Listener\ListenerConfig::__construct().

    }

    /**
     * @return callable
     *
     * @throws EventListenerException
     */
    public function getListener(): callable
    {
        $listener = new LazyListener();

The call to Arp\EventDispatcher\Listener\LazyListener::__construct() has too few arguments starting with factory.

The assignment to $listener is dead and can be removed.

        $listener = $this->listener;
        $factory = $this->factory;

        try {
            if (is_string($factory)) {
                $this->factory = $factory = new $factory();
            }

            if ($factory instanceof FactoryInterface) {
                $this->listener = $listener = $factory->create($this->options);
            }
        } catch (FactoryException $e) {
            throw new EventListenerException(
                sprintf(
                    'Failed to lazy load the event listener from factory class \'%s\': %s',
                    get_class($factory),

It seems like $factory can also be of type callable; however, parameter $object of get_class() does only seem to accept object, maybe add an additional type check?

                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        }

        return $listener;
    }
}