ResourceLoaderWikiModule.php

Go to the documentation of this file.

<?php
class ResourceLoaderWikiModule extends ResourceLoaderModule {
    protected $position = 'bottom';

    // Origin defaults to users with sitewide authority
    protected $origin = self::ORIGIN_USER_SITEWIDE;

    // In-process cache for title info
    protected $titleInfo = [];

    // List of page names that contain CSS
    protected $styles = [];

    // List of page names that contain JavaScript
    protected $scripts = [];

    // Group of module
    protected $group;

    public function __construct( array $options = null ) {
        if ( is_null( $options ) ) {
            return;
        }

        foreach ( $options as $member => $option ) {
            switch ( $member ) {
                case 'position':
                case 'styles':
                case 'scripts':
                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' ];
            }
        }

        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_SLAVE );
    }

    protected function getContent( $titleText ) {
        $title = Title::newFromText( $titleText );
        if ( !$title ) {
            return null;
        }

        $handler = ContentHandler::getForTitle( $title );
        if ( $handler->isSupportedFormat( CONTENT_FORMAT_CSS ) ) {
            $format = CONTENT_FORMAT_CSS;
        } elseif ( $handler->isSupportedFormat( CONTENT_FORMAT_JAVASCRIPT ) ) {
            $format = CONTENT_FORMAT_JAVASCRIPT;
        } else {
            return null;
        }

        $revision = Revision::newFromTitle( $title, false, Revision::READ_NORMAL );
        if ( !$revision ) {
            return null;
        }

        $content = $revision->getContent( Revision::RAW );

        if ( !$content ) {
            wfDebugLog( 'resourceloader', __METHOD__ . ': failed to load content of JS/CSS page!' );
            return null;
        }

        return $content->serialize( $format );
    }

    public function getScript( ResourceLoaderContext $context ) {
        $scripts = '';
        foreach ( $this->getPages( $context ) as $titleText => $options ) {
            if ( $options['type'] !== 'script' ) {
                continue;
            }
            $script = $this->getContent( $titleText );
            if ( strval( $script ) !== '' ) {
                $script = $this->validateScriptFile( $titleText, $script );
                $scripts .= ResourceLoader::makeComment( $titleText ) . $script . "\n";
            }
        }
        return $scripts;
    }

    public function getStyles( ResourceLoaderContext $context ) {
        $styles = [];
        foreach ( $this->getPages( $context ) as $titleText => $options ) {
            if ( $options['type'] !== 'style' ) {
                continue;
            }
            $media = isset( $options['media'] ) ? $options['media'] : 'all';
            $style = $this->getContent( $titleText );
            if ( strval( $style ) === '' ) {
                continue;
            }
            if ( $this->getFlip( $context ) ) {
                $style = CSSJanus::transform( $style, true, false );
            }
            $style = MemoizedCallable::call( 'CSSMin::remap',
                [ $style, false, $this->getConfig()->get( 'ScriptPath' ), 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 SHA1 of content
            'titleInfo' => $this->getTitleInfo( $context ),
        ];
        return $summary;
    }

    public function isKnownEmpty( ResourceLoaderContext $context ) {
        $revisions = $this->getTitleInfo( $context );

        // For user modules, don't needlessly load if there are no non-empty pages
        if ( $this->getGroup() === 'user' ) {
            foreach ( $revisions as $revision ) {
                if ( $revision['rev_len'] > 0 ) {
                    // At least one non-empty page, module should be loaded
                    return false;
                }
            }
            return true;
        }

        // Bug 68488: For other modules (i.e. ones that are called in cached html output) only check
        // page existance. 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;
    }

    protected function getTitleInfo( ResourceLoaderContext $context ) {
        $dbr = $this->getDB();
        if ( !$dbr ) {
            // We're dealing with a subclass that doesn't have a DB
            return [];
        }

        $pages = $this->getPages( $context );
        $key = implode( '|', array_keys( $pages ) );
        if ( !isset( $this->titleInfo[$key] ) ) {
            $this->titleInfo[$key] = [];
            $batch = new LinkBatch;
            foreach ( $pages as $titleText => $options ) {
                $batch->addObj( Title::newFromText( $titleText ) );
            }

            if ( !$batch->isEmpty() ) {
                $res = $dbr->select( [ 'page', 'revision' ],
                    // Include page_touched to allow purging if cache is poisoned (T117587, T113916)
                    [ 'page_namespace', 'page_title', 'page_touched', 'rev_len', 'rev_sha1' ],
                    $batch->constructSet( 'page', $dbr ),
                    __METHOD__,
                    [],
                    [ 'revision' => [ 'INNER JOIN', [ 'page_latest=rev_id' ] ] ]
                );
                foreach ( $res as $row ) {
                    // Avoid including ids or timestamps of revision/page tables so
                    // that versions are not wasted
                    $title = Title::makeTitle( $row->page_namespace, $row->page_title );
                    $this->titleInfo[$key][$title->getPrefixedText()] = [
                        'rev_len' => $row->rev_len,
                        'rev_sha1' => $row->rev_sha1,
                        'page_touched' => $row->page_touched,
                    ];
                }
            }
        }
        return $this->titleInfo[$key];
    }

    public function getPosition() {
        return $this->position;
    }

    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;
    }
}