ShadowPageLoader.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\ShadowPage;
 
use MediaWiki\Page\PageReference;
use OutOfBoundsException;
use Wikimedia\ObjectFactory\ObjectFactory;
use Wikimedia\Parsoid\Core\LinkTarget;
 
class ShadowPageLoader {
    public const CORE_SPECS = [
        [
            'namespace' => NS_MEDIAWIKI,
            'class' => MessageProvider::class,
            'services' => [
                'MessageCache',
                'ContentLanguage',
                'SlotRoleRegistry',
                'ContentHandlerFactory',
            ]
        ]
    ];
 
    private const OBJECT_FACTORY_KEYS = [
        'class', 'factory', 'args', 'services', 'optional_services'
    ];
 
    private const CORE = 0;
    private const EXTENSION = 1;
 
    private array $providers = [];
 
    private array $providersForNamespace = [];
 
    private ?PageReference $cachedTitle = null;
    private ?ShadowPage $cachedShadow = null;
    private ?MessageProvider $messageProvider = null;
 
    public function __construct(
        private ObjectFactory $objectFactory,
        private array $coreSpecs,
        private array $extensionSpecs
    ) {
    }
 
    public function get( PageReference $title ): ?ShadowPage {
        if ( $this->cachedTitle && $title->isSamePageAs( $this->cachedTitle ) ) {
            return $this->cachedShadow;
        }
        $this->cachedTitle = $title;
        $this->cachedShadow = $this->maybeCreateShadowPage( $title );
        return $this->cachedShadow;
    }
 
    public function existsForLink( LinkTarget $link ): bool {
        foreach ( $this->getProvidersForNamespace( $link->getNamespace() ) as $provider ) {
            if ( $provider->existsForLink( $link ) ) {
                return true;
            }
        }
        return false;
    }
 
    public function getMessageProvider(): MessageProvider {
        if ( $this->messageProvider === null ) {
            foreach ( $this->getProvidersForNamespace( NS_MEDIAWIKI ) as $provider ) {
                if ( $provider instanceof MessageProvider ) {
                    $this->messageProvider = $provider;
                    break;
                }
            }
        }
        return $this->messageProvider;
    }
 
    public function getExtensionProvider( string $className ): ShadowPageProvider {
        foreach ( $this->extensionSpecs as $index => $spec ) {
            if ( !isset( $spec['class'] ) ) {
                $provider = $this->getProvider( self::EXTENSION, $index, $spec );
                if ( $provider instanceof $className ) {
                    return $provider;
                }
            } elseif ( $spec['class'] === $className ) {
                return $this->getProvider( self::EXTENSION, $index, $spec );
            }
        }
        throw new OutOfBoundsException( 'No such provider class' );
    }
 
    private function maybeCreateShadowPage( PageReference $title ): ?ShadowPage {
        foreach ( $this->getProvidersForNamespace( $title->getNamespace() ) as $provider ) {
            $shadowPage = $provider->get( $title );
            if ( $shadowPage ) {
                return $shadowPage;
            }
        }
        return null;
    }
 
    private function getProvidersForNamespace( int $namespace ): array {
        if ( !isset( $this->providersForNamespace[$namespace] ) ) {
            $providers = [];
            foreach ( $this->coreSpecs as $index => $spec ) {
                if ( !isset( $spec['namespace'] ) || $spec['namespace'] === $namespace ) {
                    $providers[] = $this->getProvider( self::CORE, $index, $spec );
                }
            }
            foreach ( $this->extensionSpecs as $index => $spec ) {
                if ( !isset( $spec['namespace'] ) || $spec['namespace'] === $namespace ) {
                    $providers[] = $this->getProvider( self::EXTENSION, $index, $spec );
                }
            }
            $this->providersForNamespace[$namespace] = $providers;
        }
        return $this->providersForNamespace[$namespace];
    }
 
    private function getProvider( int $origin, int $index, array $spec ): ShadowPageProvider {
        if ( !isset( $this->providers[$origin][$index] ) ) {
            $objSpec = array_intersect_key( $spec,
                array_fill_keys( self::OBJECT_FACTORY_KEYS, true ) );
            $provider = $this->objectFactory->createObject( $objSpec );
            if ( $provider instanceof BaseShadowPageProvider ) {
                $provider->initBaseDeps( new ParseHelper() );
            }
            $this->providers[$origin][$index] = $provider;
        }
        return $this->providers[$origin][$index];
    }
}