PrefixSearch.php

Go to the documentation of this file.

<?php
abstract class PrefixSearch {
    public static function titleSearch( $search, $limit, $namespaces = [], $offset = 0 ) {
        $prefixSearch = new StringPrefixSearch;
        return $prefixSearch->search( $search, $limit, $namespaces, $offset );
    }
 
    public function search( $search, $limit, $namespaces = [], $offset = 0 ) {
        $search = trim( $search );
        if ( $search == '' ) {
            return []; // Return empty result
        }
 
        $hasNamespace = $this->extractNamespace( $search );
        if ( $hasNamespace ) {
            list( $namespace, $search ) = $hasNamespace;
            $namespaces = [ $namespace ];
        } else {
            $namespaces = $this->validateNamespaces( $namespaces );
            Hooks::run( 'PrefixSearchExtractNamespace', [ &$namespaces, &$search ] );
        }
 
        return $this->searchBackend( $namespaces, $search, $limit, $offset );
    }
 
    protected function extractNamespace( $input ) {
        if ( strpos( $input, ':' ) === false ) {
            return false;
        }
 
        // Namespace prefix only
        $title = Title::newFromText( $input . 'Dummy' );
        if (
            $title &&
            $title->getText() === 'Dummy' &&
            !$title->inNamespace( NS_MAIN ) &&
            !$title->isExternal()
        ) {
            return [ $title->getNamespace(), '' ];
        }
 
        // Namespace prefix with additional input
        $title = Title::newFromText( $input );
        if (
            $title &&
            !$title->inNamespace( NS_MAIN ) &&
            !$title->isExternal()
        ) {
            // getText provides correct capitalization
            return [ $title->getNamespace(), $title->getText() ];
        }
 
        return false;
    }
 
    public function searchWithVariants( $search, $limit, array $namespaces, $offset = 0 ) {
        $searches = $this->search( $search, $limit, $namespaces, $offset );
 
        // 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 ), [ $search ] );
 
            foreach ( $fallbackSearches as $fbs ) {
                $fallbackSearchResult = $this->search( $fbs, $fallbackLimit, $namespaces );
                $searches = array_merge( $searches, $fallbackSearchResult );
                $fallbackLimit -= count( $fallbackSearchResult );
 
                if ( $fallbackLimit == 0 ) {
                    break;
                }
            }
        }
        return $searches;
    }
 
    abstract protected function titles( array $titles );
 
    abstract protected function strings( array $strings );
 
    protected function searchBackend( $namespaces, $search, $limit, $offset ) {
        if ( count( $namespaces ) == 1 ) {
            $ns = $namespaces[0];
            if ( $ns == NS_MEDIA ) {
                $namespaces = [ NS_FILE ];
            } elseif ( $ns == NS_SPECIAL ) {
                return $this->titles( $this->specialSearch( $search, $limit, $offset ) );
            }
        }
        $srchres = [];
        if ( Hooks::run(
            'PrefixSearchBackend',
            [ $namespaces, $search, $limit, &$srchres, $offset ]
        ) ) {
            return $this->titles( $this->defaultSearchBackend( $namespaces, $search, $limit, $offset ) );
        }
        return $this->strings(
            $this->handleResultFromHook( $srchres, $namespaces, $search, $limit, $offset ) );
    }
 
    private function handleResultFromHook( $srchres, $namespaces, $search, $limit, $offset ) {
        if ( $offset === 0 ) {
            // Only perform exact db match if offset === 0
            // This is still far from perfect but at least we avoid returning the
            // same title afain and again when the user is scrolling with a query
            // that matches a title in the db.
            $rescorer = new SearchExactMatchRescorer();
            $srchres = $rescorer->rescore( $search, $namespaces, $srchres, $limit );
        }
        return $srchres;
    }
 
    protected function specialSearch( $search, $limit, $offset ) {
        global $wgContLang;
 
        $searchParts = explode( '/', $search, 2 );
        $searchKey = $searchParts[0];
        $subpageSearch = isset( $searchParts[1] ) ? $searchParts[1] : null;
 
        // Handle subpage search separately.
        if ( $subpageSearch !== null ) {
            // Try matching the full search string as a page name
            $specialTitle = Title::makeTitleSafe( NS_SPECIAL, $searchKey );
            if ( !$specialTitle ) {
                return [];
            }
            $special = SpecialPageFactory::getPage( $specialTitle->getText() );
            if ( $special ) {
                $subpages = $special->prefixSearchSubpages( $subpageSearch, $limit, $offset );
                return array_map( function ( $sub ) use ( $specialTitle ) {
                    return $specialTitle->getSubpage( $sub );
                }, $subpages );
            } else {
                return [];
            }
        }
 
        # normalize searchKey, so aliases with spaces can be found - bug 25675
        $searchKey = str_replace( ' ', '_', $searchKey );
        $searchKey = $wgContLang->caseFold( $searchKey );
 
        // Unlike SpecialPage itself, we want the canonical forms of both
        // canonical and alias title forms...
        $keys = [];
        foreach ( SpecialPageFactory::getNames() as $page ) {
            $keys[$wgContLang->caseFold( $page )] = $page;
        }
 
        foreach ( $wgContLang->getSpecialPageAliases() as $page => $aliases ) {
            if ( !in_array( $page, SpecialPageFactory::getNames() ) ) {# bug 20885
                continue;
            }
 
            foreach ( $aliases as $alias ) {
                $keys[$wgContLang->caseFold( $alias )] = $alias;
            }
        }
        ksort( $keys );
 
        $srchres = [];
        $skipped = 0;
        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'
                if ( $offset > 0 && $skipped < $offset ) {
                    $skipped++;
                    continue;
                }
                $srchres[] = Title::makeTitleSafe( NS_SPECIAL, $page );
            }
 
            if ( count( $srchres ) >= $limit ) {
                break;
            }
        }
 
        return $srchres;
    }
 
    public function defaultSearchBackend( $namespaces, $search, $limit, $offset ) {
        // Backwards compatability with old code. Default to NS_MAIN if no namespaces provided.
        if ( $namespaces === null ) {
            $namespaces = [];
        }
        if ( !$namespaces ) {
            $namespaces[] = NS_MAIN;
        }
 
        // Construct suitable prefix for each namespace. They differ in cases where
        // some namespaces always capitalize and some don't.
        $prefixes = [];
        foreach ( $namespaces as $namespace ) {
            // For now, if special is included, ignore the other namespaces
            if ( $namespace == NS_SPECIAL ) {
                return $this->specialSearch( $search, $limit, $offset );
            }
 
            $title = Title::makeTitleSafe( $namespace, $search );
            // Why does the prefix default to empty?
            $prefix = $title ? $title->getDBkey() : '';
            $prefixes[$prefix][] = $namespace;
        }
 
        $dbr = wfGetDB( DB_REPLICA );
        // Often there is only one prefix that applies to all requested namespaces,
        // but sometimes there are two if some namespaces do not always capitalize.
        $conds = [];
        foreach ( $prefixes as $prefix => $namespaces ) {
            $condition = [
                'page_namespace' => $namespaces,
                'page_title' . $dbr->buildLike( $prefix, $dbr->anyString() ),
            ];
            $conds[] = $dbr->makeList( $condition, LIST_AND );
        }
 
        $table = 'page';
        $fields = [ 'page_id', 'page_namespace', 'page_title' ];
        $conds = $dbr->makeList( $conds, LIST_OR );
        $options = [
            'LIMIT' => $limit,
            'ORDER BY' => [ 'page_title', 'page_namespace' ],
            'OFFSET' => $offset
        ];
 
        $res = $dbr->select( $table, $fields, $conds, __METHOD__, $options );
 
        return iterator_to_array( TitleArray::newFromResult( $res ) );
    }
 
    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 = [];
            foreach ( $namespaces as $ns ) {
                if ( is_numeric( $ns ) && array_key_exists( $ns, $validNamespaces ) ) {
                    $valid[] = $ns;
                }
            }
            if ( count( $valid ) > 0 ) {
                return $valid;
            }
        }
 
        return [ 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;
    }
}