PrefixSearch.php

Go to the documentation of this file.

<?php
abstract class PrefixSearch {
    public static function titleSearch( $search, $limit, $namespaces = array() ) {
        $search = new StringPrefixSearch;
        return $search->search( $search, $limit, $namespaces );
    }
 
    public function search( $search, $limit, $namespaces = array() ) {
        $search = trim( $search );
        if ( $search == '' ) {
            return array(); // Return empty result
        }
        $namespaces = $this->validateNamespaces( $namespaces );
 
        // Find a Title which is not an interwiki and is in NS_MAIN
        $title = Title::newFromText( $search );
        if ( $title && !$title->isExternal() ) {
            $ns = array( $title->getNamespace() );
            if ( $ns[0] == NS_MAIN ) {
                $ns = $namespaces; // no explicit prefix, use default namespaces
            }
            return $this->searchBackend(
                $ns, $title->getText(), $limit );
        }
 
        // Is this a namespace prefix?
        $title = Title::newFromText( $search . 'Dummy' );
        if ( $title && $title->getText() == 'Dummy'
            && $title->getNamespace() != NS_MAIN
            && !$title->isExternal() )
        {
            $namespaces = array( $title->getNamespace() );
            $search = '';
        }
 
        return $this->searchBackend( $namespaces, $search, $limit );
    }
 
    public function searchWithVariants( $search, $limit, array $namespaces ) {
        wfProfileIn( __METHOD__ );
        $searches = $this->search( $search, $limit, $namespaces );
 
        // if the content language has variants, try to retrieve fallback results
        $fallbackLimit = $limit - count( $searches );
        if ( $fallbackLimit > 0 ) {
            global $wgContLang;
 
            $fallbackSearches = $wgContLang->autoConvertToAllVariants( $search );
            $fallbackSearches = array_diff( array_unique( $fallbackSearches ), array( $search ) );
 
            foreach ( $fallbackSearches as $fbs ) {
                $fallbackSearchResult = $this->search( $fbs, $fallbackLimit, $namespaces );
                $searches = array_merge( $searches, $fallbackSearchResult );
                $fallbackLimit -= count( $fallbackSearchResult );
 
                if ( $fallbackLimit == 0 ) {
                    break;
                }
            }
        }
        wfProfileOut( __METHOD__ );
        return $searches;
    }
 
    protected abstract function titles( array $titles );
 
    protected abstract function strings( array $strings );
 
    protected function searchBackend( $namespaces, $search, $limit ) {
        if ( count( $namespaces ) == 1 ) {
            $ns = $namespaces[0];
            if ( $ns == NS_MEDIA ) {
                $namespaces = array( NS_FILE );
            } elseif ( $ns == NS_SPECIAL ) {
                return $this->titles( $this->specialSearch( $search, $limit ) );
            }
        }
        $srchres = array();
        if ( wfRunHooks( 'PrefixSearchBackend', array( $namespaces, $search, $limit, &$srchres ) ) ) {
            return $this->titles( $this->defaultSearchBackend( $namespaces, $search, $limit ) );
        }
        return $this->strings( $srchres );
    }
 
    protected function specialSearch( $search, $limit ) {
        global $wgContLang;
 
        # normalize searchKey, so aliases with spaces can be found - bug 25675
        $search = str_replace( ' ', '_', $search );
 
        $searchKey = $wgContLang->caseFold( $search );
 
        // Unlike SpecialPage itself, we want the canonical forms of both
        // canonical and alias title forms...
        $keys = array();
        foreach ( SpecialPageFactory::getList() as $page => $class ) {
            $keys[$wgContLang->caseFold( $page )] = $page;
        }
 
        foreach ( $wgContLang->getSpecialPageAliases() as $page => $aliases ) {
            if ( !array_key_exists( $page, SpecialPageFactory::getList() ) ) {# bug 20885
                continue;
            }
 
            foreach ( $aliases as $alias ) {
                $keys[$wgContLang->caseFold( $alias )] = $alias;
            }
        }
        ksort( $keys );
 
        $srchres = array();
        foreach ( $keys as $pageKey => $page ) {
            if ( $searchKey === '' || strpos( $pageKey, $searchKey ) === 0 ) {
                // bug 27671: Don't use SpecialPage::getTitleFor() here because it
                // localizes its input leading to searches for e.g. Special:All
                // returning Spezial:MediaWiki-Systemnachrichten and returning
                // Spezial:Alle_Seiten twice when $wgLanguageCode == 'de'
                $srchres[] = Title::makeTitleSafe( NS_SPECIAL, $page );
            }
 
            if ( count( $srchres ) >= $limit ) {
                break;
            }
        }
 
        return $srchres;
    }
 
    protected function defaultSearchBackend( $namespaces, $search, $limit ) {
        $ns = array_shift( $namespaces ); // support only one namespace
        if ( in_array( NS_MAIN, $namespaces ) ) {
            $ns = NS_MAIN; // if searching on many always default to main
        }
 
        $t = Title::newFromText( $search, $ns );
        $prefix = $t ? $t->getDBkey() : '';
        $dbr = wfGetDB( DB_SLAVE );
        $res = $dbr->select( 'page',
            array( 'page_id', 'page_namespace', 'page_title' ),
            array(
                'page_namespace' => $ns,
                'page_title ' . $dbr->buildLike( $prefix, $dbr->anyString() )
            ),
            __METHOD__,
            array( 'LIMIT' => $limit, 'ORDER BY' => 'page_title' )
        );
        $srchres = array();
        foreach ( $res as $row ) {
            $srchres[] = Title::newFromRow( $row );
        }
        return $srchres;
    }
 
    protected function validateNamespaces( $namespaces ) {
        global $wgContLang;
 
        // We will look at each given namespace against wgContLang namespaces
        $validNamespaces = $wgContLang->getNamespaces();
        if ( is_array( $namespaces ) && count( $namespaces ) > 0 ) {
            $valid = array();
            foreach ( $namespaces as $ns ) {
                if ( is_numeric( $ns ) && array_key_exists( $ns, $validNamespaces ) ) {
                    $valid[] = $ns;
                }
            }
            if ( count( $valid ) > 0 ) {
                return $valid;
            }
        }
 
        return array( NS_MAIN );
    }
}
 
class TitlePrefixSearch extends PrefixSearch {
 
    protected function titles( array $titles ) {
        return $titles;
    }
 
    protected function strings( array $strings ) {
        $titles = array_map( 'Title::newFromText', $strings );
        $lb = new LinkBatch( $titles );
        $lb->setCaller( __METHOD__ );
        $lb->execute();
        return $titles;
    }
}
 
class StringPrefixSearch extends PrefixSearch {
 
    protected function titles( array $titles ) {
        return array_map( function( Title $t ) { return $t->getPrefixedText(); }, $titles );
    }
 
    protected function strings( array $strings ) {
        return $strings;
    }
}