SearchEngineConfig.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Search;
 
use MediaWiki\Config\Config;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\MainConfigNames;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserIdentity;
 
class SearchEngineConfig {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::NamespacesToBeSearchedDefault,
        MainConfigNames::SearchTypeAlternatives,
        MainConfigNames::SearchType,
    ];
 
    private $config;
 
    private $engineMappings;
 
    private ServiceOptions $options;
    private Language $language;
    private HookRunner $hookRunner;
    private UserOptionsLookup $userOptionsLookup;
 
    public function __construct(
        ServiceOptions $options,
        Language $language,
        HookContainer $hookContainer,
        array $engineMappings,
        UserOptionsLookup $userOptionsLookup
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->language = $language;
        $this->engineMappings = $engineMappings;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->userOptionsLookup = $userOptionsLookup;
    }
 
    public function getConfig() {
        wfDeprecated( __METHOD__, '1.43' );
        return $this->config;
    }
 
    public function searchableNamespaces() {
        $arr = [];
        foreach ( $this->language->getNamespaces() as $ns => $name ) {
            if ( $ns >= NS_MAIN ) {
                $arr[$ns] = $name;
            }
        }
 
        $this->hookRunner->onSearchableNamespaces( $arr );
        return $arr;
    }
 
    public function userNamespaces( $user ) {
        $arr = [];
        foreach ( $this->searchableNamespaces() as $ns => $_ ) {
            if ( $this->userOptionsLookup->getOption( $user, 'searchNs' . $ns ) ) {
                $arr[] = $ns;
            }
        }
 
        return $arr;
    }
 
    public function defaultNamespaces() {
        return array_keys( $this->options->get( MainConfigNames::NamespacesToBeSearchedDefault ),
            true );
    }
 
    public function getSearchTypes() {
        $alternatives = $this->options->get( MainConfigNames::SearchTypeAlternatives ) ?: [];
        array_unshift( $alternatives, $this->options->get( MainConfigNames::SearchType ) );
 
        return $alternatives;
    }
 
    public function getSearchType() {
        return $this->options->get( MainConfigNames::SearchType );
    }
 
    public function getSearchMappings() {
        return $this->engineMappings;
    }
 
    public function namespacesAsText( $namespaces ) {
        $formatted = array_map( $this->language->getFormattedNsText( ... ), $namespaces );
        foreach ( $formatted as $key => $ns ) {
            if ( !$ns ) {
                $formatted[$key] = wfMessage( 'blanknamespace' )->text();
            }
        }
        return $formatted;
    }
}
 
class_alias( SearchEngineConfig::class, 'SearchEngineConfig' );