SearchEngine.php

Go to the documentation of this file.

<?php
class SearchEngine {
    var $limit = 10;
    var $offset = 0;
    var $prefix = '';
    var $searchTerms = array();
    var $namespaces = array( NS_MAIN );
    protected $showSuggestion = true;
 
    protected $features = array();
 
    function searchText( $term ) {
        return null;
    }
 
    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 normalizeText( $string ) {
        global $wgContLang;
 
        // Some languages such as Chinese require word segmentation
        return $wgContLang->segmentByWord( $string );
    }
 
    function transformSearchTerm( $term ) {
        return $term;
    }
 
    public static function getNearMatch( $searchterm ) {
        $title = self::getNearMatchInternal( $searchterm );
 
        wfRunHooks( 'SearchGetNearMatchComplete', array( $searchterm, &$title ) );
        return $title;
    }
 
    public static function getNearMatchResultSet( $searchterm ) {
        return new SearchNearMatchResultSet( self::getNearMatch( $searchterm ) );
    }
 
    private static function getNearMatchInternal( $searchterm ) {
        global $wgContLang, $wgEnableSearchContributorsByIP;
 
        $allSearchTerms = array( $searchterm );
 
        if ( $wgContLang->hasVariants() ) {
            $allSearchTerms = array_merge( $allSearchTerms, $wgContLang->autoConvertToAllVariants( $searchterm ) );
        }
 
        $titleResult = null;
        if ( !wfRunHooks( 'SearchGetNearMatchBefore', array( $allSearchTerms, &$titleResult ) ) ) {
            return $titleResult;
        }
 
        foreach ( $allSearchTerms as $term ) {
 
            # Exact match? No need to look further.
            $title = Title::newFromText( $term );
            if ( is_null( $title ) ) {
                return null;
            }
 
            # Try files if searching in the Media: namespace
            if ( $title->getNamespace() == NS_MEDIA ) {
                $title = Title::makeTitle( NS_FILE, $title->getText() );
            }
 
            if ( $title->isSpecialPage() || $title->isExternal() || $title->exists() ) {
                return $title;
            }
 
            # See if it still otherwise has content is some sane sense
            $page = WikiPage::factory( $title );
            if ( $page->hasViewableContent() ) {
                return $title;
            }
 
            if ( !wfRunHooks( 'SearchAfterNoDirectMatch', array( $term, &$title ) ) ) {
                return $title;
            }
 
            # Now try all lower case (i.e. first letter capitalized)
            $title = Title::newFromText( $wgContLang->lc( $term ) );
            if ( $title && $title->exists() ) {
                return $title;
            }
 
            # Now try capitalized string
            $title = Title::newFromText( $wgContLang->ucwords( $term ) );
            if ( $title && $title->exists() ) {
                return $title;
            }
 
            # Now try all upper case
            $title = Title::newFromText( $wgContLang->uc( $term ) );
            if ( $title && $title->exists() ) {
                return $title;
            }
 
            # Now try Word-Caps-Breaking-At-Word-Breaks, for hyphenated names etc
            $title = Title::newFromText( $wgContLang->ucwordbreaks( $term ) );
            if ( $title && $title->exists() ) {
                return $title;
            }
 
            // Give hooks a chance at better match variants
            $title = null;
            if ( !wfRunHooks( 'SearchGetNearMatch', array( $term, &$title ) ) ) {
                return $title;
            }
        }
 
        $title = Title::newFromText( $searchterm );
 
        # Entering an IP address goes to the contributions page
        if ( $wgEnableSearchContributorsByIP ) {
            if ( ( $title->getNamespace() == NS_USER && User::isIP( $title->getText() ) )
                || User::isIP( trim( $searchterm ) ) ) {
                return SpecialPage::getTitleFor( 'Contributions', $title->getDBkey() );
            }
        }
 
        # Entering a user goes to the user page whether it's there or not
        if ( $title->getNamespace() == NS_USER ) {
            return $title;
        }
 
        # Go to images that exist even if there's no local page.
        # There may have been a funny upload, or it may be on a shared
        # file repository such as Wikimedia Commons.
        if ( $title->getNamespace() == NS_FILE ) {
            $image = wfFindFile( $title );
            if ( $image ) {
                return $title;
            }
        }
 
        # MediaWiki namespace? Page may be "implied" if not customized.
        # Just return it, with caps forced as the message system likes it.
        if ( $title->getNamespace() == NS_MEDIAWIKI ) {
            return Title::makeTitle( NS_MEDIAWIKI, $wgContLang->ucfirst( $title->getText() ) );
        }
 
        # Quoted term? Try without the quotes...
        $matches = array();
        if ( preg_match( '/^"([^"]+)"$/', $searchterm, $matches ) ) {
            return SearchEngine::getNearMatch( $matches[1] );
        }
 
        return null;
    }
 
    public static function legalSearchChars() {
        return "A-Za-z_'.0-9\\x80-\\xFF\\-";
    }
 
    function setLimitOffset( $limit, $offset = 0 ) {
        $this->limit = intval( $limit );
        $this->offset = intval( $offset );
    }
 
    function setNamespaces( $namespaces ) {
        $this->namespaces = $namespaces;
    }
 
    function setShowSuggestion( $showSuggestion ) {
        $this->showSuggestion = $showSuggestion;
    }
 
    function replacePrefixes( $query ) {
        global $wgContLang;
 
        $parsed = $query;
        if ( strpos( $query, ':' ) === false ) { // nothing to do
            wfRunHooks( 'SearchEngineReplacePrefixesComplete', array( $this, $query, &$parsed ) );
            return $parsed;
        }
 
        $allkeyword = wfMessage( 'searchall' )->inContentLanguage()->text() . ":";
        if ( strncmp( $query, $allkeyword, strlen( $allkeyword ) ) == 0 ) {
            $this->namespaces = null;
            $parsed = substr( $query, strlen( $allkeyword ) );
        } elseif ( strpos( $query, ':' ) !== false ) {
            $prefix = str_replace( ' ', '_', substr( $query, 0, strpos( $query, ':' ) ) );
            $index = $wgContLang->getNsIndex( $prefix );
            if ( $index !== false ) {
                $this->namespaces = array( $index );
                $parsed = substr( $query, strlen( $prefix ) + 1 );
            }
        }
        if ( trim( $parsed ) == '' ) {
            $parsed = $query; // prefix was the whole query
        }
 
        wfRunHooks( 'SearchEngineReplacePrefixesComplete', array( $this, $query, &$parsed ) );
 
        return $parsed;
    }
 
    public static function searchableNamespaces() {
        global $wgContLang;
        $arr = array();
        foreach ( $wgContLang->getNamespaces() as $ns => $name ) {
            if ( $ns >= NS_MAIN ) {
                $arr[$ns] = $name;
            }
        }
 
        wfRunHooks( 'SearchableNamespaces', array( &$arr ) );
        return $arr;
    }
 
    public static function userNamespaces( $user ) {
        global $wgSearchEverythingOnlyLoggedIn;
 
        $searchableNamespaces = SearchEngine::searchableNamespaces();
 
        // get search everything preference, that can be set to be read for logged-in users
        // it overrides other options
        if ( !$wgSearchEverythingOnlyLoggedIn || $user->isLoggedIn() ) {
            if ( $user->getOption( 'searcheverything' ) ) {
                return array_keys( $searchableNamespaces );
            }
        }
 
        $arr = array();
        foreach ( $searchableNamespaces as $ns => $name ) {
            if ( $user->getOption( 'searchNs' . $ns ) ) {
                $arr[] = $ns;
            }
        }
 
        return $arr;
    }
 
    public static function userHighlightPrefs() {
        $contextlines = 2; // Hardcode this. Old defaults sucked. :)
        $contextchars = 75; // same as above.... :P
        return array( $contextlines, $contextchars );
    }
 
    public static function defaultNamespaces() {
        global $wgNamespacesToBeSearchedDefault;
 
        return array_keys( $wgNamespacesToBeSearchedDefault, true );
    }
 
    public static function namespacesAsText( $namespaces ) {
        global $wgContLang;
 
        $formatted = array_map( array( $wgContLang, 'getFormattedNsText' ), $namespaces );
        foreach ( $formatted as $key => $ns ) {
            if ( empty( $ns ) ) {
                $formatted[$key] = wfMessage( 'blanknamespace' )->text();
            }
        }
        return $formatted;
    }
 
    public static function helpNamespaces() {
        global $wgNamespacesToBeSearchedHelp;
 
        return array_keys( $wgNamespacesToBeSearchedHelp, true );
    }
 
    function filter( $text ) {
        $lc = $this->legalSearchChars();
        return trim( preg_replace( "/[^{$lc}]/", " ", $text ) );
    }
 
    public static function create( $type = null ) {
        global $wgSearchType;
        $dbr = null;
 
        $alternatives = self::getSearchTypes();
 
        if ( $type && in_array( $type, $alternatives ) ) {
            $class = $type;
        } elseif ( $wgSearchType !== null ) {
            $class = $wgSearchType;
        } else {
            $dbr = wfGetDB( DB_SLAVE );
            $class = $dbr->getSearchEngine();
        }
 
        $search = new $class( $dbr );
        return $search;
    }
 
    public static function getSearchTypes() {
        global $wgSearchType, $wgSearchTypeAlternatives;
 
        $alternatives = $wgSearchTypeAlternatives ?: array();
        array_unshift( $alternatives, $wgSearchType );
 
        return $alternatives;
    }
 
    function update( $id, $title, $text ) {
        // no-op
    }
 
    function updateTitle( $id, $title ) {
        // no-op
    }
 
    function delete( $id, $title ) {
        // no-op
    }
 
    public static function getOpenSearchTemplate() {
        global $wgOpenSearchTemplate, $wgCanonicalServer;
        if ( $wgOpenSearchTemplate ) {
            return $wgOpenSearchTemplate;
        } else {
            $ns = implode( '|', SearchEngine::defaultNamespaces() );
            if ( !$ns ) {
                $ns = "0";
            }
            return $wgCanonicalServer . wfScript( 'api' ) . '?action=opensearch&search={searchTerms}&namespace=' . $ns;
        }
    }
 
    public function getTextFromContent( Title $t, Content $c = null ) {
        return $c ? $c->getTextForSearchIndex() : '';
    }
 
    public function textAlreadyUpdatedForIndex() {
        return false;
    }
}
 
class SearchResultTooMany {
    # # Some search engines may bail out if too many matches are found
}
 
class SearchEngineDummy extends SearchEngine {
    // no-op
}