SearchEngine.php

Go to the documentation of this file.

<?php
class SearchEngine {
    public $prefix = '';

    public $namespaces = array( NS_MAIN );

    protected $limit = 10;

    protected $offset = 0;

    protected $searchTerms = array();

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

        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 ) {
        $arr = array();
        foreach ( SearchEngine::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 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 SearchEngineDummy extends SearchEngine {
    // no-op
}