SearchEngine.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
abstract class SearchEngine {
    public $prefix = '';
 
    public $namespaces = [ NS_MAIN ];
 
    protected $limit = 10;
 
    protected $offset = 0;
 
    protected $searchTerms = [];
 
    protected $showSuggestion = true;
    private $sort = 'relevance';
 
    protected $features = [];
 
    const COMPLETION_PROFILE_TYPE = 'completionSearchProfile';
 
    const FT_QUERY_INDEP_PROFILE_TYPE = 'fulltextQueryIndepProfile';
 
    const CHARS_ALL = 1;
 
    const CHARS_NO_SYNTAX = 2;
 
    function searchText( $term ) {
        return null;
    }
 
    function searchArchiveTitle( $term ) {
        return Status::newGood( [] );
    }
 
    function searchTitle( $term ) {
        return null;
    }
 
    public function supports( $feature ) {
        switch ( $feature ) {
        case 'search-update':
            return true;
        case 'title-suffix-filter':
        default:
            return false;
        }
    }
 
    public function setFeatureData( $feature, $data ) {
        $this->features[$feature] = $data;
    }
 
    public function getFeatureData( $feature ) {
        if ( isset( $this->features[$feature] ) ) {
            return $this->features[$feature];
        }
        return null;
    }
 
    public function normalizeText( $string ) {
        global $wgContLang;
 
        // Some languages such as Chinese require word segmentation
        return $wgContLang->segmentByWord( $string );
    }
 
    public function transformSearchTerm( $term ) {
        return $term;
    }
 
    public function getNearMatcher( Config $config ) {
        global $wgContLang;
        return new SearchNearMatcher( $config, $wgContLang );
    }
 
    protected static function defaultNearMatcher() {
        $config = MediaWikiServices::getInstance()->getMainConfig();
        return MediaWikiServices::getInstance()->newSearchEngine()->getNearMatcher( $config );
    }
 
    public static function getNearMatch( $searchterm ) {
        return static::defaultNearMatcher()->getNearMatch( $searchterm );
    }
 
    public static function getNearMatchResultSet( $searchterm ) {
        return static::defaultNearMatcher()->getNearMatchResultSet( $searchterm );
    }
 
    public static function legalSearchChars( $type = self::CHARS_ALL ) {
        return "A-Za-z_'.0-9\\x80-\\xFF\\-";
    }
 
    function setLimitOffset( $limit, $offset = 0 ) {
        $this->limit = intval( $limit );
        $this->offset = intval( $offset );
    }
 
    function setNamespaces( $namespaces ) {
        if ( $namespaces ) {
            // Filter namespaces to only keep valid ones
            $validNs = $this->searchableNamespaces();
            $namespaces = array_filter( $namespaces, function ( $ns ) use( $validNs ) {
                return $ns < 0 || isset( $validNs[$ns] );
            } );
        } else {
            $namespaces = [];
        }
        $this->namespaces = $namespaces;
    }
 
    function setShowSuggestion( $showSuggestion ) {
        $this->showSuggestion = $showSuggestion;
    }
 
    public function getValidSorts() {
        return [ 'relevance' ];
    }
 
    public function setSort( $sort ) {
        if ( !in_array( $sort, $this->getValidSorts() ) ) {
            throw new InvalidArgumentException( "Invalid sort: $sort. " .
                "Must be one of: " . implode( ', ', $this->getValidSorts() ) );
        }
        $this->sort = $sort;
    }
 
    public function getSort() {
        return $this->sort;
    }
 
    function replacePrefixes( $query ) {
        $queryAndNs = self::parseNamespacePrefixes( $query );
        if ( $queryAndNs === false ) {
            return $query;
        }
        $this->namespaces = $queryAndNs[1];
        return $queryAndNs[0];
    }
 
    public static function parseNamespacePrefixes( $query ) {
        global $wgContLang;
 
        $parsed = $query;
        if ( strpos( $query, ':' ) === false ) { // nothing to do
            return false;
        }
        $extractedNamespace = null;
 
        $allkeyword = wfMessage( 'searchall' )->inContentLanguage()->text() . ":";
        if ( strncmp( $query, $allkeyword, strlen( $allkeyword ) ) == 0 ) {
            $extractedNamespace = null;
            $parsed = substr( $query, strlen( $allkeyword ) );
        } elseif ( strpos( $query, ':' ) !== false ) {
            // TODO: should we unify with PrefixSearch::extractNamespace ?
            $prefix = str_replace( ' ', '_', substr( $query, 0, strpos( $query, ':' ) ) );
            $index = $wgContLang->getNsIndex( $prefix );
            if ( $index !== false ) {
                $extractedNamespace = [ $index ];
                $parsed = substr( $query, strlen( $prefix ) + 1 );
            } else {
                return false;
            }
        }
 
        if ( trim( $parsed ) == '' ) {
            $parsed = $query; // prefix was the whole query
        }
 
        return [ $parsed, $extractedNamespace ];
    }
 
    public static function userHighlightPrefs() {
        $contextlines = 2; // Hardcode this. Old defaults sucked. :)
        $contextchars = 75; // same as above.... :P
        return [ $contextlines, $contextchars ];
    }
 
    function update( $id, $title, $text ) {
        // no-op
    }
 
    function updateTitle( $id, $title ) {
        // no-op
    }
 
    function delete( $id, $title ) {
        // no-op
    }
 
    public static function getOpenSearchTemplate() {
        wfDeprecated( __METHOD__, '1.25' );
        return ApiOpenSearch::getOpenSearchTemplate( 'application/x-suggestions+json' );
    }
 
    public function getTextFromContent( Title $t, Content $c = null ) {
        return $c ? $c->getTextForSearchIndex() : '';
    }
 
    public function textAlreadyUpdatedForIndex() {
        return false;
    }
 
    protected function normalizeNamespaces( $search ) {
        // Find a Title which is not an interwiki and is in NS_MAIN
        $title = Title::newFromText( $search );
        $ns = $this->namespaces;
        if ( $title && !$title->isExternal() ) {
            $ns = [ $title->getNamespace() ];
            $search = $title->getText();
            if ( $ns[0] == NS_MAIN ) {
                $ns = $this->namespaces; // no explicit prefix, use default namespaces
                Hooks::run( 'PrefixSearchExtractNamespace', [ &$ns, &$search ] );
            }
        } else {
            $title = Title::newFromText( $search . 'Dummy' );
            if ( $title && $title->getText() == 'Dummy'
                    && $title->getNamespace() != NS_MAIN
                    && !$title->isExternal()
            ) {
                $ns = [ $title->getNamespace() ];
                $search = '';
            } else {
                Hooks::run( 'PrefixSearchExtractNamespace', [ &$ns, &$search ] );
            }
        }
 
        $ns = array_map( function ( $space ) {
            return $space == NS_MEDIA ? NS_FILE : $space;
        }, $ns );
 
        $this->setNamespaces( $ns );
        return $search;
    }
 
    protected function completionSearchBackend( $search ) {
        $results = [];
 
        $search = trim( $search );
 
        if ( !in_array( NS_SPECIAL, $this->namespaces ) && // We do not run hook on Special: search
             !Hooks::run( 'PrefixSearchBackend',
                [ $this->namespaces, $search, $this->limit, &$results, $this->offset ]
        ) ) {
            // False means hook worked.
            // FIXME: Yes, the API is weird. That's why it is going to be deprecated.
 
            return SearchSuggestionSet::fromStrings( $results );
        } else {
            // Hook did not do the job, use default simple search
            $results = $this->simplePrefixSearch( $search );
            return SearchSuggestionSet::fromTitles( $results );
        }
    }
 
    public function completionSearch( $search ) {
        if ( trim( $search ) === '' ) {
            return SearchSuggestionSet::emptySuggestionSet(); // Return empty result
        }
        $search = $this->normalizeNamespaces( $search );
        return $this->processCompletionResults( $search, $this->completionSearchBackend( $search ) );
    }
 
    public function completionSearchWithVariants( $search ) {
        if ( trim( $search ) === '' ) {
            return SearchSuggestionSet::emptySuggestionSet(); // Return empty result
        }
        $search = $this->normalizeNamespaces( $search );
 
        $results = $this->completionSearchBackend( $search );
        $fallbackLimit = $this->limit - $results->getSize();
        if ( $fallbackLimit > 0 ) {
            global $wgContLang;
 
            $fallbackSearches = $wgContLang->autoConvertToAllVariants( $search );
            $fallbackSearches = array_diff( array_unique( $fallbackSearches ), [ $search ] );
 
            foreach ( $fallbackSearches as $fbs ) {
                $this->setLimitOffset( $fallbackLimit );
                $fallbackSearchResult = $this->completionSearch( $fbs );
                $results->appendAll( $fallbackSearchResult );
                $fallbackLimit -= count( $fallbackSearchResult );
                if ( $fallbackLimit <= 0 ) {
                    break;
                }
            }
        }
        return $this->processCompletionResults( $search, $results );
    }
 
    public function extractTitles( SearchSuggestionSet $completionResults ) {
        return $completionResults->map( function ( SearchSuggestion $sugg ) {
            return $sugg->getSuggestedTitle();
        } );
    }
 
    protected function processCompletionResults( $search, SearchSuggestionSet $suggestions ) {
        $search = trim( $search );
        // preload the titles with LinkBatch
        $titles = $suggestions->map( function ( SearchSuggestion $sugg ) {
            return $sugg->getSuggestedTitle();
        } );
        $lb = new LinkBatch( $titles );
        $lb->setCaller( __METHOD__ );
        $lb->execute();
 
        $results = $suggestions->map( function ( SearchSuggestion $sugg ) {
            return $sugg->getSuggestedTitle()->getPrefixedText();
        } );
 
        if ( $this->offset === 0 ) {
            // Rescore results with an exact title match
            // NOTE: in some cases like cross-namespace redirects
            // (frequently used as shortcuts e.g. WP:WP on huwiki) some
            // backends like Cirrus will return no results. We should still
            // try an exact title match to workaround this limitation
            $rescorer = new SearchExactMatchRescorer();
            $rescoredResults = $rescorer->rescore( $search, $this->namespaces, $results, $this->limit );
        } else {
            // No need to rescore if offset is not 0
            // The exact match must have been returned at position 0
            // if it existed.
            $rescoredResults = $results;
        }
 
        if ( count( $rescoredResults ) > 0 ) {
            $found = array_search( $rescoredResults[0], $results );
            if ( $found === false ) {
                // If the first result is not in the previous array it
                // means that we found a new exact match
                $exactMatch = SearchSuggestion::fromTitle( 0, Title::newFromText( $rescoredResults[0] ) );
                $suggestions->prepend( $exactMatch );
                $suggestions->shrink( $this->limit );
            } else {
                // if the first result is not the same we need to rescore
                if ( $found > 0 ) {
                    $suggestions->rescore( $found );
                }
            }
        }
 
        return $suggestions;
    }
 
    public function defaultPrefixSearch( $search ) {
        if ( trim( $search ) === '' ) {
            return [];
        }
 
        $search = $this->normalizeNamespaces( $search );
        return $this->simplePrefixSearch( $search );
    }
 
    protected function simplePrefixSearch( $search ) {
        // Use default database prefix search
        $backend = new TitlePrefixSearch;
        return $backend->defaultSearchBackend( $this->namespaces, $search, $this->limit, $this->offset );
    }
 
    public static function searchableNamespaces() {
        return MediaWikiServices::getInstance()->getSearchEngineConfig()->searchableNamespaces();
    }
 
    public static function userNamespaces( $user ) {
        return MediaWikiServices::getInstance()->getSearchEngineConfig()->userNamespaces( $user );
    }
 
    public static function defaultNamespaces() {
        return MediaWikiServices::getInstance()->getSearchEngineConfig()->defaultNamespaces();
    }
 
    public static function namespacesAsText( $namespaces ) {
        return MediaWikiServices::getInstance()->getSearchEngineConfig()->namespacesAsText( $namespaces );
    }
 
    public static function create( $type = null ) {
        return MediaWikiServices::getInstance()->getSearchEngineFactory()->create( $type );
    }
 
    public static function getSearchTypes() {
        return MediaWikiServices::getInstance()->getSearchEngineConfig()->getSearchTypes();
    }
 
    public function getProfiles( $profileType, User $user = null ) {
        return null;
    }
 
    public function makeSearchFieldMapping( $name, $type ) {
        return new NullIndexField();
    }
 
    public function getSearchIndexFields() {
        $models = ContentHandler::getContentModels();
        $fields = [];
        $seenHandlers = new SplObjectStorage();
        foreach ( $models as $model ) {
            try {
                $handler = ContentHandler::getForModelID( $model );
            }
            catch ( MWUnknownContentModelException $e ) {
                // If we can find no handler, ignore it
                continue;
            }
            // Several models can have the same handler, so avoid processing it repeatedly
            if ( $seenHandlers->contains( $handler ) ) {
                // We already did this one
                continue;
            }
            $seenHandlers->attach( $handler );
            $handlerFields = $handler->getFieldsForSearchIndex( $this );
            foreach ( $handlerFields as $fieldName => $fieldData ) {
                if ( empty( $fields[$fieldName] ) ) {
                    $fields[$fieldName] = $fieldData;
                } else {
                    // TODO: do we allow some clashes with the same type or reject all of them?
                    $mergeDef = $fields[$fieldName]->merge( $fieldData );
                    if ( !$mergeDef ) {
                        throw new InvalidArgumentException( "Duplicate field $fieldName for model $model" );
                    }
                    $fields[$fieldName] = $mergeDef;
                }
            }
        }
        // Hook to allow extensions to produce search mapping fields
        Hooks::run( 'SearchIndexFields', [ &$fields, $this ] );
        return $fields;
    }
 
    public function augmentSearchResults( SearchResultSet $resultSet ) {
        $setAugmentors = [];
        $rowAugmentors = [];
        Hooks::run( "SearchResultsAugment", [ &$setAugmentors, &$rowAugmentors ] );
 
        if ( !$setAugmentors && !$rowAugmentors ) {
            // We're done here
            return;
        }
 
        // Convert row augmentors to set augmentor
        foreach ( $rowAugmentors as $name => $row ) {
            if ( isset( $setAugmentors[$name] ) ) {
                throw new InvalidArgumentException( "Both row and set augmentors are defined for $name" );
            }
            $setAugmentors[$name] = new PerRowAugmentor( $row );
        }
 
        foreach ( $setAugmentors as $name => $augmentor ) {
            $data = $augmentor->augmentAll( $resultSet );
            if ( $data ) {
                $resultSet->setAugmentedData( $name, $data );
            }
        }
    }
}
 
class SearchEngineDummy extends SearchEngine {
    // no-op
}