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
        }
        $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 = [ $title->getNamespace() ];
            $search = $title->getText();
            if ( $ns[0] == NS_MAIN ) {
                $ns = $namespaces; // no explicit prefix, use default namespaces
                Hooks::run( 'PrefixSearchExtractNamespace', [ &$ns, &$search ] );
            }
            return $this->searchBackend( $ns, $search, $limit, $offset );
        }

        // Is this a namespace prefix?
        $title = Title::newFromText( $search . 'Dummy' );
        if ( $title && $title->getText() == 'Dummy'
            && $title->getNamespace() != NS_MAIN
            && !$title->isExternal() )
        {
            $namespaces = [ $title->getNamespace() ];
            $search = '';
        } else {
            Hooks::run( 'PrefixSearchExtractNamespace', [ &$namespaces, &$search ] );
        }

        return $this->searchBackend( $namespaces, $search, $limit, $offset );
    }

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

    private function handleResultFromHook( $srchres, $namespaces, $search, $limit ) {
        $rescorer = new SearchExactMatchRescorer();
        return $rescorer->rescore( $search, $namespaces, $srchres, $limit );
    }

    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 ) {
        $ns = array_shift( $namespaces ); // support only one namespace
        if ( is_null( $ns ) || in_array( NS_MAIN, $namespaces ) ) {
            $ns = NS_MAIN; // if searching on many always default to main
        }

        if ( $ns == NS_SPECIAL ) {
            return $this->specialSearch( $search, $limit, $offset );
        }

        $t = Title::newFromText( $search, $ns );
        $prefix = $t ? $t->getDBkey() : '';
        $dbr = wfGetDB( DB_SLAVE );
        $res = $dbr->select( 'page',
            [ 'page_id', 'page_namespace', 'page_title' ],
            [
                'page_namespace' => $ns,
                'page_title ' . $dbr->buildLike( $prefix, $dbr->anyString() )
            ],
            __METHOD__,
            [
                'LIMIT' => $limit,
                'ORDER BY' => 'page_title',
                'OFFSET' => $offset
            ]
        );
        $srchres = [];
        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 = [];
            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;
    }
}