HooksRegistrationService.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\HooksRegistrationService\MethodMatcher;
use Elgg\Traits\Loggable;
use Psr\Log\LogLevel;

abstract class HooksRegistrationService {

    use Loggable;
    
    const REG_KEY_PRIORITY = 0;
    const REG_KEY_INDEX = 1;
    const REG_KEY_HANDLER = 2;
    
    const OPTION_DEPRECATION_MESSAGE = 'deprecation_message';
    const OPTION_DEPRECATION_VERSION = 'deprecation_version';

    private $next_index = 0;

    private $registrations = [];

    private $backups = [];

    public function registerHandler($name, $type, $callback, $priority = 500) {
        if (empty($name) || empty($type) || !is_callable($callback, true)) {
            return false;
        }
        
        $services = _elgg_services();
        if (in_array($this->getLogger()->getLevel(false), [LogLevel::WARNING, LogLevel::NOTICE, LogLevel::INFO, LogLevel::DEBUG])) {
            if (!$services->handlers->isCallable($callback)) {
                $this->getLogger()->warning('Handler: ' . $services->handlers->describeCallable($callback) . ' is not callable');
            }
        }
                
        $this->registrations[$name][$type][] = [
            self::REG_KEY_PRIORITY => $priority,
            self::REG_KEY_INDEX => $this->next_index,
            self::REG_KEY_HANDLER => $callback,
        ];
        $this->next_index++;

        return true;
    }
    
    public function unregisterHandler($name, $type, $callback) {
        if (empty($this->registrations[$name][$type])) {
            return false;
        }

        $matcher = $this->getMatcher($callback);

        foreach ($this->registrations[$name][$type] as $i => $registration) {
            if ($matcher) {
                if (!$matcher->matches($registration[self::REG_KEY_HANDLER])) {
                    continue;
                }
            } else {
                if ($registration[self::REG_KEY_HANDLER] != $callback) {
                    continue;
                }
            }

            unset($this->registrations[$name][$type][$i]);
            return true;
        }

        return false;
    }
    
    public function clearHandlers($name, $type) {
        unset($this->registrations[$name][$type]);
    }

    public function getAllHandlers() {
        $ret = [];
        foreach ($this->registrations as $name => $types) {
            foreach ($types as $type => $registrations) {
                foreach ($registrations as $registration) {
                    $priority = $registration[self::REG_KEY_PRIORITY];
                    $handler = $registration[self::REG_KEY_HANDLER];
                    $ret[$name][$type][$priority][] = $handler;
                }
            }
        }

        return $ret;
    }

    public function hasHandler($name, $type) {
        return !empty($this->registrations[$name][$type]);
    }

    public function getOrderedHandlers($name, $type) {
        $registrations = [];
        
        if (!empty($this->registrations[$name][$type])) {
            if ($name !== 'all' && $type !== 'all') {
                array_splice($registrations, count($registrations), 0, $this->registrations[$name][$type]);
            }
        }
        if (!empty($this->registrations['all'][$type])) {
            if ($type !== 'all') {
                array_splice($registrations, count($registrations), 0, $this->registrations['all'][$type]);
            }
        }
        if (!empty($this->registrations[$name]['all'])) {
            if ($name !== 'all') {
                array_splice($registrations, count($registrations), 0, $this->registrations[$name]['all']);
            }
        }
        if (!empty($this->registrations['all']['all'])) {
            array_splice($registrations, count($registrations), 0, $this->registrations['all']['all']);
        }

        usort($registrations, function ($a, $b) {
            // priority first
            if ($a[self::REG_KEY_PRIORITY] < $b[self::REG_KEY_PRIORITY]) {
                return -1;
            }
            if ($a[self::REG_KEY_PRIORITY] > $b[self::REG_KEY_PRIORITY]) {
                return 1;
            }
            // then insertion order
            return ($a[self::REG_KEY_INDEX] < $b[self::REG_KEY_INDEX]) ? -1 : 1;
        });

        $handlers = [];
        foreach ($registrations as $registration) {
            $handlers[] = $registration[self::REG_KEY_HANDLER];
        }

        return $handlers;
    }

    protected function getMatcher($spec) {
        if (is_string($spec) && false !== strpos($spec, '::')) {
            list ($type, $method) = explode('::', $spec, 2);
            return new MethodMatcher($type, $method);
        }

        if (!is_array($spec) || empty($spec[0]) || empty($spec[1]) || !is_string($spec[1])) {
            return null;
        }

        if (is_object($spec[0])) {
            $spec[0] = get_class($spec[0]);
        }

        if (!is_string($spec[0])) {
            return null;
        }

        return new MethodMatcher($spec[0], $spec[1]);
    }

    public function backup() {
        $this->backups[] = $this->registrations;
        $this->registrations = [];
    }

    public function restore() {
        $backup = array_pop($this->backups);
        if (is_array($backup)) {
            $this->registrations = $backup;
        }
    }
    
    protected function checkDeprecation($name, $type, array $options = []) {
        $options = array_merge([
            self::OPTION_DEPRECATION_MESSAGE => '',
            self::OPTION_DEPRECATION_VERSION => '',
        ], $options);
        
        $handlers = $this->hasHandler($name, $type);
        if (!$handlers || !$options[self::OPTION_DEPRECATION_MESSAGE]) {
            return;
        }
        
        $this->logDeprecatedMessage(
            $options[self::OPTION_DEPRECATION_MESSAGE],
            $options[self::OPTION_DEPRECATION_VERSION]
        );
    }
}