ResourceLoaderWikiModule.php

Go to the documentation of this file.

<?php
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use Wikimedia\Minify\CSSMin;
use Wikimedia\Rdbms\Database;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Timestamp\ConvertibleTimestamp;
 
class ResourceLoaderWikiModule extends ResourceLoaderModule {
    protected $origin = self::ORIGIN_USER_SITEWIDE;
 
    protected $titleInfo = [];
 
    protected $styles = [];
 
    protected $scripts = [];
 
    protected $datas = [];
 
    protected $group;
 
    public function __construct( array $options = null ) {
        if ( $options === null ) {
            return;
        }
 
        foreach ( $options as $member => $option ) {
            switch ( $member ) {
                case 'styles':
                case 'scripts':
                case 'datas':
                case 'group':
                case 'targets':
                    $this->{$member} = $option;
                    break;
            }
        }
    }
 
    protected function getPages( ResourceLoaderContext $context ) {
        $config = $this->getConfig();
        $pages = [];
 
        // Filter out pages from origins not allowed by the current wiki configuration.
        if ( $config->get( 'UseSiteJs' ) ) {
            foreach ( $this->scripts as $script ) {
                $pages[$script] = [ 'type' => 'script' ];
            }
            foreach ( $this->datas as $data ) {
                $pages[$data] = [ 'type' => 'data' ];
            }
        }
 
        if ( $config->get( 'UseSiteCss' ) ) {
            foreach ( $this->styles as $style ) {
                $pages[$style] = [ 'type' => 'style' ];
            }
        }
 
        return $pages;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    protected function getDB() {
        return wfGetDB( DB_REPLICA );
    }
 
    protected function getContent( $titleText, ResourceLoaderContext $context ) {
        $pageStore = MediaWikiServices::getInstance()->getPageStore();
        $title = $pageStore->getPageByText( $titleText );
        if ( !$title ) {
            return null; // Bad title
        }
 
        $content = $this->getContentObj( $title, $context );
        if ( !$content ) {
            return null; // No content found
        }
 
        $handler = $content->getContentHandler();
        if ( $handler->isSupportedFormat( CONTENT_FORMAT_CSS ) ) {
            $format = CONTENT_FORMAT_CSS;
        } elseif ( $handler->isSupportedFormat( CONTENT_FORMAT_JAVASCRIPT ) ) {
            $format = CONTENT_FORMAT_JAVASCRIPT;
        } elseif ( $handler->isSupportedFormat( CONTENT_FORMAT_JSON ) ) {
            $format = CONTENT_FORMAT_JSON;
        } else {
            return null; // Bad content model
        }
 
        return $content->serialize( $format );
    }
 
    protected function getContentObj(
        PageIdentity $page, ResourceLoaderContext $context, $maxRedirects = null
    ) {
        $overrideCallback = $context->getContentOverrideCallback();
        $content = $overrideCallback ? call_user_func( $overrideCallback, $page ) : null;
        if ( $content ) {
            if ( !$content instanceof Content ) {
                $this->getLogger()->error(
                    'Bad content override for "{title}" in ' . __METHOD__,
                    [ 'title' => (string)$page ]
                );
                return null;
            }
        } else {
            $revision = MediaWikiServices::getInstance()
                ->getRevisionLookup()
                ->getKnownCurrentRevision( $page );
            if ( !$revision ) {
                return null;
            }
            $content = $revision->getContent( SlotRecord::MAIN, RevisionRecord::RAW );
 
            if ( !$content ) {
                $this->getLogger()->error(
                    'Failed to load content of CSS/JS/JSON page "{title}" in ' . __METHOD__,
                    [ 'title' => (string)$page ]
                );
                return null;
            }
        }
 
        if ( $content->isRedirect() ) {
            if ( $maxRedirects === null ) {
                $maxRedirects = $this->getConfig()->get( 'MaxRedirects' ) ?: 0;
            }
            if ( $maxRedirects > 0 ) {
                $newTitle = $content->getRedirectTarget();
                return $newTitle ? $this->getContentObj( $newTitle, $context, $maxRedirects - 1 ) : null;
            }
        }
 
        return $content;
    }
 
    public function shouldEmbedModule( ResourceLoaderContext $context ) {
        $overrideCallback = $context->getContentOverrideCallback();
        if ( $overrideCallback && $this->getSource() === 'local' ) {
            foreach ( $this->getPages( $context ) as $page => $info ) {
                $title = Title::newFromText( $page );
                if ( $title && call_user_func( $overrideCallback, $title ) !== null ) {
                    return true;
                }
            }
        }
 
        return parent::shouldEmbedModule( $context );
    }
 
    public function getScript( ResourceLoaderContext $context ) {
        if ( $this->isPackaged() ) {
            return $this->getPackageFiles( $context );
        } else {
            $scripts = '';
            foreach ( $this->getPages( $context ) as $titleText => $options ) {
                if ( $options['type'] !== 'script' ) {
                    continue;
                }
                $script = $this->getContent( $titleText, $context );
                if ( strval( $script ) !== '' ) {
                    $script = $this->validateScriptFile( $titleText, $script );
                    $scripts .= ResourceLoader::makeComment( $titleText ) . $script . "\n";
                }
            }
            return $scripts;
        }
    }
 
    protected function isPackaged(): bool {
        // Packaged mode is disabled by default for backwards compatibility.
        // Subclasses may opt-in to this feature.
        return false;
    }
 
    public function supportsURLLoading() {
        // If package files are involved, don't support URL loading
        return !$this->isPackaged();
    }
 
    protected function getRequireKey( string $titleText ): string {
        return $titleText;
    }
 
    private function getPackageFiles( ResourceLoaderContext $context ): array {
        $main = null;
 
        $files = [];
        foreach ( $this->getPages( $context ) as $titleText => $options ) {
            if ( $options['type'] !== 'script' && $options['type'] !== 'data' ) {
                continue;
            }
            $content = $this->getContent( $titleText, $context );
            if ( strval( $content ) !== '' ) {
                $fileKey = $this->getRequireKey( $titleText );
                if ( $options['type'] === 'script' ) {
                    $script = $this->validateScriptFile( $titleText, $content );
                    $files[$fileKey] = [
                        'type' => 'script',
                        'content' => $script,
                    ];
                    // First script becomes the "main" script
                    if ( $main === null ) {
                        $main = $fileKey;
                    }
                } elseif ( $options['type'] === 'data' ) {
                    $data = FormatJson::decode( $content );
                    if ( $data == null ) {
                        // This is unlikely to happen since we only load JSON from
                        // wiki pages with a JSON content model, which are validated
                        // during edit save.
                        $data = [ 'error' => 'Invalid JSON' ];
                    }
                    $files[$fileKey] = [
                        'type' => 'data',
                        'content' => $data,
                    ];
                }
            }
        }
 
        return [
            'main' => $main,
            'files' => $files,
        ];
    }
 
    public function getStyles( ResourceLoaderContext $context ) {
        $styles = [];
        foreach ( $this->getPages( $context ) as $titleText => $options ) {
            if ( $options['type'] !== 'style' ) {
                continue;
            }
            $media = $options['media'] ?? 'all';
            $style = $this->getContent( $titleText, $context );
            if ( strval( $style ) === '' ) {
                continue;
            }
            if ( $this->getFlip( $context ) ) {
                $style = CSSJanus::transform( $style, true, false );
            }
            $remoteDir = $this->getConfig()->get( 'ScriptPath' );
            if ( $remoteDir === '' ) {
                // When the site is configured with the script path at the
                // document root, MediaWiki uses an empty string but that is
                // not a valid URI path. Expand to a slash to avoid fatals
                // later in CSSMin::resolveUrl().
                // See also ResourceLoaderFilePath::extractBasePaths, T282280.
                $remoteDir = '/';
            }
 
            $style = MemoizedCallable::call(
                [ CSSMin::class, 'remap' ],
                [ $style, false, $remoteDir, true ]
            );
            if ( !isset( $styles[$media] ) ) {
                $styles[$media] = [];
            }
            $style = ResourceLoader::makeComment( $titleText ) . $style;
            $styles[$media][] = $style;
        }
        return $styles;
    }
 
    public function enableModuleContentVersion() {
        return false;
    }
 
    public function getDefinitionSummary( ResourceLoaderContext $context ) {
        $summary = parent::getDefinitionSummary( $context );
        $summary[] = [
            'pages' => $this->getPages( $context ),
            // Includes meta data of current revisions
            'titleInfo' => $this->getTitleInfo( $context ),
        ];
        return $summary;
    }
 
    public function isKnownEmpty( ResourceLoaderContext $context ) {
        $revisions = $this->getTitleInfo( $context );
 
        // If a module has dependencies it cannot be empty. An empty array will be cast to false
        if ( $this->getDependencies() ) {
            return false;
        }
        // For user modules, don't needlessly load if there are no non-empty pages
        if ( $this->getGroup() === self::GROUP_USER ) {
            foreach ( $revisions as $revision ) {
                if ( $revision['page_len'] > 0 ) {
                    // At least one non-empty page, module should be loaded
                    return false;
                }
            }
            return true;
        }
 
        // T70488: For other modules (i.e. ones that are called in cached html output) only check
        // page existence. This ensures that, if some pages in a module are temporarily blanked,
        // we don't end omit the module's script or link tag on some pages.
        return count( $revisions ) === 0;
    }
 
    private function setTitleInfo( $batchKey, array $titleInfo ) {
        $this->titleInfo[$batchKey] = $titleInfo;
    }
 
    private static function makeTitleKey( LinkTarget $title ) {
        // Used for keys in titleInfo.
        return "{$title->getNamespace()}:{$title->getDBkey()}";
    }
 
    protected function getTitleInfo( ResourceLoaderContext $context ) {
        $dbr = $this->getDB();
 
        $pageNames = array_keys( $this->getPages( $context ) );
        sort( $pageNames );
        $batchKey = implode( '|', $pageNames );
        if ( !isset( $this->titleInfo[$batchKey] ) ) {
            $this->titleInfo[$batchKey] = static::fetchTitleInfo( $dbr, $pageNames, __METHOD__ );
        }
 
        $titleInfo = $this->titleInfo[$batchKey];
 
        // Override the title info from the overrides, if any
        $overrideCallback = $context->getContentOverrideCallback();
        if ( $overrideCallback ) {
            foreach ( $pageNames as $page ) {
                $title = Title::newFromText( $page );
                $content = $title ? call_user_func( $overrideCallback, $title ) : null;
                if ( $content !== null ) {
                    $titleInfo[$title->getPrefixedText()] = [
                        'page_len' => $content->getSize(),
                        'page_latest' => 'TBD', // None available
                        'page_touched' => ConvertibleTimestamp::now( TS_MW ),
                    ];
                }
            }
        }
 
        return $titleInfo;
    }
 
    protected static function fetchTitleInfo( IDatabase $db, array $pages, $fname = __METHOD__ ) {
        $titleInfo = [];
        $linkBatchFactory = MediaWikiServices::getInstance()->getLinkBatchFactory();
        $batch = $linkBatchFactory->newLinkBatch();
        foreach ( $pages as $titleText ) {
            $title = Title::newFromText( $titleText );
            if ( $title ) {
                // Page name may be invalid if user-provided (e.g. gadgets)
                $batch->addObj( $title );
            }
        }
        if ( !$batch->isEmpty() ) {
            $res = $db->select( 'page',
                // Include page_touched to allow purging if cache is poisoned (T117587, T113916)
                [ 'page_namespace', 'page_title', 'page_touched', 'page_len', 'page_latest' ],
                $batch->constructSet( 'page', $db ),
                $fname
            );
            foreach ( $res as $row ) {
                // Avoid including ids or timestamps of revision/page tables so
                // that versions are not wasted
                $title = new TitleValue( (int)$row->page_namespace, $row->page_title );
                $titleInfo[self::makeTitleKey( $title )] = [
                    'page_len' => $row->page_len,
                    'page_latest' => $row->page_latest,
                    'page_touched' => $row->page_touched,
                ];
            }
        }
        return $titleInfo;
    }
 
    public static function preloadTitleInfo(
        ResourceLoaderContext $context, IDatabase $db, array $moduleNames
    ) {
        $rl = $context->getResourceLoader();
        // getDB() can be overridden to point to a foreign database.
        // For now, only preload local. In the future, we could preload by wikiID.
        $allPages = [];
        $wikiModules = [];
        foreach ( $moduleNames as $name ) {
            $module = $rl->getModule( $name );
            if ( $module instanceof self ) {
                $mDB = $module->getDB();
                // Subclasses may implement getDB differently
                if ( $mDB->getDomainID() === $db->getDomainID() ) {
                    $wikiModules[] = $module;
                    $allPages += $module->getPages( $context );
                }
            }
        }
 
        if ( !$wikiModules ) {
            // Nothing to preload
            return;
        }
 
        $pageNames = array_keys( $allPages );
        sort( $pageNames );
        $hash = sha1( implode( '|', $pageNames ) );
 
        // Avoid Zend bug where "static::" does not apply LSB in the closure
        $func = [ static::class, 'fetchTitleInfo' ];
        $fname = __METHOD__;
 
        $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
        $allInfo = $cache->getWithSetCallback(
            $cache->makeGlobalKey( 'resourceloader-titleinfo', $db->getDomainID(), $hash ),
            $cache::TTL_HOUR,
            static function ( $curVal, &$ttl, array &$setOpts ) use ( $func, $pageNames, $db, $fname ) {
                $setOpts += Database::getCacheSetOptions( $db );
 
                return call_user_func( $func, $db, $pageNames, $fname );
            },
            [
                'checkKeys' => [
                    $cache->makeGlobalKey( 'resourceloader-titleinfo', $db->getDomainID() ) ]
            ]
        );
 
        foreach ( $wikiModules as $wikiModule ) {
            $pages = $wikiModule->getPages( $context );
            // Before we intersect, map the names to canonical form (T145673).
            $intersect = [];
            foreach ( $pages as $pageName => $unused ) {
                $title = Title::newFromText( $pageName );
                if ( $title ) {
                    $intersect[ self::makeTitleKey( $title ) ] = 1;
                } else {
                    // Page name may be invalid if user-provided (e.g. gadgets)
                    $rl->getLogger()->info(
                        'Invalid wiki page title "{title}" in ' . __METHOD__,
                        [ 'title' => $pageName ]
                    );
                }
            }
            $info = array_intersect_key( $allInfo, $intersect );
            $pageNames = array_keys( $pages );
            sort( $pageNames );
            $batchKey = implode( '|', $pageNames );
            $wikiModule->setTitleInfo( $batchKey, $info );
        }
    }
 
    public static function invalidateModuleCache(
        PageIdentity $page,
        ?RevisionRecord $old,
        ?RevisionRecord $new,
        string $domain
    ) {
        static $models = [ CONTENT_MODEL_CSS, CONTENT_MODEL_JAVASCRIPT ];
 
        $purge = false;
        // TODO: MCR: differentiate between page functionality and content model!
        //       Not all pages containing CSS or JS have to be modules! [PageType]
        if ( $old ) {
            $oldModel = $old->getSlot( SlotRecord::MAIN, RevisionRecord::RAW )->getModel();
            if ( in_array( $oldModel, $models ) ) {
                $purge = true;
            }
        }
 
        if ( !$purge && $new ) {
            $newModel = $new->getSlot( SlotRecord::MAIN, RevisionRecord::RAW )->getModel();
            if ( in_array( $newModel, $models ) ) {
                $purge = true;
            }
        }
 
        if ( !$purge ) {
            $title = Title::castFromPageIdentity( $page );
            $purge = ( $title->isSiteConfigPage() || $title->isUserConfigPage() );
        }
 
        if ( $purge ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
            $key = $cache->makeGlobalKey( 'resourceloader-titleinfo', $domain );
            $cache->touchCheckKey( $key );
        }
    }
 
    public function getType() {
        // Check both because subclasses don't always pass pages via the constructor,
        // they may also override getPages() instead, in which case we should keep
        // defaulting to LOAD_GENERAL and allow them to override getType() separately.
        return ( $this->styles && !$this->scripts ) ? self::LOAD_STYLES : self::LOAD_GENERAL;
    }
}