SlotRoleRegistry.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Storage\NameTableStore;
use Wikimedia\Assert\Assert;
 
class SlotRoleRegistry {
 
    private NameTableStore $roleNamesStore;
    private array $instantiators = [];
    private array $handlers = [];
 
    public function __construct( NameTableStore $roleNamesStore ) {
        $this->roleNamesStore = $roleNamesStore;
    }
 
    public function defineRole( string $role, callable $instantiator ): void {
        $role = strtolower( $role );
 
        if ( isset( $this->instantiators[$role] ) ) {
            throw new LogicException( "Role $role is already defined" );
        }
 
        $this->instantiators[$role] = $instantiator;
    }
 
    public function defineRoleWithModel(
        string $role,
        string $model,
        array $layout = [],
        bool $derived = false
    ): void {
        $this->defineRole(
            $role,
            static function ( $role ) use ( $model, $layout, $derived ) {
                return new SlotRoleHandler( $role, $model, $layout, $derived );
            }
        );
    }
 
    public function getRoleHandler( string $role ): SlotRoleHandler {
        $role = strtolower( $role );
 
        if ( !isset( $this->handlers[$role] ) ) {
            if ( !isset( $this->instantiators[$role] ) ) {
                if ( $this->isKnownRole( $role ) ) {
                    // The role has no handler defined, but is represented in the database.
                    // This may happen e.g. when the extension that defined the role was uninstalled.
                    wfWarn( __METHOD__ . ": known but undefined slot role $role" );
                    $this->handlers[$role] = new FallbackSlotRoleHandler( $role );
                } else {
                    // The role doesn't have a handler defined, and is not represented in
                    // the database. Something must be quite wrong.
                    throw new InvalidArgumentException( "Unknown role $role" );
                }
            } else {
                $handler = $this->instantiators[$role]( $role );
 
                Assert::postcondition(
                    $handler instanceof SlotRoleHandler,
                    "Instantiator for $role role must return a SlotRoleHandler"
                );
 
                $this->handlers[$role] = $handler;
            }
        }
 
        return $this->handlers[$role];
    }
 
    public function getAllowedRoles( PageIdentity $page ): array {
        // TODO: allow this to be overwritten per namespace (or page type)
        // TODO: decide how to control which slots are offered for editing by default (T209927)
        return $this->getDefinedRoles();
    }
 
    public function getRequiredRoles( PageIdentity $page ): array {
        // TODO: allow this to be overwritten per namespace (or page type)
        return [ SlotRecord::MAIN ];
    }
 
    public function getDefinedRoles(): array {
        return array_keys( $this->instantiators );
    }
 
    public function getKnownRoles(): array {
        return array_unique( array_merge(
            $this->getDefinedRoles(),
            $this->roleNamesStore->getMap()
        ) );
    }
 
    public function isDefinedRole( string $role ): bool {
        $role = strtolower( $role );
        return isset( $this->instantiators[$role] );
    }
 
    public function isKnownRole( string $role ): bool {
        $role = strtolower( $role );
        return in_array( $role, $this->getKnownRoles(), true );
    }
 
}