PHPDaemon\Traits\EventHandlers

Complexity

Total Complexity

27

Size/Duplication

Total Lines	172
Duplicated Lines	17.44 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	event()	15	15	5
A	trigger()	15	15	5
A	triggerAndCount()	0	16	5
A	getLastEventName()	0	4	1
A	on()	0	4	1
A	off()	0	4	1
A	cleanupEventHandlers()	0	5	1
A	bind()	0	11	3
A	unbind()	0	20	5

<?php
namespace PHPDaemon\Traits;

use PHPDaemon\Core\CallbackWrapper;

/**
 * Event handlers trait
 * @package PHPDaemon\Traits
 * @author  Vasily Zorin <maintainer@daemon.io>
 */
trait EventHandlers
{
    /**
     * @var array Event handlers
     */
    protected $eventHandlers = [];

    /**
     * @var boolean Unshift $this to arguments of callback?
     */
    protected $addThisToEvents = true;

    /**
     * @var string Last called event name
     */
    protected $lastEventName;

    /**
     * Propagate event
     * @param  string $name Event name
     * @param  mixed ...$args Arguments
     * @return this

Should the return type not be EventHandlers?

     */
    public function event($name, ...$args)

This method seems to be duplicated in your project.

    {
        if ($this->addThisToEvents) {
            array_unshift($args, $this);
        }
        if (isset($this->eventHandlers[$name])) {
            $this->lastEventName = $name;
            foreach ($this->eventHandlers[$name] as $cb) {
                if ($cb(...$args) === true) {
                    return $this;
                }
            }
        }
        return $this;
    }

    /**
     * Propagate event
     * @param  string $name Event name
     * @param  mixed ...$args Arguments
     * @return this

Should the return type not be EventHandlers?

     */
    public function trigger($name, ...$args)

This method seems to be duplicated in your project.

    {
        if ($this->addThisToEvents) {
            array_unshift($args, $this);
        }
        if (isset($this->eventHandlers[$name])) {
            $this->lastEventName = $name;
            foreach ($this->eventHandlers[$name] as $cb) {
                if ($cb(...$args) === true) {
                    return $this;
                }
            }
        }
        return $this;
    }

    /**
     * Propagate event
     * @param  string $name Event name
     * @param  mixed ...$args Arguments
     * @return integer
     */
    public function triggerAndCount($name, ...$args)
    {
        if ($this->addThisToEvents) {
            array_unshift($args, $this);
        }
        $cnt = 0;
        if (isset($this->eventHandlers[$name])) {
            $this->lastEventName = $name;
            foreach ($this->eventHandlers[$name] as $cb) {
                if ($cb(...$args) !== 0) {
                    ++$cnt;
                }
            }
        }
        return $cnt;
    }

    /**
     * Use it to define event name, when one callback was bind to more than one events
     * @return string
     */
    public function getLastEventName()
    {
        return $this->lastEventName;
    }

    /**
     * Bind event or events
     * @alias EventHandlers::bind
     * @param string|array $event Event name
     * @param callable $cb Callback
     * @return this

Should the return type not be EventHandlers?

     */
    public function on($event, $cb)
    {
        return $this->bind($event, $cb);
    }

    /**
     * Bind event or events
     * @param string|array $event Event name
     * @param callable $cb Callback
     * @return this

Should the return type not be EventHandlers?

     */
    public function bind($event, $cb)
    {
        if ($cb !== null) {
            $cb = CallbackWrapper::wrap($cb);
        }
        $event = (array) $event;
        foreach ($event as $e) {
            CallbackWrapper::addToArray($this->eventHandlers[$e], $cb);
        }
        return $this;
    }

    /**
     * Unbind event(s) or callback from event(s)
     * @alias EventHandlers::unbind
     * @param string|array $event Event name
     * @param callable $cb Callback, optional

Should the type for parameter $cb not be callable|null?

     * @return this

Should the return type not be EventHandlers?

     */
    public function off($event, $cb = null)
    {
        return $this->unbind($event, $cb);
    }

    /**
     * Unbind event(s) or callback from event(s)
     * @param string|array $event Event name
     * @param callable $cb Callback, optional

Should the type for parameter $cb not be callable|null?

     * @return this

Should the return type not be EventHandlers?

     */
    public function unbind($event, $cb = null)
    {
        if ($cb !== null) {
            $cb = CallbackWrapper::wrap($cb);
        }
        $event = (array) $event;
        $success = true;

$success is not used, you could remove the assignment.

        foreach ($event as $e) {
            if (!isset($this->eventHandlers[$e])) {
                $success = false;

$success is not used, you could remove the assignment.

                continue;
            }
            if ($cb === null) {
                unset($this->eventHandlers[$e]);
                continue;
            }
            CallbackWrapper::removeFromArray($this->eventHandlers[$e], $cb);
        }
        return $this;
    }

    /**
     * Clean up all events
     * @return void
     */
    protected function cleanupEventHandlers()
    {
        $this->eventHandlers = [];
        //Daemon::log('clean up event handlers '.get_class($this). ' -- '.$this->attrs->server['REQUEST_URI']. PHP_EOL .Debug::backtrace());
    }
}