EventyClassic\Event

Complexity

Total Complexity

20

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	listen()	0	10	1
A	remove()	0	13	6
A	removeAll()	0	13	5
A	getFunction()	0	7	2
A	getListeners()	0	32	5

<?php

namespace EventyClassic;

abstract class Event
{
    /**
     * Holds the event listeners.
     *
     * @var array
     */
    protected $listeners = null;

    public function __construct()
    {
        $this->listeners = [];
    }

    /**
     * Adds a listener.
     *
     * @param string  $hook      Hook name.
     * @param mixed   $callback  Function to execute.
     * @param integer $priority  Priority of the action.
     * @param integer $arguments Number of arguments to accept.
     *
     * @return Event
     */
    public function listen($hook, $callback, $priority = 20, $arguments = 1)
    {
        $this->listeners[] = [
            'hook'      => $hook,
            'callback'  => $callback,
            'priority'  => $priority,
            'arguments' => $arguments,
        ];

        return $this;
    }

    /**
     * Removes a listener.
     *
     * @param string $hook     Hook name.
     * @param mixed  $callback Function to execute.
     * @param int    $priority Priority of the action.
     */
    public function remove($hook, $callback, $priority = 20)
    {
        if ($this->listeners) {

The expression $this->listeners of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $listeners = $this->listeners;
            foreach ($this->listeners as $key => $value) {
                if ($value['hook'] == $hook &&
                    $value['callback'] == $callback &&
                    $value['priority'] == $priority
                ) {
                    unset($listeners[$key]);
                }
            }
            $this->listeners = $listeners;
        }
    }

    /**
     * Remove all listeners with given hook in collection. If no hook, clear all listeners.
     *
     * @param string $hook Hook name
     */
    public function removeAll($hook = null)
    {
        if ($this->listeners) {

The expression $this->listeners of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            if ($hook) {
                $listeners = $this->listeners;
                foreach ($this->listeners as $key => $value) {
                    if ($value['hook'] == $hook) {
                        unset($listeners[$key]);
                    }
                }
                $this->listeners = $listeners;
            } else {
                $this->listeners = [];
            }
        }
    }

    /**
     * Gets a sorted list of all listeners.
     *
     * @return array
     */
    public function getListeners()
    {
        $listeners = $this->listeners;

        if (count($listeners) == 0) {
            return [];
        }

        reset($listeners);
        $key = key($listeners);

        $same = true;
        $previous = $listeners[$key];
        foreach ($listeners as $listener) {
            if ($previous['priority'] != $listener['priority']) {
                $same = false;
                break;
            }
        }

        if ($same) {
            return $listeners;
        }

        usort(
            $listeners,
            function ($a, $b) {
                return ($a['priority'] - $b['priority']);
            }
        );

        return $listeners;
    }

    /**
     * Gets the function.
     *
     * @param mixed $callback Callback
     *
     * @return callable A closure
     *
     * @throws \Exception
     */
    protected function getFunction($callback)
    {
        if (is_callable($callback)) {
            return $callback;
        }

        throw new \Exception('$callback is not a Callable', 1);
    }

    /**
     * Fires a new action.
     *
     * @param string $action Name of action
     * @param array  $args   Arguments passed to the action
     */
    abstract public function fire($action, $args);
}