CategoryTreeHooks.php

Go to the documentation of this file.

<?php
class CategoryTreeHooks {
 
    public static function shouldForceHeaders() {
        global $wgCategoryTreeSidebarRoot, $wgCategoryTreeHijackPageCategories,
            $wgCategoryTreeForceHeaders;
        return $wgCategoryTreeForceHeaders || $wgCategoryTreeSidebarRoot
            || $wgCategoryTreeHijackPageCategories;
    }
 
    public static function initialize() {
        global $wgRequest;
        global $wgCategoryTreeDefaultOptions, $wgCategoryTreeDefaultMode;
        global $wgCategoryTreeCategoryPageOptions, $wgCategoryTreeCategoryPageMode;
        global $wgCategoryTreeOmitNamespace;
 
        if ( !isset( $wgCategoryTreeDefaultOptions['mode'] )
            || is_null( $wgCategoryTreeDefaultOptions['mode'] )
        ) {
            $wgCategoryTreeDefaultOptions['mode'] = $wgCategoryTreeDefaultMode;
        }
 
        if ( !isset( $wgCategoryTreeDefaultOptions['hideprefix'] )
            || is_null( $wgCategoryTreeDefaultOptions['hideprefix'] )
        ) {
            $wgCategoryTreeDefaultOptions['hideprefix'] = $wgCategoryTreeOmitNamespace;
        }
 
        if ( !isset( $wgCategoryTreeCategoryPageOptions['mode'] )
            || is_null( $wgCategoryTreeCategoryPageOptions['mode'] )
        ) {
            $mode = $wgRequest->getVal( 'mode' );
            $wgCategoryTreeCategoryPageOptions['mode'] = ( $mode )
                ? CategoryTree::decodeMode( $mode ) : $wgCategoryTreeCategoryPageMode;
        }
    }
 
    public static function setHooks( $parser ) {
        global $wgCategoryTreeAllowTag;
        if ( !$wgCategoryTreeAllowTag ) {
            return;
        }
        $parser->setHook( 'categorytree', 'CategoryTreeHooks::parserHook' );
        $parser->setFunctionHook( 'categorytree', 'CategoryTreeHooks::parserFunction' );
    }
 
    public static function parserFunction( $parser ) {
        $params = func_get_args();
        array_shift( $params ); // first is $parser, strip it
 
        // first user-supplied parameter must be category name
        if ( !$params ) {
            return ''; // no category specified, return nothing
        }
        $cat = array_shift( $params );
 
        // build associative arguments from flat parameter list
        $argv = [];
        foreach ( $params as $p ) {
            if ( preg_match( '/^\s*(\S.*?)\s*=\s*(.*?)\s*$/', $p, $m ) ) {
                $k = $m[1];
                $v = preg_replace( '/^"\s*(.*?)\s*"$/', '$1', $m[2] ); // strip any quotes enclusing the value
            } else {
                $k = trim( $p );
                $v = true;
            }
 
            $argv[$k] = $v;
        }
 
        // now handle just like a <categorytree> tag
        $html = self::parserHook( $cat, $argv, $parser );
        return [ $html, 'noparse' => true, 'isHTML' => true ];
    }
 
    public static function skinTemplateOutputPageBeforeExec( $skin, $tpl ) {
        global $wgCategoryTreeSidebarRoot, $wgCategoryTreeSidebarOptions;
 
        if ( !$wgCategoryTreeSidebarRoot ) {
            return;
        }
 
        $html = self::parserHook( $wgCategoryTreeSidebarRoot, $wgCategoryTreeSidebarOptions );
        if ( $html ) {
            $tpl->data['sidebar']['categorytree-portlet'] = $html;
        }
    }
 
    public static function parserHook( $cat, $argv, $parser = null, $allowMissing = false ) {
        global $wgOut;
 
        if ( $parser ) {
            $parser->mOutput->mCategoryTreeTag = true; # flag for use by CategoryTreeHooks::parserOutput
        } else {
            CategoryTree::setHeaders( $wgOut );
        }
 
        $ct = new CategoryTree( $argv );
 
        $attr = Sanitizer::validateTagAttributes( $argv, 'div' );
 
        $hideroot = isset( $argv['hideroot'] )
            ? CategoryTree::decodeBoolean( $argv['hideroot'] ) : null;
        $onlyroot = isset( $argv['onlyroot'] )
            ? CategoryTree::decodeBoolean( $argv['onlyroot'] ) : null;
        $depthArg = isset( $argv['depth'] ) ? (int)$argv['depth'] : null;
 
        $depth = CategoryTree::capDepth( $ct->getOption( 'mode' ), $depthArg );
        if ( $onlyroot ) {
            $depth = 0;
        }
 
        return $ct->getTag( $parser, $cat, $hideroot, $attr, $depth, $allowMissing );
    }
 
    public static function parserOutput( $outputPage, $parserOutput ) {
        if ( self::shouldForceHeaders() ) {
            // Skip, we've already set the headers unconditionally
            return;
        }
        if ( !empty( $parserOutput->mCategoryTreeTag ) ) {
            CategoryTree::setHeaders( $outputPage );
        }
    }
 
    public static function addHeaders( OutputPage $out ) {
        if ( !self::shouldForceHeaders() ) {
            return;
        }
        CategoryTree::setHeaders( $out );
    }
 
    public static function articleFromTitle( $title, &$article ) {
        if ( $title->getNamespace() == NS_CATEGORY ) {
            $article = new CategoryTreeCategoryPage( $title );
        }
        return true;
    }
 
    public static function outputPageMakeCategoryLinks( &$out, $categories, &$links ) {
        global $wgCategoryTreePageCategoryOptions, $wgCategoryTreeHijackPageCategories;
 
        if ( !$wgCategoryTreeHijackPageCategories ) {
            // Not enabled, don't do anything
            return true;
        }
 
        foreach ( $categories as $category => $type ) {
            $links[$type][] = self::parserHook( $category, $wgCategoryTreePageCategoryOptions, null, true );
        }
 
        return false;
    }
 
    public static function skinJoinCategoryLinks( $skin, &$links, &$result ) {
        global $wgCategoryTreeHijackPageCategories;
        if ( !$wgCategoryTreeHijackPageCategories ) {
            // Not enabled, don't do anything.
            return true;
        }
        $embed = '<div class="CategoryTreeCategoryBarItem">';
        $pop = '</div>';
        $sep = ' ';
 
        $result = $embed . implode( "{$pop} {$sep} {$embed}", $links ) . $pop;
 
        return false;
    }
 
    public static function getConfigVars( &$vars ) {
        global $wgCategoryTreeCategoryPageOptions;
 
        // Look this is pretty bad but Category tree is just whacky, it needs to be rewritten
        $ct = new CategoryTree( $wgCategoryTreeCategoryPageOptions );
        $vars['wgCategoryTreePageCategoryOptions'] = $ct->getOptionsAsJsStructure();
        return true;
    }
 
    public static function onSpecialTrackingCategoriesPreprocess(
        $specialPage, $trackingCategories
    ) {
        $categoryDbKeys = [];
        foreach ( $trackingCategories as $catMsg => $data ) {
            foreach ( $data['cats'] as $catTitle ) {
                $categoryDbKeys[] = $catTitle->getDbKey();
            }
        }
        $categories = [];
        if ( $categoryDbKeys ) {
            $dbr = wfGetDB( DB_REPLICA );
            $res = $dbr->select(
                'category',
                [ 'cat_id', 'cat_title', 'cat_pages', 'cat_subcats', 'cat_files' ],
                [ 'cat_title' => array_unique( $categoryDbKeys ) ],
                __METHOD__
            );
            foreach ( $res as $row ) {
                $categories[$row->cat_title] = Category::newFromRow( $row );
            }
        }
        $specialPage->categoryTreeCategories = $categories;
    }
 
    public static function onSpecialTrackingCategoriesGenerateCatLink(
        $specialPage, $catTitle, &$html
    ) {
        if ( !isset( $specialPage->categoryTreeCategories ) ) {
            return;
        }
 
        $cat = null;
        if ( isset( $specialPage->categoryTreeCategories[$catTitle->getDbKey()] ) ) {
            $cat = $specialPage->categoryTreeCategories[$catTitle->getDbKey()];
        }
 
        $html .= CategoryTree::createCountString( $specialPage->getContext(), $cat, 0 );
    }
}