Файловый менеджер - Редактировать - /var/www/html/title.zip
Ðазад
PK ! E�[�� � MalformedTitleException.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use Exception; use ILocalizedException; use MediaWiki\Message\Message; /** * MalformedTitleException is thrown when a TitleParser is unable to parse a title string. * @newable * @since 1.23 */ class MalformedTitleException extends Exception implements ILocalizedException { /** @var string|null */ private $titleText; /** @var string */ private $errorMessage; /** @var array */ private $errorMessageParameters; /** * @stable to call * @param string $errorMessage Localisation message describing the error (since MW 1.26) * @param string|null $titleText The invalid title text (since MW 1.26) * @param array $errorMessageParameters Additional parameters for the error message. * $titleText will be appended if it's not null. (since MW 1.26) */ public function __construct( $errorMessage, $titleText = null, $errorMessageParameters = [] ) { $this->errorMessage = $errorMessage; $this->titleText = $titleText; if ( $titleText !== null ) { $errorMessageParameters[] = wfEscapeWikiText( $titleText ); } $this->errorMessageParameters = $errorMessageParameters; // Supply something useful for Exception::getMessage() to return. $enMsg = wfMessage( $errorMessage, $errorMessageParameters ); $enMsg->inLanguage( 'en' )->useDatabase( false ); parent::__construct( $enMsg->text() ); } /** * @since 1.26 * @return string|null */ public function getTitleText() { return $this->titleText; } /** * @since 1.26 * @return string */ public function getErrorMessage() { return $this->errorMessage; } /** * @since 1.26 * @return array */ public function getErrorMessageParameters() { return $this->errorMessageParameters; } /** * @since 1.29 * @return Message */ public function getMessageObject() { return wfMessage( $this->getErrorMessage(), $this->getErrorMessageParameters() ); } } /** @deprecated class alias since 1.41 */ class_alias( MalformedTitleException::class, 'MalformedTitleException' ); PK ! �I��C C % NamespaceAwareForeignTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; /** * A parser that translates page titles on a foreign wiki into ForeignTitle * objects, using information about the namespace setup on the foreign site. */ class NamespaceAwareForeignTitleFactory implements ForeignTitleFactory { /** * @var array */ protected $foreignNamespaces; /** * @var array */ private $foreignNamespacesFlipped; /** * Normalizes an array name for $foreignNamespacesFlipped. * @param string $name * @return string */ private function normalizeNamespaceName( $name ) { return strtolower( str_replace( ' ', '_', $name ) ); } /** * @param array|null $foreignNamespaces An array 'id' => 'name' which contains * the complete namespace setup of the foreign wiki. Such data could be * obtained from siteinfo/namespaces in an XML dump file, or by an action API * query such as api.php?action=query&meta=siteinfo&siprop=namespaces. If * this data is unavailable, use NaiveForeignTitleFactory instead. */ public function __construct( $foreignNamespaces ) { $this->foreignNamespaces = $foreignNamespaces; if ( $foreignNamespaces !== null ) { $this->foreignNamespacesFlipped = []; foreach ( $foreignNamespaces as $id => $name ) { $newKey = self::normalizeNamespaceName( $name ); $this->foreignNamespacesFlipped[$newKey] = $id; } } } /** * Create a ForeignTitle object. * * Based on the page title and optionally the namespace ID, of a page on a foreign wiki. * These values could be, for example, the `<title>` and `<ns>` attributes found in an * XML dump. * * @param string $title The page title * @param int|null $ns The namespace ID, or null if this data is not available * @return ForeignTitle */ public function createForeignTitle( $title, $ns = null ) { // Export schema version 0.5 and earlier (MW 1.18 and earlier) does not // contain a <ns> tag, so we need to be able to handle that case. if ( $ns === null ) { return self::parseTitleNoNs( $title ); } else { return self::parseTitleWithNs( $title, $ns ); } } /** * Helper function to parse the title when the namespace ID is not specified. * * @param string $title * @return ForeignTitle */ protected function parseTitleNoNs( $title ) { $pieces = explode( ':', $title, 2 ); $key = self::normalizeNamespaceName( $pieces[0] ); // Does the part before the colon match a known namespace? Check the // foreign namespaces $isNamespacePartValid = isset( $this->foreignNamespacesFlipped[$key] ); if ( count( $pieces ) === 2 && $isNamespacePartValid ) { [ $namespaceName, $pageName ] = $pieces; $ns = $this->foreignNamespacesFlipped[$key]; } else { $namespaceName = ''; $pageName = $title; $ns = 0; } return new ForeignTitle( $ns, $namespaceName, $pageName ); } /** * Helper function to parse the title when the namespace value is known. * * @param string $title * @param int $ns * @return ForeignTitle */ protected function parseTitleWithNs( $title, $ns ) { $pieces = explode( ':', $title, 2 ); // Is $title of the form Namespace:Title (true), or just Title (false)? $titleIncludesNamespace = ( $ns != '0' && count( $pieces ) === 2 ); if ( isset( $this->foreignNamespaces[$ns] ) ) { $namespaceName = $this->foreignNamespaces[$ns]; } else { // If the foreign wiki is misconfigured, XML dumps can contain a page with // a non-zero namespace ID, but whose title doesn't contain a colon // (T114115). In those cases, output a made-up namespace name to avoid // collisions. The ImportTitleFactory might replace this with something // more appropriate. $namespaceName = $titleIncludesNamespace ? $pieces[0] : "Ns$ns"; } // We assume that the portion of the page title before the colon is the // namespace name, except in the case of namespace 0. if ( $titleIncludesNamespace ) { $pageName = $pieces[1]; } else { $pageName = $title; } return new ForeignTitle( $ns, $namespaceName, $pageName ); } } /** @deprecated class alias since 1.41 */ class_alias( NamespaceAwareForeignTitleFactory::class, 'NamespaceAwareForeignTitleFactory' ); PK ! 9t�( ( TitleParser.phpnu �Iw�� <?php /** * A title parser service for %MediaWiki. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Daniel Kinzler */ namespace MediaWiki\Title; /** * A title parser service for %MediaWiki. * * This is designed to encapsulate knowledge about conventions for the title * forms to be used in the database, in urls, in wikitext, etc. * * @see https://www.mediawiki.org/wiki/Requests_for_comment/TitleValue * @since 1.23 */ interface TitleParser { /** * Parses the given text and constructs a TitleValue. * * @note this only parses local page links, interwiki-prefixes etc. are not considered! * * @param string $text The text to parse * @param int $defaultNamespace Namespace to assume by default (usually NS_MAIN) * * @throws MalformedTitleException If the text is not a valid representation of a page title. * @return TitleValue */ public function parseTitle( $text, $defaultNamespace = NS_MAIN ); /** * Given a namespace and title, return a TitleValue if valid, or null if invalid. * * @param int $namespace * @param string $text * @param string $fragment * @param string $interwiki * * @return TitleValue|null */ public function makeTitleValueSafe( $namespace, $text, $fragment = '', $interwiki = '' ); } /** @deprecated class alias since 1.41 */ class_alias( TitleParser::class, 'TitleParser' ); PK ! �d�l SubpageImportTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use InvalidArgumentException; /** * A class to convert page titles on a foreign wiki (ForeignTitle objects) into * page titles on the local wiki (Title objects), placing all pages as subpages * of a given root page. */ class SubpageImportTitleFactory implements ImportTitleFactory { private TitleFactory $titleFactory; private Title $rootPage; /** * @param NamespaceInfo $namespaceInfo * @param TitleFactory $titleFactory * @param Title $rootPage The root page under which all pages should be created */ public function __construct( NamespaceInfo $namespaceInfo, TitleFactory $titleFactory, Title $rootPage ) { if ( !$namespaceInfo->hasSubpages( $rootPage->getNamespace() ) ) { throw new InvalidArgumentException( "The root page you specified, $rootPage, is in a " . "namespace where subpages are not allowed" ); } $this->titleFactory = $titleFactory; $this->rootPage = $rootPage; } /** * Determines which local title best corresponds to the given foreign title. * If such a title can't be found or would be locally invalid, null is * returned. * * @param ForeignTitle $foreignTitle The ForeignTitle to convert * @return Title|null */ public function createTitleFromForeignTitle( ForeignTitle $foreignTitle ) { return $this->titleFactory->newFromText( $this->rootPage->getPrefixedDBkey() . '/' . $foreignTitle->getFullText() ); } } /** @deprecated class alias since 1.41 */ class_alias( SubpageImportTitleFactory::class, 'SubpageImportTitleFactory' ); PK ! �h TitleValue.phpnu �Iw�� <?php /** * Representation of a page title within MediaWiki. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Daniel Kinzler */ namespace MediaWiki\Title; use InvalidArgumentException; use MediaWiki\Linker\LinkTarget; use MediaWiki\Page\PageReference; use Stringable; use Wikimedia\Assert\Assert; use Wikimedia\Assert\ParameterAssertionException; use Wikimedia\Assert\ParameterTypeException; use Wikimedia\Parsoid\Core\LinkTarget as ParsoidLinkTarget; use Wikimedia\Parsoid\Core\LinkTargetTrait; /** * Represents the target of a wiki link. * * @note In contrast to Title, this is designed to be a plain value object. That is, * it is immutable, does not use global state, and causes no side effects. * * @newable * * @see https://www.mediawiki.org/wiki/Manual:Modeling_pages * @since 1.23 */ class TitleValue implements Stringable, LinkTarget { use LinkTargetTrait; /** @var int */ private $namespace; /** @var string */ private $dbkey; /** @var string */ private $fragment; /** @var string */ private $interwiki; /** * Text form including namespace/interwiki, initialised on demand * * Only public to share cache with TitleFormatter * * @internal * @var string */ public $prefixedText = null; /** * Constructs a TitleValue, or returns null if the parameters are not valid. * * @note This does not perform any normalization, and only basic validation. * For full normalization and validation, use TitleParser::makeTitleValueSafe(). * * @param int $namespace The namespace ID. This is not validated. * @param string $title The page title in either DBkey or text form. No normalization is applied * beyond underscore/space conversion. * @param string $fragment The fragment title. Use '' to represent the whole page. * No validation or normalization is applied. * @param string $interwiki The interwiki component. * No validation or normalization is applied. * @return TitleValue|null */ public static function tryNew( $namespace, $title, $fragment = '', $interwiki = '' ) { if ( !is_int( $namespace ) ) { throw new ParameterTypeException( '$namespace', 'int' ); } try { return new static( $namespace, $title, $fragment, $interwiki ); } catch ( ParameterAssertionException $ex ) { return null; } } /** * Create a TitleValue from a local PageReference. * * @note The PageReference may belong to another wiki. In that case, the resulting TitleValue * is also logically bound to that other wiki. No attempt is made to map the * PageReference wiki ID to an interwiki prefix for the TitleValue. * * @since 1.36 * @param PageReference $page * @return TitleValue */ public static function newFromPage( PageReference $page ): TitleValue { return new TitleValue( $page->getNamespace(), $page->getDBkey() ); } /** * Create a TitleValue from a LinkTarget * @param ParsoidLinkTarget $linkTarget * @return TitleValue * @since 1.42 */ public static function newFromLinkTarget( ParsoidLinkTarget $linkTarget ): TitleValue { if ( $linkTarget instanceof TitleValue ) { return $linkTarget; } return new TitleValue( $linkTarget->getNamespace(), $linkTarget->getDBkey(), $linkTarget->getFragment(), $linkTarget->getInterwiki() ); } /** * Casts a PageReference to a LinkTarget. * * If $page is null, null is returned. * If $page is also an instance of LinkTarget, $page is returned unchanged. * * @see newFromPage() * @since 1.37 * @param PageReference|null $page * @return LinkTarget|null */ public static function castPageToLinkTarget( ?PageReference $page ): ?LinkTarget { if ( !$page || $page instanceof LinkTarget ) { return $page; } return self::newFromPage( $page ); } /** * Construct a TitleValue. * * @note TitleValue expects a valid namespace and name; typically, a TitleValue is constructed * either from a database entry, or by a TitleParser. For constructing a TitleValue from user * input or external sources, use a TitleParser. * * @stable to call * @param int $namespace The namespace ID. This is not validated. * @param string $title The page title in either DBkey or text form. No normalization is applied * beyond underscore/space conversion. * @param string $fragment The fragment title. Use '' to represent the whole page. * No validation or normalization is applied. * @param string $interwiki The interwiki component. * No validation or normalization is applied. */ public function __construct( $namespace, $title, $fragment = '', $interwiki = '' ) { self::assertValidSpec( $namespace, $title, $fragment, $interwiki ); $this->namespace = $namespace; $this->dbkey = strtr( $title, ' ', '_' ); $this->fragment = $fragment; $this->interwiki = $interwiki; } /** * Assert that the given parameters could be used to construct a TitleValue object. * * Performs basic syntax and consistency checks. Does not perform full validation, * use TitleParser::makeTitleValueSafe() for that. * * @param int $namespace * @param string $title * @param string $fragment * @param string $interwiki * @throws InvalidArgumentException if the combination of parameters is not valid for * constructing a TitleValue. */ public static function assertValidSpec( $namespace, $title, $fragment = '', $interwiki = '' ) { if ( !is_int( $namespace ) ) { throw new ParameterTypeException( '$namespace', 'int' ); } if ( !is_string( $title ) ) { throw new ParameterTypeException( '$title', 'string' ); } if ( !is_string( $fragment ) ) { throw new ParameterTypeException( '$fragment', 'string' ); } if ( !is_string( $interwiki ) ) { throw new ParameterTypeException( '$interwiki', 'string' ); } Assert::parameter( !preg_match( '/^[_ ]|[\r\n\t]|[_ ]$/', $title ), '$title', "invalid name '$title'" ); // NOTE: As of MW 1.34, [[#]] is rendered as a valid link, pointing to the empty // page title, effectively leading to the wiki's main page. This means that a completely // empty TitleValue has to be considered valid, for consistency with Title. // Also note that [[#foo]] is a valid on-page section links, and that [[acme:#foo]] is // a valid interwiki link. Assert::parameter( $title !== '' || $namespace === NS_MAIN, '$title', 'should not be empty unless namespace is main' ); } public function getNamespace(): int { return $this->namespace; } public function getFragment(): string { return $this->fragment; } public function getDBkey(): string { return $this->dbkey; } public function createFragmentTarget( string $fragment ): self { return new TitleValue( $this->namespace, $this->dbkey, $fragment, $this->interwiki ); } public function getInterwiki(): string { return $this->interwiki; } /** * Returns a string representation of the title, for logging. This is purely informative * and must not be used programmatically. Use the appropriate TitleFormatter to generate * the correct string representation for a given use. * * @since 1.23 * @return string */ public function __toString(): string { $name = $this->namespace . ':' . $this->dbkey; if ( $this->fragment !== '' ) { $name .= '#' . $this->fragment; } if ( $this->interwiki !== '' ) { $name = $this->interwiki . ':' . $name; } return $name; } } /** @deprecated class alias since 1.41 */ class_alias( TitleValue::class, 'TitleValue' ); PK ! ps4r�� �� Title.phpnu �Iw�� <?php /** * Representation of a title within MediaWiki. * * See Title.md * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use HTMLCacheUpdateJob; use InvalidArgumentException; use MapCacheLRU; use MediaWiki\Cache\LinkCache; use MediaWiki\Context\RequestContext; use MediaWiki\DAO\WikiAwareEntityTrait; use MediaWiki\Deferred\AutoCommitUpdate; use MediaWiki\Deferred\DeferredUpdates; use MediaWiki\HookContainer\HookRunner; use MediaWiki\Html\Html; use MediaWiki\Interwiki\InterwikiLookup; use MediaWiki\Language\ILanguageConverter; use MediaWiki\Language\Language; use MediaWiki\Linker\LinkTarget; use MediaWiki\MainConfigNames; use MediaWiki\MediaWikiServices; use MediaWiki\Message\Message; use MediaWiki\Page\ExistingPageRecord; use MediaWiki\Page\PageIdentity; use MediaWiki\Page\PageIdentityValue; use MediaWiki\Page\PageReference; use MediaWiki\Page\PageStoreRecord; use MediaWiki\Page\ProperPageIdentity; use MediaWiki\Parser\Sanitizer; use MediaWiki\Request\PathRouter; use MediaWiki\ResourceLoader\WikiModule; use MediaWiki\SpecialPage\SpecialPage; use MediaWiki\Utils\MWTimestamp; use MessageLocalizer; use MWException; use RuntimeException; use stdClass; use Stringable; use Wikimedia\Assert\Assert; use Wikimedia\Assert\PreconditionException; use Wikimedia\Parsoid\Core\LinkTarget as ParsoidLinkTarget; use Wikimedia\Parsoid\Core\LinkTargetTrait; use Wikimedia\Rdbms\DBAccessObjectUtils; use Wikimedia\Rdbms\IConnectionProvider; use Wikimedia\Rdbms\IDatabase; use Wikimedia\Rdbms\IDBAccessObject; use WikiPage; /** * Represents a title within MediaWiki. * Optionally may contain an interwiki designation or namespace. * @note This class can fetch various kinds of data from the database; * however, it does so inefficiently. * @note Consider using a TitleValue object instead. TitleValue is more lightweight * and does not rely on global state or the database. */ class Title implements Stringable, LinkTarget, PageIdentity { use WikiAwareEntityTrait; use LinkTargetTrait; /** @var MapCacheLRU|null */ private static $titleCache = null; /** * Title::newFromText maintains a cache to avoid expensive re-normalization of * commonly used titles. On a batch operation this can become a memory leak * if not bounded. */ private const CACHE_MAX = 1000; /** * Flag for use with factory methods like newFromLinkTarget() that have * a $forceClone parameter. If set, the method must return a new instance. * Without this flag, some factory methods may return existing instances.as * * @since 1.33 */ public const NEW_CLONE = 'clone'; /** @var string Text form (spaces not underscores) of the main part */ private $mTextform = ''; /** @var string URL-encoded form of the main part */ private $mUrlform = ''; /** @var string Main part with underscores */ private $mDbkeyform = ''; /** @var int Namespace index, i.e. one of the NS_xxxx constants */ private $mNamespace = NS_MAIN; /** @var string Interwiki prefix */ private $mInterwiki = ''; /** @var bool Was this Title created from a string with a local interwiki prefix? */ private $mLocalInterwiki = false; /** @var string Title fragment (i.e. the bit after the #) */ private $mFragment = ''; /***************************************************************************/ // region Private member variables /** @name Private member variables * Please use the accessor functions instead. * @internal * @{ */ /** @var int Article ID, fetched from the link cache on demand */ public $mArticleID = -1; /** @var int|false ID of most recent revision */ protected $mLatestID = false; /** * @var string|false ID of the page's content model, i.e. one of the * CONTENT_MODEL_XXX constants */ private $mContentModel = false; /** * @var bool If a content model was forced via setContentModel() * this will be true to avoid having other code paths reset it */ private $mForcedContentModel = false; /** @var int|null Estimated number of revisions; null of not loaded */ private $mEstimateRevisions; /** * Text form including namespace/interwiki, initialised on demand * * Only public to share cache with TitleFormatter * * @internal * @var string|null */ public $prefixedText = null; /** * Namespace to assume when no namespace was passed to factory methods. * This must be NS_MAIN, as it's hardcoded in several places. See T2696. * Used primarily for {{transclusion}} tags. */ private const DEFAULT_NAMESPACE = NS_MAIN; /** @var int The page length, 0 for special pages */ protected $mLength = -1; /** @var null|bool Is the article at this title a redirect? */ public $mRedirect = null; /** @var bool Whether a page has any subpages */ private $mHasSubpages; /** @var array|null The (string) language code of the page's language and content code. */ private $mPageLanguage; /** @var string|false|null The page language code from the database, null if not saved in * the database or false if not loaded, yet. */ private $mDbPageLanguage = false; /** @var TitleValue|null */ private $mTitleValue = null; /** @var bool|null Would deleting this page be a big deletion? */ private $mIsBigDeletion = null; /** @var bool|null Is the title known to be valid? */ private $mIsValid = null; /** @var string|null The key of this instance in the internal Title instance cache */ private $mInstanceCacheKey = null; // endregion -- end of private member variables /** @} */ /***************************************************************************/ /** * Shorthand for getting a Language Converter for specific language * @param Language $language Language of converter * @return ILanguageConverter */ private function getLanguageConverter( $language ): ILanguageConverter { return MediaWikiServices::getInstance()->getLanguageConverterFactory() ->getLanguageConverter( $language ); } /** * Shorthand for getting a Language Converter for page's language * @return ILanguageConverter */ private function getPageLanguageConverter(): ILanguageConverter { return $this->getLanguageConverter( $this->getPageLanguage() ); } /** * Shorthand for getting a database connection provider * @return IConnectionProvider */ private function getDbProvider(): IConnectionProvider { return MediaWikiServices::getInstance()->getConnectionProvider(); } /** * B/C kludge: provide a TitleParser for use by Title. * Ideally, Title would have no methods that need this. * Avoid usage of this singleton by using TitleValue * and the associated services when possible. * * @return TitleFormatter */ private static function getTitleFormatter() { return MediaWikiServices::getInstance()->getTitleFormatter(); } /** * B/C kludge: provide an InterwikiLookup for use by Title. * Ideally, Title would have no methods that need this. * Avoid usage of this singleton by using TitleValue * and the associated services when possible. * * @return InterwikiLookup */ private static function getInterwikiLookup() { return MediaWikiServices::getInstance()->getInterwikiLookup(); } private function __construct() { } /** * Create a new Title from a prefixed DB key * * @param string $key The database key, which has underscores * instead of spaces, possibly including namespace and * interwiki prefixes * @return Title|null Title, or null on an error */ public static function newFromDBkey( $key ) { $t = new self(); try { $t->secureAndSplit( $key ); return $t; } catch ( MalformedTitleException $ex ) { return null; } } /** * Returns a Title given a LinkTarget. * If the given LinkTarget is already a Title instance, that instance is returned, * unless $forceClone is "clone". If $forceClone is "clone" and the given LinkTarget * is already a Title instance, that instance is copied using the clone operator. * * @since 1.27 * @param ParsoidLinkTarget $linkTarget Assumed to be safe. * @param string $forceClone set to NEW_CLONE to ensure a fresh instance is returned. * @return Title */ public static function newFromLinkTarget( ParsoidLinkTarget $linkTarget, $forceClone = '' ) { if ( $linkTarget instanceof Title ) { // Special case if it's already a Title object if ( $forceClone === self::NEW_CLONE ) { return clone $linkTarget; } else { return $linkTarget; } } return self::makeTitle( $linkTarget->getNamespace(), $linkTarget->getText(), $linkTarget->getFragment(), $linkTarget->getInterwiki() ); } /** * Same as newFromLinkTarget(), but if passed null, returns null. * * @since 1.34 * @param ParsoidLinkTarget|null $linkTarget Assumed to be safe (if not null). * @return Title|null */ public static function castFromLinkTarget( ?ParsoidLinkTarget $linkTarget ) { if ( !$linkTarget ) { return null; } return self::newFromLinkTarget( $linkTarget ); } /** * Return a Title for a given PageIdentity. If $pageIdentity is a Title, * that Title is returned unchanged. * * @since 1.41 * @param PageIdentity $pageIdentity * @return Title */ public static function newFromPageIdentity( PageIdentity $pageIdentity ): Title { return self::newFromPageReference( $pageIdentity ); } /** * Same as newFromPageIdentity(), but if passed null, returns null. * * @since 1.36 * @param PageIdentity|null $pageIdentity * @return Title|null */ public static function castFromPageIdentity( ?PageIdentity $pageIdentity ): ?Title { return self::castFromPageReference( $pageIdentity ); } /** * Return a Title for a given Reference. If $pageReference is a Title, * that Title is returned unchanged. * * @since 1.41 * @param PageReference $pageReference * @return Title */ public static function newFromPageReference( PageReference $pageReference ): Title { if ( $pageReference instanceof Title ) { return $pageReference; } $pageReference->assertWiki( self::LOCAL ); $title = self::makeTitle( $pageReference->getNamespace(), $pageReference->getDBkey() ); if ( $pageReference instanceof PageIdentity ) { $title->mArticleID = $pageReference->getId(); } return $title; } /** * Same as newFromPageReference(), but if passed null, returns null. * * @since 1.37 * @param PageReference|null $pageReference * @return Title|null */ public static function castFromPageReference( ?PageReference $pageReference ): ?Title { if ( !$pageReference ) { return null; } return self::newFromPageReference( $pageReference ); } /** * Create a new Title from text, such as what one would find in a link. * Decodes any HTML entities in the text. * Titles returned by this method are guaranteed to be valid. * Call canExist() to check if the Title represents an editable page. * * @note The Title instance returned by this method is not guaranteed to be a fresh instance. * It may instead be a cached instance created previously, with references to it remaining * elsewhere. * * @param string|int|null $text The link text; spaces, prefixes, and an * initial ':' indicating the main namespace are accepted. * @param int $defaultNamespace The namespace to use if none is specified * by a prefix. If you want to force a specific namespace even if * $text might begin with a namespace prefix, use makeTitle() or * makeTitleSafe(). * @return Title|null Title or null if the Title could not be parsed because * it is invalid. */ public static function newFromText( $text, $defaultNamespace = NS_MAIN ) { // DWIM: Integers can be passed in here when page titles are used as array keys. if ( $text !== null && !is_string( $text ) && !is_int( $text ) ) { throw new InvalidArgumentException( '$text must be a string.' ); } if ( $text === null || $text === '' ) { return null; } try { return self::newFromTextThrow( (string)$text, (int)$defaultNamespace ); } catch ( MalformedTitleException $ex ) { return null; } } /** * Like Title::newFromText(), but throws MalformedTitleException when the title is invalid, * rather than returning null. * * Titles returned by this method are guaranteed to be valid. * Call canExist() to check if the Title represents an editable page. * * @note The Title instance returned by this method is not guaranteed to be a fresh instance. * It may instead be a cached instance created previously, with references to it remaining * elsewhere. * * @see Title::newFromText * * @since 1.25 * @param string $text Title text to check * @param int $defaultNamespace * @throws MalformedTitleException If the title is invalid. * @return Title */ public static function newFromTextThrow( $text, $defaultNamespace = NS_MAIN ) { if ( is_object( $text ) ) { throw new InvalidArgumentException( '$text must be a string, given an object' ); } elseif ( $text === null ) { // Legacy code relies on MalformedTitleException being thrown in this case // TODO: fix(happens when URL with no title in it is parsed). throw new MalformedTitleException( 'title-invalid-empty' ); } $titleCache = self::getTitleCache(); // Wiki pages often contain multiple links to the same page. // Title normalization and parsing can become expensive on pages with many // links, so we can save a little time by caching them. if ( $defaultNamespace === NS_MAIN ) { $t = $titleCache->get( $text ); if ( $t ) { return $t; } } // Convert things like é ā or 〗 into normalized (T16952) text $filteredText = Sanitizer::decodeCharReferencesAndNormalize( $text ); $t = new Title(); $dbKeyForm = strtr( $filteredText, ' ', '_' ); $t->secureAndSplit( $dbKeyForm, (int)$defaultNamespace ); if ( $defaultNamespace === NS_MAIN ) { $t->mInstanceCacheKey = $text; $titleCache->set( $text, $t ); } return $t; } /** * Removes this instance from the internal title cache, so it can be modified in-place * without polluting the cache (see T281337). */ private function uncache() { if ( $this->mInstanceCacheKey !== null ) { $titleCache = self::getTitleCache(); $titleCache->clear( $this->mInstanceCacheKey ); $this->mInstanceCacheKey = null; } } /** * THIS IS NOT THE FUNCTION YOU WANT. Use Title::newFromText(). * * Example of wrong and broken code: * $title = Title::newFromURL( $request->getText( 'title' ) ); * * Example of right code: * $title = Title::newFromText( $request->getText( 'title' ) ); * * Create a new Title from URL-encoded text. Ensures that * the given title's length does not exceed the maximum. * * @param string $url The title, as might be taken from a URL * @return Title|null The new object, or null on an error */ public static function newFromURL( $url ) { $t = new Title(); # For compatibility with old buggy URLs. "+" is usually not valid in titles, # but some URLs used it as a space replacement and they still come # from some external search tools. if ( !str_contains( self::legalChars(), '+' ) ) { $url = strtr( $url, '+', ' ' ); } $dbKeyForm = strtr( $url, ' ', '_' ); try { $t->secureAndSplit( $dbKeyForm ); return $t; } catch ( MalformedTitleException $ex ) { return null; } } /** * @return MapCacheLRU */ private static function getTitleCache() { if ( self::$titleCache === null ) { self::$titleCache = new MapCacheLRU( self::CACHE_MAX ); } return self::$titleCache; } /** * Create a new Title from an article ID * * @param int $id The page_id corresponding to the Title to create * @param int $flags Bitfield of IDBAccessObject::READ_* constants * @return Title|null The new object, or null on an error */ public static function newFromID( $id, $flags = 0 ) { $pageStore = MediaWikiServices::getInstance()->getPageStore(); $dbr = DBAccessObjectUtils::getDBFromRecency( MediaWikiServices::getInstance()->getConnectionProvider(), $flags ); $row = $dbr->newSelectQueryBuilder() ->select( $pageStore->getSelectFields() ) ->from( 'page' ) ->where( [ 'page_id' => $id ] ) ->recency( $flags ) ->caller( __METHOD__ )->fetchRow(); if ( $row !== false ) { $title = self::newFromRow( $row ); } else { $title = null; } return $title; } /** * Make a Title object from a DB row * * @param stdClass $row Object database row (needs at least page_title,page_namespace) * @return Title */ public static function newFromRow( $row ) { $t = self::makeTitle( $row->page_namespace, $row->page_title ); $t->loadFromRow( $row ); return $t; } /** * Load Title object fields from a DB row. * If false is given, the title will be treated as non-existing. * * @param stdClass|false $row Database row */ public function loadFromRow( $row ) { if ( $row ) { // page found if ( isset( $row->page_id ) ) { $this->mArticleID = (int)$row->page_id; } if ( isset( $row->page_len ) ) { $this->mLength = (int)$row->page_len; } if ( isset( $row->page_is_redirect ) ) { $this->mRedirect = (bool)$row->page_is_redirect; } if ( isset( $row->page_latest ) ) { $this->mLatestID = (int)$row->page_latest; } if ( isset( $row->page_content_model ) ) { $this->lazyFillContentModel( $row->page_content_model ); } else { $this->lazyFillContentModel( false ); // lazily-load getContentModel() } if ( isset( $row->page_lang ) ) { $this->mDbPageLanguage = (string)$row->page_lang; } } else { // page not found $this->mArticleID = 0; $this->mLength = 0; $this->mRedirect = false; $this->mLatestID = 0; $this->lazyFillContentModel( false ); // lazily-load getContentModel() } } /** * Create a new Title from a namespace index and a DB key. * * It's assumed that $ns and $title are safe, for instance when * they came directly from the database or a special page name, * not from user input. * * No validation is applied. For convenience, spaces are normalized * to underscores, so that e.g. user_text fields can be used directly. * * @note This method may return Title objects that are "invalid" * according to the isValid() method. This is usually caused by * configuration changes: e.g. a namespace that was once defined is * no longer configured, or a character that was once allowed in * titles is now forbidden. * * @param int $ns The namespace of the article * @param string $title The unprefixed database key form * @param string $fragment The link fragment (after the "#") * @param string $interwiki The interwiki prefix * @return Title The new object */ public static function makeTitle( $ns, $title, $fragment = '', $interwiki = '' ) { $t = new Title(); $t->mInterwiki = $interwiki; $t->mFragment = self::normalizeFragment( $fragment ); $t->mNamespace = $ns = (int)$ns; $t->mDbkeyform = strtr( $title, ' ', '_' ); $t->mArticleID = ( $ns >= 0 ) ? -1 : 0; $t->mUrlform = wfUrlencode( $t->mDbkeyform ); $t->mTextform = strtr( $title, '_', ' ' ); return $t; } /** * Create a new Title from a namespace index and a DB key. * The parameters will be checked for validity, which is a bit slower * than makeTitle() but safer for user-provided data. * * The Title object returned by this method is guaranteed to be valid. * Call canExist() to check if the Title represents an editable page. * * @param int $ns The namespace of the article * @param string $title Database key form * @param string $fragment The link fragment (after the "#") * @param string $interwiki Interwiki prefix * @return Title|null The new object, or null on an error */ public static function makeTitleSafe( $ns, $title, $fragment = '', $interwiki = '' ) { // NOTE: ideally, this would just call makeTitle() and then isValid(), // but presently, that means more overhead on a potential performance hotspot. if ( !MediaWikiServices::getInstance()->getNamespaceInfo()->exists( $ns ) ) { return null; } $t = new Title(); $dbKeyForm = self::makeName( $ns, $title, $fragment, $interwiki, true ); try { $t->secureAndSplit( $dbKeyForm ); return $t; } catch ( MalformedTitleException $ex ) { return null; } } /** * Create a new Title for the Main Page * * This uses the 'mainpage' interface message, which could be specified in * `$wgForceUIMsgAsContentMsg`. If that is the case, then calling this method * will use the user language, which would involve initialising the session * via `RequestContext::getMain()->getLanguage()`. For session-less endpoints, * be sure to pass in a MessageLocalizer (such as your own RequestContext or * ResourceLoader Context) to prevent an error. * * @note The Title instance returned by this method is not guaranteed to be a fresh instance. * It may instead be a cached instance created previously, with references to it remaining * elsewhere. * * @param MessageLocalizer|null $localizer An optional context to use (since 1.34) * @return Title */ public static function newMainPage( ?MessageLocalizer $localizer = null ) { static $recursionGuard = false; $title = null; if ( !$recursionGuard ) { $msg = $localizer ? $localizer->msg( 'mainpage' ) : wfMessage( 'mainpage' ); $recursionGuard = true; $title = self::newFromText( $msg->inContentLanguage()->text() ); $recursionGuard = false; } // Every page renders at least one link to the Main Page (e.g. sidebar). // Don't produce fatal errors that would make the wiki inaccessible, and hard to fix the // invalid message. // // Fallback scenarios: // * Recursion guard // If the message contains a bare local interwiki (T297571), then // Title::newFromText via MediaWikiTitleCodec::splitTitleString can get back here. // * Invalid title // If the 'mainpage' message contains something that is invalid, Title::newFromText // will return null. return $title ?? self::makeTitle( NS_MAIN, 'Main Page' ); } /** * Get a regex character class describing the legal characters in a link * * @return string The list of characters, not delimited */ public static function legalChars() { global $wgLegalTitleChars; return $wgLegalTitleChars; } /** * Utility method for converting a character sequence from bytes to Unicode. * * Primary usecase being converting $wgLegalTitleChars to a sequence usable in * javascript, as PHP uses UTF-8 bytes where javascript uses Unicode code units. * * @param string $byteClass * @return string */ public static function convertByteClassToUnicodeClass( $byteClass ) { $length = strlen( $byteClass ); // Input token queue $x0 = $x1 = $x2 = ''; // Decoded queue $d0 = $d1 = ''; // Decoded integer codepoints $ord0 = $ord1 = $ord2 = 0; // Re-encoded queue $r0 = $r1 = $r2 = ''; // Output $out = ''; // Flags $allowUnicode = false; for ( $pos = 0; $pos < $length; $pos++ ) { // Shift the queues down $x2 = $x1; $x1 = $x0; $d1 = $d0; $ord2 = $ord1; $ord1 = $ord0; $r2 = $r1; $r1 = $r0; // Load the current input token and decoded values $inChar = $byteClass[$pos]; if ( $inChar === '\\' ) { if ( preg_match( '/x([0-9a-fA-F]{2})/A', $byteClass, $m, 0, $pos + 1 ) ) { $x0 = $inChar . $m[0]; $d0 = chr( hexdec( $m[1] ) ); $pos += strlen( $m[0] ); } elseif ( preg_match( '/[0-7]{3}/A', $byteClass, $m, 0, $pos + 1 ) ) { $x0 = $inChar . $m[0]; $d0 = chr( octdec( $m[0] ) ); $pos += strlen( $m[0] ); } elseif ( $pos + 1 >= $length ) { $x0 = $d0 = '\\'; } else { $d0 = $byteClass[$pos + 1]; $x0 = $inChar . $d0; $pos++; } } else { $x0 = $d0 = $inChar; } $ord0 = ord( $d0 ); // Load the current re-encoded value if ( $ord0 < 32 || $ord0 == 0x7f ) { $r0 = sprintf( '\x%02x', $ord0 ); } elseif ( $ord0 >= 0x80 ) { // Allow unicode if a single high-bit character appears $r0 = sprintf( '\x%02x', $ord0 ); $allowUnicode = true; // @phan-suppress-next-line PhanParamSuspiciousOrder false positive } elseif ( strpos( '-\\[]^', $d0 ) !== false ) { $r0 = '\\' . $d0; } else { $r0 = $d0; } // Do the output if ( $x0 !== '' && $x1 === '-' && $x2 !== '' ) { // Range if ( $ord2 > $ord0 ) { // Empty range } elseif ( $ord0 >= 0x80 ) { // Unicode range $allowUnicode = true; if ( $ord2 < 0x80 ) { // Keep the non-unicode section of the range $out .= "$r2-\\x7F"; } } else { // Normal range $out .= "$r2-$r0"; } // Reset state to the initial value // @phan-suppress-next-line PhanPluginRedundantAssignmentInLoop $x0 = $x1 = $d0 = $d1 = $r0 = $r1 = ''; } elseif ( $ord2 < 0x80 ) { // ASCII character $out .= $r2; } } // @phan-suppress-next-line PhanSuspiciousValueComparison if ( $ord1 < 0x80 ) { $out .= $r1; } if ( $ord0 < 0x80 ) { $out .= $r0; } if ( $allowUnicode ) { $out .= '\u0080-\uFFFF'; } return $out; } /** * Make a prefixed DB key from a DB key and a namespace index * * @param int $ns Numerical representation of the namespace * @param string $title The DB key form the title * @param string $fragment The link fragment (after the "#") * @param string $interwiki The interwiki prefix * @param bool $canonicalNamespace If true, use the canonical name for * $ns instead of the localized version. * @return string The prefixed form of the title */ public static function makeName( $ns, $title, $fragment = '', $interwiki = '', $canonicalNamespace = false ) { if ( $canonicalNamespace ) { $namespace = MediaWikiServices::getInstance()->getNamespaceInfo()-> getCanonicalName( $ns ); } else { $namespace = MediaWikiServices::getInstance()->getContentLanguage()->getNsText( $ns ); } if ( $namespace === false ) { // See T165149. Awkward, but better than erroneously linking to the main namespace. $namespace = self::makeName( NS_SPECIAL, "Badtitle/NS$ns", '', '', $canonicalNamespace ); } $name = $namespace === '' ? $title : "$namespace:$title"; if ( strval( $interwiki ) != '' ) { $name = "$interwiki:$name"; } if ( strval( $fragment ) != '' ) { $name .= '#' . $fragment; } return $name; } /** * Callback for usort() to do title sorts by (namespace, title) * * @param LinkTarget|PageReference $a * @param LinkTarget|PageReference $b * * @return int Result of string comparison, or namespace comparison */ public static function compare( $a, $b ) { return $a->getNamespace() <=> $b->getNamespace() ?: strcmp( $a->getDBkey(), $b->getDBkey() ); } /** * Returns true if the title is a valid link target, and that it has been * properly normalized. This method checks that the title is syntactically valid, * and that the namespace it refers to exists. * * Titles constructed using newFromText() or makeTitleSafe() are always valid. * * @note Code that wants to check whether the title can represent a page that can * be created and edited should use canExist() instead. Examples of valid titles * that cannot "exist" are Special pages, interwiki links, and on-page section links * that only have the fragment part set. * * @see canExist() * * @return bool */ public function isValid() { if ( $this->mIsValid !== null ) { return $this->mIsValid; } try { // Optimization: Avoid Title::getFullText because that involves GenderCache // and (unbatched) database queries. For validation, canonical namespace suffices. $text = self::makeName( $this->mNamespace, $this->mDbkeyform, $this->mFragment, $this->mInterwiki, true ); $titleCodec = MediaWikiServices::getInstance()->getTitleParser(); '@phan-var MediaWikiTitleCodec $titleCodec'; $parts = $titleCodec->splitTitleString( $text, $this->mNamespace ); // Check that nothing changed! // This ensures that $text was already properly normalized. if ( $parts['fragment'] !== $this->mFragment || $parts['interwiki'] !== $this->mInterwiki || $parts['local_interwiki'] !== $this->mLocalInterwiki || $parts['namespace'] !== $this->mNamespace || $parts['dbkey'] !== $this->mDbkeyform ) { $this->mIsValid = false; return $this->mIsValid; } } catch ( MalformedTitleException $ex ) { $this->mIsValid = false; return $this->mIsValid; } $this->mIsValid = true; return $this->mIsValid; } /** * Determine whether the object refers to a page within * this project (either this wiki or a wiki with a local * interwiki, see https://www.mediawiki.org/wiki/Manual:Interwiki_table#iw_local ) * * @return bool True if this is an in-project interwiki link or a wikilink, false otherwise */ public function isLocal() { if ( $this->isExternal() ) { $iw = self::getInterwikiLookup()->fetch( $this->mInterwiki ); if ( $iw ) { return $iw->isLocal(); } } return true; } /** * Get the interwiki prefix * * Use Title::isExternal to check if a interwiki is set * * @return string Interwiki prefix */ public function getInterwiki(): string { return $this->mInterwiki; } /** * Was this a local interwiki link? * * @return bool */ public function wasLocalInterwiki() { return $this->mLocalInterwiki; } /** * Determine whether the object refers to a page within * this project and is transcludable. * * @return bool True if this is transcludable */ public function isTrans() { if ( !$this->isExternal() ) { return false; } return self::getInterwikiLookup()->fetch( $this->mInterwiki )->isTranscludable(); } /** * Returns the DB name of the distant wiki which owns the object. * * @return string|false The DB name */ public function getTransWikiID() { if ( !$this->isExternal() ) { return false; } return self::getInterwikiLookup()->fetch( $this->mInterwiki )->getWikiID(); } /** * Get a TitleValue object representing this Title. * * @note Not all valid Titles have a corresponding valid TitleValue * (e.g. TitleValues cannot represent page-local links that have a * fragment but no title text). * * @return TitleValue|null */ public function getTitleValue() { if ( $this->mTitleValue === null ) { try { $this->mTitleValue = new TitleValue( $this->mNamespace, $this->mDbkeyform, $this->mFragment, $this->mInterwiki ); } catch ( InvalidArgumentException $ex ) { wfDebug( __METHOD__ . ': Can\'t create a TitleValue for [[' . $this->getPrefixedText() . ']]: ' . $ex->getMessage() ); } } return $this->mTitleValue; } /** * Get the text form (spaces not underscores) of the main part * * @return string Main part of the title */ public function getText(): string { return $this->mTextform; } /** * Get the URL-encoded form of the main part * * @return string Main part of the title, URL-encoded */ public function getPartialURL() { return $this->mUrlform; } /** * Get the main part with underscores * * @return string Main part of the title, with underscores */ public function getDBkey(): string { return $this->mDbkeyform; } /** * Get the namespace index, i.e. one of the NS_xxxx constants. * * @return int Namespace index */ public function getNamespace(): int { return $this->mNamespace; } /** * @param int $flags * * @return bool Whether $flags indicates that the latest information should be * read from the primary database, bypassing caches. */ private function shouldReadLatest( int $flags ) { return ( $flags & ( IDBAccessObject::READ_LATEST ) ) > 0; } /** * Get the page's content model id, see the CONTENT_MODEL_XXX constants. * * @todo Deprecate this in favor of SlotRecord::getModel() * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return string Content model id */ public function getContentModel( $flags = 0 ) { if ( $this->mForcedContentModel ) { if ( !$this->mContentModel ) { throw new RuntimeException( 'Got out of sync; an empty model is being forced' ); } // Content model is locked to the currently loaded one return $this->mContentModel; } if ( $this->shouldReadLatest( $flags ) || !$this->mContentModel ) { $this->lazyFillContentModel( $this->getFieldFromPageStore( 'page_content_model', $flags ) ); } if ( !$this->mContentModel ) { $slotRoleregistry = MediaWikiServices::getInstance()->getSlotRoleRegistry(); $mainSlotHandler = $slotRoleregistry->getRoleHandler( 'main' ); $this->lazyFillContentModel( $mainSlotHandler->getDefaultModel( $this ) ); } return $this->mContentModel; } /** * Convenience method for checking a title's content model name * * @param string $id The content model ID (use the CONTENT_MODEL_XXX constants). * @return bool True if $this->getContentModel() == $id */ public function hasContentModel( $id ) { return $this->getContentModel() == $id; } /** * Set a proposed content model for the page for permissions checking * * This does not actually change the content model of a title in the DB. * It only affects this particular Title instance. The content model is * forced to remain this value until another setContentModel() call. * * ContentHandler::canBeUsedOn() should be checked before calling this * if there is any doubt regarding the applicability of the content model * * @warning This must only be used if the caller controls the further use of * this Title object, to avoid other code unexpectedly using the new value. * * @since 1.28 * @param string $model CONTENT_MODEL_XXX constant */ public function setContentModel( $model ) { if ( (string)$model === '' ) { throw new InvalidArgumentException( "Missing CONTENT_MODEL_* constant" ); } $this->uncache(); $this->mContentModel = $model; $this->mForcedContentModel = true; } /** * If the content model field is not frozen then update it with a retrieved value * * @param string|bool $model CONTENT_MODEL_XXX constant or false */ private function lazyFillContentModel( $model ) { if ( !$this->mForcedContentModel ) { $this->mContentModel = ( $model === false ) ? false : (string)$model; } } /** * Get the namespace text * * @return string|false Namespace name with underscores (not spaces), e.g. 'User_talk' */ public function getNsText() { if ( $this->isExternal() ) { // This probably shouldn't even happen, except for interwiki transclusion. // If possible, use the canonical name for the foreign namespace. if ( $this->mNamespace === NS_MAIN ) { // Optimisation return ''; } else { $nsText = MediaWikiServices::getInstance()->getNamespaceInfo()-> getCanonicalName( $this->mNamespace ); if ( $nsText !== false ) { return $nsText; } } } try { $formatter = self::getTitleFormatter(); return $formatter->getNamespaceName( $this->mNamespace, $this->mDbkeyform ); } catch ( InvalidArgumentException $ex ) { wfDebug( __METHOD__ . ': ' . $ex->getMessage() ); return false; } } /** * Get the namespace text of the subject (rather than talk) page * * @return string Namespace name with underscores (not spaces) */ public function getSubjectNsText() { $services = MediaWikiServices::getInstance(); return $services->getContentLanguage()-> getNsText( $services->getNamespaceInfo()->getSubject( $this->mNamespace ) ); } /** * Get the namespace text of the talk page * * @return string Namespace name with underscores (not spaces) */ public function getTalkNsText() { $services = MediaWikiServices::getInstance(); return $services->getContentLanguage()-> getNsText( $services->getNamespaceInfo()->getTalk( $this->mNamespace ) ); } /** * Can this title have a corresponding talk page? * * False for relative section links (with getText() === ''), * interwiki links (with getInterwiki() !== ''), and pages in NS_SPECIAL. * * @see NamespaceInfo::canHaveTalkPage * @since 1.30 * * @return bool True if this title either is a talk page or can have a talk page associated. */ public function canHaveTalkPage() { return MediaWikiServices::getInstance()->getNamespaceInfo()->canHaveTalkPage( $this ); } /** * Can this title represent a page in the wiki's database? * * Titles can exist as pages in the database if they are valid, and they * are not Special pages, interwiki links, or fragment-only links. * * @see isValid() * * @return bool true if and only if this title can be used to perform an edit. */ public function canExist(): bool { // NOTE: Don't use getArticleID(), we don't want to // trigger a database query here. This check is supposed to // act as an optimization, not add extra cost. if ( $this->mArticleID > 0 ) { // It exists, so it can exist. return true; } // NOTE: we call the relatively expensive isValid() method further down, // but we can bail out early if we already know the title is invalid. if ( $this->mIsValid === false ) { // It's invalid, so it can't exist. return false; } if ( $this->getNamespace() < NS_MAIN ) { // It's a special page, so it can't exist in the database. return false; } if ( $this->isExternal() ) { // If it's external, it's not local, so it can't exist. return false; } if ( $this->getText() === '' ) { // The title has no text, so it can't exist in the database. // It's probably an on-page section link, like "#something". return false; } // Double check that the title is valid. return $this->isValid(); } /** * Returns true if this is a special page. * * @return bool */ public function isSpecialPage() { return $this->mNamespace === NS_SPECIAL; } /** * Returns true if this title resolves to the named special page * * @param string $name The special page name * @return bool */ public function isSpecial( $name ) { if ( $this->isSpecialPage() ) { [ $thisName, /* $subpage */ ] = MediaWikiServices::getInstance()->getSpecialPageFactory()-> resolveAlias( $this->mDbkeyform ); if ( $name == $thisName ) { return true; } } return false; } /** * If the Title refers to a special page alias which is not the local default, resolve * the alias, and localise the name as necessary. Otherwise, return $this * * @return Title */ public function fixSpecialName() { if ( $this->isSpecialPage() ) { $spFactory = MediaWikiServices::getInstance()->getSpecialPageFactory(); [ $canonicalName, $par ] = $spFactory->resolveAlias( $this->mDbkeyform ); if ( $canonicalName ) { $localName = $spFactory->getLocalNameFor( $canonicalName, $par ); if ( $localName != $this->mDbkeyform ) { return self::makeTitle( NS_SPECIAL, $localName ); } } } return $this; } /** * Returns true if the title is inside the specified namespace. * * @param int $ns The namespace * @return bool * @since 1.19 */ public function inNamespace( int $ns ): bool { return MediaWikiServices::getInstance()->getNamespaceInfo()-> equals( $this->mNamespace, $ns ); } /** * Returns true if the title is inside one of the specified namespaces. * * @param int|int[] ...$namespaces The namespaces to check for * @return bool * @since 1.19 */ public function inNamespaces( ...$namespaces ) { if ( count( $namespaces ) > 0 && is_array( $namespaces[0] ) ) { $namespaces = $namespaces[0]; } foreach ( $namespaces as $ns ) { if ( $this->inNamespace( $ns ) ) { return true; } } return false; } /** * Returns true if the title has the same subject namespace as the * namespace specified. * For example this method will take NS_USER and return true if namespace * is either NS_USER or NS_USER_TALK since both of them have NS_USER * as their subject namespace. * * This is MUCH simpler than individually testing for equivalence * against both NS_USER and NS_USER_TALK, and is also forward compatible. * @since 1.19 * @param int $ns * @return bool */ public function hasSubjectNamespace( $ns ) { return MediaWikiServices::getInstance()->getNamespaceInfo()-> subjectEquals( $this->mNamespace, $ns ); } /** * Is this Title in a namespace which contains content? * In other words, is this a content page, for the purposes of calculating * statistics, etc? * * @return bool */ public function isContentPage() { return MediaWikiServices::getInstance()->getNamespaceInfo()-> isContent( $this->mNamespace ); } /** * Would anybody with sufficient privileges be able to move this page? * Some pages just aren't movable. * * @return bool */ public function isMovable() { $services = MediaWikiServices::getInstance(); if ( !$services->getNamespaceInfo()-> isMovable( $this->mNamespace ) || $this->isExternal() ) { // Interwiki title or immovable namespace. Hooks don't get to override here return false; } $result = true; ( new HookRunner( $services->getHookContainer() ) )->onTitleIsMovable( $this, $result ); return $result; } /** * Is this the mainpage? * @see T302186 * * @since 1.18 * @return bool */ public function isMainPage() { /** @var Title|null */ static $cachedMainPage; $cachedMainPage ??= self::newMainPage(); return $this->equals( $cachedMainPage ); } /** * Is this a subpage? * * @return bool */ public function isSubpage() { return MediaWikiServices::getInstance() ->getNamespaceInfo() ->hasSubpages( $this->mNamespace ) && str_contains( $this->getText(), '/' ); } /** * Is this a conversion table for the LanguageConverter? * * @return bool */ public function isConversionTable() { // @todo ConversionTable should become a separate content model. // @todo And the prefix should be localized, too! return $this->mNamespace === NS_MEDIAWIKI && str_starts_with( $this->getText(), 'Conversiontable/' ); } /** * Does that page contain wikitext, or it is JS, CSS or whatever? * * @return bool */ public function isWikitextPage() { return $this->hasContentModel( CONTENT_MODEL_WIKITEXT ); } /** * Could this MediaWiki namespace page contain custom CSS, JSON, or JavaScript for the * global UI. This is generally true for pages in the MediaWiki namespace having * CONTENT_MODEL_CSS, CONTENT_MODEL_JSON, or CONTENT_MODEL_JAVASCRIPT. * * This method does *not* return true for per-user JS/JSON/CSS. Use isUserConfigPage() * for that! * * Note that this method should not return true for pages that contain and show * "inactive" CSS, JSON, or JS. * * @return bool * @since 1.31 */ public function isSiteConfigPage() { return ( $this->isSiteCssConfigPage() || $this->isSiteJsonConfigPage() || $this->isSiteJsConfigPage() ); } /** * Is this a "config" (.css, .json, or .js) subpage of a user page? * * @return bool * @since 1.31 */ public function isUserConfigPage() { return ( $this->isUserCssConfigPage() || $this->isUserJsonConfigPage() || $this->isUserJsConfigPage() ); } /** * Trim down a .css, .json, or .js subpage title to get the corresponding skin name * * @return string Containing skin name from .css, .json, or .js subpage title * @since 1.31 */ public function getSkinFromConfigSubpage() { $text = $this->getText(); $lastSlashPos = $this->findSubpageDivider( $text, -1 ); if ( $lastSlashPos === false ) { return ''; } $lastDot = strrpos( $text, '.', $lastSlashPos ); if ( $lastDot === false ) { return ''; } return substr( $text, $lastSlashPos + 1, $lastDot - $lastSlashPos - 1 ); } /** * Is this a CSS "config" subpage of a user page? * * @return bool * @since 1.31 */ public function isUserCssConfigPage() { return ( $this->mNamespace === NS_USER && $this->isSubpage() && $this->hasContentModel( CONTENT_MODEL_CSS ) ); } /** * Is this a JSON "config" subpage of a user page? * * @return bool * @since 1.31 */ public function isUserJsonConfigPage() { return ( $this->mNamespace === NS_USER && $this->isSubpage() && $this->hasContentModel( CONTENT_MODEL_JSON ) ); } /** * Is this a JS "config" subpage of a user page? * * @return bool * @since 1.31 */ public function isUserJsConfigPage() { return ( $this->mNamespace === NS_USER && $this->isSubpage() && $this->hasContentModel( CONTENT_MODEL_JAVASCRIPT ) ); } /** * Is this a sitewide CSS "config" page? * * @return bool * @since 1.32 */ public function isSiteCssConfigPage() { return ( $this->mNamespace === NS_MEDIAWIKI && ( $this->hasContentModel( CONTENT_MODEL_CSS ) // paranoia - a MediaWiki: namespace page with mismatching extension and content // model is probably by mistake and might get handled incorrectly (see e.g. T112937) || str_ends_with( $this->mDbkeyform, '.css' ) ) ); } /** * Is this a sitewide JSON "config" page? * * @return bool * @since 1.32 */ public function isSiteJsonConfigPage() { return ( $this->mNamespace === NS_MEDIAWIKI && ( $this->hasContentModel( CONTENT_MODEL_JSON ) // paranoia - a MediaWiki: namespace page with mismatching extension and content // model is probably by mistake and might get handled incorrectly (see e.g. T112937) || str_ends_with( $this->mDbkeyform, '.json' ) ) ); } /** * Is this a sitewide JS "config" page? * * @return bool * @since 1.31 */ public function isSiteJsConfigPage() { return ( $this->mNamespace === NS_MEDIAWIKI && ( $this->hasContentModel( CONTENT_MODEL_JAVASCRIPT ) // paranoia - a MediaWiki: namespace page with mismatching extension and content // model is probably by mistake and might get handled incorrectly (see e.g. T112937) || str_ends_with( $this->mDbkeyform, '.js' ) ) ); } /** * Is this a message which can contain raw HTML? * * @return bool * @since 1.32 */ public function isRawHtmlMessage() { global $wgRawHtmlMessages; if ( !$this->inNamespace( NS_MEDIAWIKI ) ) { return false; } $message = lcfirst( $this->getRootTitle()->getDBkey() ); return in_array( $message, $wgRawHtmlMessages, true ); } /** * Is this a talk page of some sort? * * @return bool */ public function isTalkPage() { return MediaWikiServices::getInstance()->getNamespaceInfo()-> isTalk( $this->mNamespace ); } /** * Get a Title object associated with the talk page of this article * * @deprecated since 1.34, use getTalkPageIfDefined() or NamespaceInfo::getTalkPage() * with NamespaceInfo::canHaveTalkPage(). Note that the new method will * throw if asked for the talk page of a section-only link, or of an interwiki * link. * @return Title The object for the talk page * @throws MWException if $target doesn't have talk pages, e.g. because it's in NS_SPECIAL * or because it's a relative link, or an interwiki link. */ public function getTalkPage() { // NOTE: The equivalent code in NamespaceInfo is less lenient about producing invalid titles. // Instead of failing on invalid titles, let's just log the issue for now. // See the discussion on T227817. // Is this the same title? $talkNS = MediaWikiServices::getInstance()->getNamespaceInfo()->getTalk( $this->mNamespace ); if ( $this->mNamespace == $talkNS ) { return $this; } $title = self::makeTitle( $talkNS, $this->mDbkeyform ); $this->warnIfPageCannotExist( $title, __METHOD__ ); return $title; // TODO: replace the above with the code below: // return self::castFromLinkTarget( // MediaWikiServices::getInstance()->getNamespaceInfo()->getTalkPage( $this ) ); } /** * Get a Title object associated with the talk page of this article, * if such a talk page can exist. * * @since 1.30 * * @return Title|null The object for the talk page, * or null if no associated talk page can exist, according to canHaveTalkPage(). */ public function getTalkPageIfDefined() { if ( !$this->canHaveTalkPage() ) { return null; } return $this->getTalkPage(); } /** * Get a title object associated with the subject page of this * talk page * * @deprecated since 1.34, use NamespaceInfo::getSubjectPage * @return Title The object for the subject page */ public function getSubjectPage() { // Is this the same title? $subjectNS = MediaWikiServices::getInstance()->getNamespaceInfo() ->getSubject( $this->mNamespace ); if ( $this->mNamespace == $subjectNS ) { return $this; } // NOTE: The equivalent code in NamespaceInfo is less lenient about producing invalid titles. // Instead of failing on invalid titles, let's just log the issue for now. // See the discussion on T227817. $title = self::makeTitle( $subjectNS, $this->mDbkeyform ); $this->warnIfPageCannotExist( $title, __METHOD__ ); return $title; // TODO: replace the above with the code below: // return self::castFromLinkTarget( // MediaWikiServices::getInstance()->getNamespaceInfo()->getSubjectPage( $this ) ); } /** * @param Title $title * @param string $method * * @return bool whether a warning was issued */ private function warnIfPageCannotExist( Title $title, $method ) { if ( $this->getText() == '' ) { wfLogWarning( $method . ': called on empty title ' . $this->getFullText() . ', returning ' . $title->getFullText() ); return true; } if ( $this->getInterwiki() !== '' ) { wfLogWarning( $method . ': called on interwiki title ' . $this->getFullText() . ', returning ' . $title->getFullText() ); return true; } return false; } /** * Get the other title for this page, if this is a subject page * get the talk page, if it is a subject page get the talk page * * @deprecated since 1.34, use NamespaceInfo::getAssociatedPage * @since 1.25 * @throws MWException If the page doesn't have an other page * @return Title */ public function getOtherPage() { // NOTE: Depend on the methods in this class instead of their equivalent in NamespaceInfo, // until their semantics has become exactly the same. // See the discussion on T227817. if ( $this->isSpecialPage() ) { throw new MWException( 'Special pages cannot have other pages' ); } if ( $this->isTalkPage() ) { return $this->getSubjectPage(); } else { if ( !$this->canHaveTalkPage() ) { throw new MWException( "{$this->getPrefixedText()} does not have an other page" ); } return $this->getTalkPage(); } // TODO: replace the above with the code below: // return self::castFromLinkTarget( // MediaWikiServices::getInstance()->getNamespaceInfo()->getAssociatedPage( $this ) ); } /** * Get the Title fragment (i.e.\ the bit after the #) in text form * * Use Title::hasFragment to check for a fragment * * @return string Title fragment */ public function getFragment(): string { return $this->mFragment; } /** * Get the fragment in URL form, including the "#" character if there is one * * @return string Fragment in URL form */ public function getFragmentForURL() { if ( !$this->hasFragment() ) { return ''; } elseif ( $this->isExternal() ) { // Note: If the interwiki is unknown, it's treated as a namespace on the local wiki, // so we treat it like a local interwiki. $interwiki = self::getInterwikiLookup()->fetch( $this->mInterwiki ); if ( $interwiki && !$interwiki->isLocal() ) { return '#' . Sanitizer::escapeIdForExternalInterwiki( $this->mFragment ); } } return '#' . Sanitizer::escapeIdForLink( $this->mFragment ); } /** * Set the fragment for this title. Removes the first character from the * specified fragment before setting, so it assumes you're passing it with * an initial "#". * * @warning This must only be used if the caller controls the further use of * this Title object, to avoid other code unexpectedly using the new value. * * @param string $fragment Text */ public function setFragment( $fragment ) { $this->uncache(); $this->mFragment = self::normalizeFragment( $fragment ); } /** * Creates a new Title for a different fragment of the same page. * * @since 1.27 * @param string $fragment * @return Title */ public function createFragmentTarget( string $fragment ): self { return self::makeTitle( $this->mNamespace, $this->getText(), $fragment, $this->mInterwiki ); } /** * Normalizes fragment part of the title. * * @param string $fragment * @return string */ private static function normalizeFragment( $fragment ) { if ( str_starts_with( $fragment, '#' ) ) { $fragment = substr( $fragment, 1 ); } return strtr( $fragment, '_', ' ' ); } /** * Prefix some arbitrary text with the namespace or interwiki prefix * of this object * * @param string $name The text * @return string The prefixed text */ private function prefix( $name ) { $p = ''; if ( $this->isExternal() ) { $p = $this->mInterwiki . ':'; } if ( $this->mNamespace != 0 ) { $nsText = $this->getNsText(); if ( $nsText === false ) { // See T165149. Awkward, but better than erroneously linking to the main namespace. $nsText = MediaWikiServices::getInstance()->getContentLanguage()-> getNsText( NS_SPECIAL ) . ":Badtitle/NS{$this->mNamespace}"; } $p .= $nsText . ':'; } return $p . $name; } /** * Get the prefixed database key form * * @return string The prefixed title, with underscores and * any interwiki and namespace prefixes */ public function getPrefixedDBkey() { $s = $this->prefix( $this->mDbkeyform ); $s = strtr( $s, ' ', '_' ); return $s; } /** * Get the prefixed title with spaces. * This is the form usually used for display * * @return string The prefixed title, with spaces */ public function getPrefixedText() { if ( $this->prefixedText === null ) { $s = $this->prefix( $this->mTextform ); $s = strtr( $s, '_', ' ' ); $this->prefixedText = $s; } return $this->prefixedText; } /** * Return a string representation of this title * * @return string Representation of this title */ public function __toString(): string { return $this->getPrefixedText(); } /** * Get the prefixed title with spaces, plus any fragment * (part beginning with '#') * * @return string The prefixed title, with spaces and the fragment, including '#' */ public function getFullText() { $text = $this->getPrefixedText(); if ( $this->hasFragment() ) { $text .= '#' . $this->mFragment; } return $text; } /** * Finds the first or last subpage divider (slash) in the string. * Any leading sequence of slashes is ignored, since it does not divide * two parts of the string. Considering leading slashes dividers would * result in empty root title or base title (T229443). * * Note that trailing slashes are considered dividers, and empty subpage * names are allowed. * * @param string $text * @param int $dir -1 for the last or +1 for the first divider. * * @return false|int */ private function findSubpageDivider( $text, $dir ) { if ( $dir > 0 ) { // Skip leading slashes, but keep the last one when there is nothing but slashes $bottom = strspn( $text, '/', 0, -1 ); $idx = strpos( $text, '/', $bottom ); } else { // Any slash from the end can be a divider, as subpage names can be empty $idx = strrpos( $text, '/' ); } // The first character can never be a divider, as that would result in an empty base return $idx === 0 ? false : $idx; } /** * Whether this Title's namespace has subpages enabled. * @return bool */ private function hasSubpagesEnabled() { return MediaWikiServices::getInstance()->getNamespaceInfo()-> hasSubpages( $this->mNamespace ); } /** * Get the root page name text without a namespace, i.e. the leftmost part before any slashes * * @note the return value may contain trailing whitespace and is thus * not safe for use with makeTitle or TitleValue. * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getRootText(); * # returns: 'Foo' * @endcode * * @return string Root name * @since 1.20 */ public function getRootText() { $text = $this->getText(); if ( !$this->hasSubpagesEnabled() ) { return $text; } $firstSlashPos = $this->findSubpageDivider( $text, +1 ); // Don't discard the real title if there's no subpage involved if ( $firstSlashPos === false ) { return $text; } return substr( $text, 0, $firstSlashPos ); } /** * Get the root page name title, i.e. the leftmost part before any slashes * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getRootTitle(); * # returns: Title{User:Foo} * @endcode * * @return Title * @since 1.20 */ public function getRootTitle() { $title = self::makeTitleSafe( $this->mNamespace, $this->getRootText() ); if ( !$title ) { if ( !$this->isValid() ) { // If the title wasn't valid in the first place, we can't expect // to successfully parse it. T290194 return $this; } Assert::postcondition( $title !== null, 'makeTitleSafe() should always return a Title for the text ' . 'returned by getRootText().' ); } return $title; } /** * Get the base page name without a namespace, i.e. the part before the subpage name * * @note the return value may contain trailing whitespace and is thus * not safe for use with makeTitle or TitleValue. * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getBaseText(); * # returns: 'Foo/Bar' * @endcode * * @return string Base name */ public function getBaseText() { $text = $this->getText(); if ( !$this->hasSubpagesEnabled() ) { return $text; } $lastSlashPos = $this->findSubpageDivider( $text, -1 ); // Don't discard the real title if there's no subpage involved if ( $lastSlashPos === false ) { return $text; } return substr( $text, 0, $lastSlashPos ); } /** * Get the base page name title, i.e. the part before the subpage name. * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getBaseTitle(); * # returns: Title{User:Foo/Bar} * @endcode * * @return Title * @since 1.20 */ public function getBaseTitle() { $title = self::makeTitleSafe( $this->mNamespace, $this->getBaseText() ); if ( !$title ) { if ( !$this->isValid() ) { // If the title wasn't valid in the first place, we can't expect // to successfully parse it. T290194 return $this; } Assert::postcondition( $title !== null, 'makeTitleSafe() should always return a Title for the text ' . 'returned by getBaseText().' ); } return $title; } /** * Get the lowest-level subpage name, i.e. the rightmost part after any slashes * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getSubpageText(); * # returns: "Baz" * @endcode * * @return string Subpage name */ public function getSubpageText() { $text = $this->getText(); if ( !$this->hasSubpagesEnabled() ) { return $text; } $lastSlashPos = $this->findSubpageDivider( $text, -1 ); if ( $lastSlashPos === false ) { // T256922 - Return the title text if no subpages return $text; } return substr( $text, $lastSlashPos + 1 ); } /** * Get the title for a subpage of the current page * * @par Example: * @code * Title::newFromText('User:Foo/Bar/Baz')->getSubpage("Asdf"); * # returns: Title{User:Foo/Bar/Baz/Asdf} * @endcode * * @param string $text The subpage name to add to the title * @return Title|null Subpage title, or null on an error * @since 1.20 */ public function getSubpage( $text ) { return self::makeTitleSafe( $this->mNamespace, $this->getText() . '/' . $text, '', $this->mInterwiki ); } /** * Get a URL-encoded form of the subpage text * * @return string URL-encoded subpage name */ public function getSubpageUrlForm() { $text = $this->getSubpageText(); $text = wfUrlencode( strtr( $text, ' ', '_' ) ); return $text; } /** * Get a URL-encoded title (not an actual URL) including interwiki * * @return string The URL-encoded form */ public function getPrefixedURL() { $s = $this->prefix( $this->mDbkeyform ); $s = wfUrlencode( strtr( $s, ' ', '_' ) ); return $s; } /** * Get a real URL referring to this title, with interwiki link and * fragment * * @see self::getLocalURL for the arguments. * @see \MediaWiki\Utils\UrlUtils::expand() * @param string|array $query * @param false $query2 deprecated since MW 1.19; ignored since MW 1.41 * @param string|int|null $proto Protocol type to use in URL * @return string The URL */ public function getFullURL( $query = '', $query2 = false, $proto = PROTO_RELATIVE ) { $services = MediaWikiServices::getInstance(); $query = is_array( $query ) ? wfArrayToCgi( $query ) : $query; # Hand off all the decisions on urls to getLocalURL $url = $this->getLocalURL( $query ); # Expand the url to make it a full url. Note that getLocalURL has the # potential to output full urls for a variety of reasons, so we use # UrlUtils::expand() instead of simply prepending $wgServer $url = (string)$services->getUrlUtils()->expand( $url, $proto ); # Finally, add the fragment. $url .= $this->getFragmentForURL(); ( new HookRunner( $services->getHookContainer() ) )->onGetFullURL( $this, $url, $query ); return $url; } /** * Get a url appropriate for making redirects based on an untrusted url arg * * This is basically the same as getFullUrl(), but in the case of external * interwikis, we send the user to a landing page, to prevent possible * phishing attacks and the like. * * @note Uses current protocol by default, since technically relative urls * aren't allowed in redirects per HTTP spec, so this is not suitable for * places where the url gets cached, as might pollute between * https and non-https users. * @see self::getLocalURL for the arguments. * @param array|string $query * @param string $proto Protocol type to use in URL * @return string A url suitable to use in an HTTP location header. */ public function getFullUrlForRedirect( $query = '', $proto = PROTO_CURRENT ) { $target = $this; if ( $this->isExternal() ) { $target = SpecialPage::getTitleFor( 'GoToInterwiki', $this->getPrefixedDBkey() ); } return $target->getFullURL( $query, false, $proto ); } /** * Get a URL with no fragment or server name (relative URL) from a Title object. * If this page is generated with action=render, however, * $wgServer is prepended to make an absolute URL. * * @see self::getFullURL to always get an absolute URL. * @see self::getLinkURL to always get a URL that's the simplest URL that will be * valid to link, locally, to the current Title. * @see self::newFromText to produce a Title object. * * @param string|array $query An optional query string, * not used for interwiki links. Can be specified as an associative array as well, * e.g., [ 'action' => 'edit' ] (keys and values will be URL-escaped). * Some query patterns will trigger various shorturl path replacements. * * @return string */ public function getLocalURL( $query = '' ) { global $wgArticlePath, $wgScript, $wgMainPageIsDomainRoot; $query = is_array( $query ) ? wfArrayToCgi( $query ) : $query; $services = MediaWikiServices::getInstance(); $hookRunner = new HookRunner( $services->getHookContainer() ); $interwiki = self::getInterwikiLookup()->fetch( $this->mInterwiki ); if ( $interwiki ) { $namespace = $this->getNsText(); if ( $namespace != '' ) { # Can this actually happen? Interwikis shouldn't be parsed. # Yes! It can in interwiki transclusion. But... it probably shouldn't. $namespace .= ':'; } $url = $interwiki->getURL( $namespace . $this->mDbkeyform ); $url = wfAppendQuery( $url, $query ); } else { $dbkey = wfUrlencode( $this->getPrefixedDBkey() ); if ( $query == '' ) { if ( $wgMainPageIsDomainRoot && $this->isMainPage() ) { $url = '/'; } else { $url = str_replace( '$1', $dbkey, $wgArticlePath ); } $hookRunner->onGetLocalURL__Article( $this, $url ); } else { global $wgVariantArticlePath, $wgActionPaths; $url = false; $matches = []; $articlePaths = PathRouter::getActionPaths( $wgActionPaths, $wgArticlePath ); if ( $articlePaths && preg_match( '/^(.*&|)action=([^&]*)(&(.*)|)$/', $query, $matches ) ) { $action = urldecode( $matches[2] ); if ( isset( $articlePaths[$action] ) ) { $query = $matches[1]; if ( isset( $matches[4] ) ) { $query .= $matches[4]; } $url = str_replace( '$1', $dbkey, $articlePaths[$action] ); if ( $query != '' ) { $url = wfAppendQuery( $url, $query ); } } } if ( $url === false && $wgVariantArticlePath && preg_match( '/^variant=([^&]*)$/', $query, $matches ) && $this->getPageLanguage()->equals( $services->getContentLanguage() ) && $this->getPageLanguageConverter()->hasVariants() ) { $variant = urldecode( $matches[1] ); if ( $this->getPageLanguageConverter()->hasVariant( $variant ) ) { // Only do the variant replacement if the given variant is a valid // variant for the page's language. $url = str_replace( '$2', urlencode( $variant ), $wgVariantArticlePath ); $url = str_replace( '$1', $dbkey, $url ); } } if ( $url === false ) { if ( $query == '-' ) { $query = ''; } $url = "{$wgScript}?title={$dbkey}&{$query}"; } } $hookRunner->onGetLocalURL__Internal( $this, $url, $query ); } $hookRunner->onGetLocalURL( $this, $url, $query ); return $url; } /** * Get a URL that's the simplest URL that will be valid to link, locally, * to the current Title. It includes the fragment, but does not include * the server unless action=render is used (or the link is external). If * there's a fragment but the prefixed text is empty, we just return a link * to the fragment. * * The result obviously should not be URL-escaped, but does need to be * HTML-escaped if it's being output in HTML. * * @param string|array $query * @param string|string[]|false $query2 deprecated since MW 1.19; ignored since MW 1.41 * @param string|int|false $proto A PROTO_* constant on how the URL should be expanded, * or false (default) for no expansion * @see self::getLocalURL for the arguments. * @return string The URL */ public function getLinkURL( $query = '', $query2 = false, $proto = false ) { if ( $this->isExternal() || $proto !== false ) { $ret = $this->getFullURL( $query, false, $proto ); } elseif ( $this->getPrefixedText() === '' && $this->hasFragment() ) { $ret = $this->getFragmentForURL(); } else { $ret = $this->getLocalURL( $query ) . $this->getFragmentForURL(); } return $ret; } /** * Get the URL form for an internal link. * - Used in various CDN-related code, in case we have a different * internal hostname for the server from the exposed one. * * This uses $wgInternalServer to qualify the path, or $wgServer * if $wgInternalServer is not set. If the server variable used is * protocol-relative, the URL will be expanded to http:// * * @see self::getLocalURL for the arguments. * @param string|array $query * @return string The URL */ public function getInternalURL( $query = '' ) { global $wgInternalServer, $wgServer; $services = MediaWikiServices::getInstance(); $query = is_array( $query ) ? wfArrayToCgi( $query ) : $query; $server = $wgInternalServer !== false ? $wgInternalServer : $wgServer; $url = (string)$services->getUrlUtils()->expand( $server . $this->getLocalURL( $query ), PROTO_HTTP ); ( new HookRunner( $services->getHookContainer() ) ) ->onGetInternalURL( $this, $url, $query ); return $url; } /** * Get the URL for a canonical link, for use in things like IRC and * e-mail notifications. Uses $wgCanonicalServer and the * GetCanonicalURL hook. * * NOTE: Unlike getInternalURL(), the canonical URL includes the fragment * * @see self::getLocalURL for the arguments. * @param string|array $query * @return string The URL * @since 1.18 */ public function getCanonicalURL( $query = '' ) { $services = MediaWikiServices::getInstance(); $query = is_array( $query ) ? wfArrayToCgi( $query ) : $query; $url = (string)$services->getUrlUtils()->expand( $this->getLocalURL( $query ) . $this->getFragmentForURL(), PROTO_CANONICAL ); ( new HookRunner( $services->getHookContainer() ) ) ->onGetCanonicalURL( $this, $url, $query ); return $url; } /** * Get the edit URL for this Title * * @return string The URL, or a null string if this is an interwiki link */ public function getEditURL() { if ( $this->isExternal() ) { return ''; } $s = $this->getLocalURL( 'action=edit' ); return $s; } /** * Is this title subject to title protection? * Title protection is the one applied against creation of such title. * * @deprecated since 1.37, use RestrictionStore::getCreateProtection() instead; * hard-deprecated since 1.43 * * @return array|bool An associative array representing any existent title * protection, or false if there's none. */ public function getTitleProtection() { wfDeprecated( __METHOD__, '1.37' ); return MediaWikiServices::getInstance()->getRestrictionStore()->getCreateProtection( $this ) ?: false; } /** * Remove any title protection due to page existing * * @deprecated since 1.37, do not use (this is only for WikiPage::onArticleCreate) */ public function deleteTitleProtection() { MediaWikiServices::getInstance()->getRestrictionStore()->deleteCreateProtection( $this ); } /** * Load restrictions from the page_restrictions table * * @deprecated since 1.37, no public replacement; hard-deprecated since 1.43 * * @param int $flags A bit field. If IDBAccessObject::READ_LATEST is set, skip replicas and read * from the primary DB. */ public function loadRestrictions( $flags = 0 ) { wfDeprecated( __METHOD__, '1.37' ); MediaWikiServices::getInstance()->getRestrictionStore()->loadRestrictions( $this, $flags ); } /** * Flush the protection cache in this object and force reload from the database. * This is used when updating protection from WikiPage::doUpdateRestrictions(). * * @deprecated since 1.37, now internal; hard-deprecated since 1.43 */ public function flushRestrictions() { wfDeprecated( __METHOD__, '1.37' ); MediaWikiServices::getInstance()->getRestrictionStore()->flushRestrictions( $this ); } /** * Purge expired restrictions from the page_restrictions table * * This will purge no more than $wgUpdateRowsPerQuery page_restrictions rows */ public static function purgeExpiredRestrictions() { if ( MediaWikiServices::getInstance()->getReadOnlyMode()->isReadOnly() ) { return; } DeferredUpdates::addUpdate( new AutoCommitUpdate( MediaWikiServices::getInstance()->getConnectionProvider()->getPrimaryDatabase(), __METHOD__, static function ( IDatabase $dbw, $fname ) { $config = MediaWikiServices::getInstance()->getMainConfig(); $ids = $dbw->newSelectQueryBuilder() ->select( 'pr_id' ) ->from( 'page_restrictions' ) ->where( $dbw->expr( 'pr_expiry', '<', $dbw->timestamp() ) ) ->limit( $config->get( MainConfigNames::UpdateRowsPerQuery ) ) // T135470 ->caller( $fname )->fetchFieldValues(); if ( $ids ) { $dbw->newDeleteQueryBuilder() ->deleteFrom( 'page_restrictions' ) ->where( [ 'pr_id' => $ids ] ) ->caller( $fname )->execute(); } $dbw->newDeleteQueryBuilder() ->deleteFrom( 'protected_titles' ) ->where( $dbw->expr( 'pt_expiry', '<', $dbw->timestamp() ) ) ->caller( $fname )->execute(); } ) ); } /** * Does this have subpages? (Warning, usually requires an extra DB query.) * * @return bool */ public function hasSubpages() { if ( !MediaWikiServices::getInstance()->getNamespaceInfo()-> hasSubpages( $this->mNamespace ) ) { # Duh return false; } # We dynamically add a member variable for the purpose of this method # alone to cache the result. There's no point in having it hanging # around uninitialized in every Title object; therefore we only add it # if needed and don't declare it statically. if ( $this->mHasSubpages === null ) { $subpages = $this->getSubpages( 1 ); $this->mHasSubpages = $subpages instanceof TitleArrayFromResult && $subpages->count(); } return $this->mHasSubpages; } /** * Get all subpages of this page. * * @param int $limit Maximum number of subpages to fetch; -1 for no limit * @return TitleArrayFromResult|array TitleArrayFromResult, or empty array if this page's namespace * doesn't allow subpages */ public function getSubpages( $limit = -1 ) { if ( !MediaWikiServices::getInstance()->getNamespaceInfo()-> hasSubpages( $this->mNamespace ) ) { return []; } $services = MediaWikiServices::getInstance(); $pageStore = $services->getPageStore(); $titleFactory = $services->getTitleFactory(); $query = $pageStore->newSelectQueryBuilder() ->fields( $pageStore->getSelectFields() ) ->whereTitlePrefix( $this->getNamespace(), $this->getDBkey() . '/' ) ->caller( __METHOD__ ); if ( $limit > -1 ) { $query->limit( $limit ); } return $titleFactory->newTitleArrayFromResult( $query->fetchResultSet() ); } /** * Is there a version of this page in the deletion archive? * * @deprecated since 1.36. Use self::getDeletedEditsCount() * @return int The number of archived revisions */ public function isDeleted() { return $this->getDeletedEditsCount(); } /** * Is there a version of this page in the deletion archive? * * @since 1.36 * @return int The number of archived revisions */ public function getDeletedEditsCount() { if ( $this->mNamespace < 0 ) { return 0; } $dbr = $this->getDbProvider()->getReplicaDatabase(); $n = (int)$dbr->newSelectQueryBuilder() ->select( 'COUNT(*)' ) ->from( 'archive' ) ->where( [ 'ar_namespace' => $this->mNamespace, 'ar_title' => $this->mDbkeyform ] ) ->caller( __METHOD__ )->fetchField(); if ( $this->mNamespace === NS_FILE ) { $n += $dbr->newSelectQueryBuilder() ->select( 'COUNT(*)' ) ->from( 'filearchive' ) ->where( [ 'fa_name' => $this->mDbkeyform ] ) ->caller( __METHOD__ )->fetchField(); } return $n; } /** * Is there a version of this page in the deletion archive? * * @deprecated since 1.36, Use self::hasDeletedEdits() * @return bool */ public function isDeletedQuick() { return $this->hasDeletedEdits(); } /** * Is there a version of this page in the deletion archive? * * @since 1.36 * @return bool */ public function hasDeletedEdits() { if ( $this->mNamespace < 0 ) { return false; } $dbr = $this->getDbProvider()->getReplicaDatabase(); $deleted = (bool)$dbr->newSelectQueryBuilder() ->select( '1' ) ->from( 'archive' ) ->where( [ 'ar_namespace' => $this->mNamespace, 'ar_title' => $this->mDbkeyform ] ) ->caller( __METHOD__ )->fetchField(); if ( !$deleted && $this->mNamespace === NS_FILE ) { $deleted = (bool)$dbr->newSelectQueryBuilder() ->select( '1' ) ->from( 'filearchive' ) ->where( [ 'fa_name' => $this->mDbkeyform ] ) ->caller( __METHOD__ )->fetchField(); } return $deleted; } /** * Get the article ID for this Title from the link cache, * adding it if necessary * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return int The ID */ public function getArticleID( $flags = 0 ) { if ( $this->mArticleID === -1 && !$this->canExist() ) { $this->mArticleID = 0; return $this->mArticleID; } if ( $this->mArticleID === -1 || $this->shouldReadLatest( $flags ) ) { $this->mArticleID = (int)$this->getFieldFromPageStore( 'page_id', $flags ); } return $this->mArticleID; } /** * Is this an article that is a redirect page? * Uses link cache, adding it if necessary. * * This is intended to provide fast access to page_is_redirect for linking. * In rare cases, there might not be a valid target in the redirect table * even though this function returns true. * * To find a redirect target, just call WikiPage::getRedirectTarget() and * check if it returns null, there's no need to call this first. * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return bool */ public function isRedirect( $flags = 0 ) { if ( $this->shouldReadLatest( $flags ) || $this->mRedirect === null ) { $this->mRedirect = (bool)$this->getFieldFromPageStore( 'page_is_redirect', $flags ); } return $this->mRedirect; } /** * What is the length of this page? * Uses link cache, adding it if necessary * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return int */ public function getLength( $flags = 0 ) { if ( $this->shouldReadLatest( $flags ) || $this->mLength < 0 ) { $this->mLength = (int)$this->getFieldFromPageStore( 'page_len', $flags ); } if ( $this->mLength < 0 ) { $this->mLength = 0; } return $this->mLength; } /** * What is the page_latest field for this page? * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return int Int or 0 if the page doesn't exist */ public function getLatestRevID( $flags = 0 ) { if ( $this->shouldReadLatest( $flags ) || $this->mLatestID === false ) { $this->mLatestID = (int)$this->getFieldFromPageStore( 'page_latest', $flags ); } if ( !$this->mLatestID ) { $this->mLatestID = 0; } return $this->mLatestID; } /** * Inject a page ID, reset DB-loaded fields, and clear the link cache for this title * * This can be called on page insertion to allow loading of the new page_id without * having to create a new Title instance. Likewise with deletion. * * This is also used during page moves, to reflect the change in the relationship * between article ID and title text. * * @note This overrides Title::setContentModel() * * @param int|bool $id Page ID, 0 for non-existent, or false for "unknown" (lazy-load) */ public function resetArticleID( $id ) { if ( $id === false ) { $this->mArticleID = -1; } else { $this->mArticleID = (int)$id; } $this->mRedirect = null; $this->mLength = -1; $this->mLatestID = false; $this->mContentModel = false; $this->mForcedContentModel = false; $this->mEstimateRevisions = null; $this->mPageLanguage = null; $this->mDbPageLanguage = false; $this->mIsBigDeletion = null; $this->uncache(); MediaWikiServices::getInstance()->getLinkCache()->clearLink( $this ); MediaWikiServices::getInstance()->getRestrictionStore()->flushRestrictions( $this ); } public static function clearCaches() { $linkCache = MediaWikiServices::getInstance()->getLinkCache(); $linkCache->clear(); $titleCache = self::getTitleCache(); $titleCache->clear(); } /** * Capitalize a text string for a title if it belongs to a namespace that capitalizes * * @param string $text Containing title to capitalize * @param int $ns Namespace index, defaults to NS_MAIN * @return string Containing capitalized title */ public static function capitalize( $text, $ns = NS_MAIN ) { $services = MediaWikiServices::getInstance(); if ( $services->getNamespaceInfo()->isCapitalized( $ns ) ) { return $services->getContentLanguage()->ucfirst( $text ); } else { return $text; } } /** * Secure and split - main initialisation function for this object * * Assumes that $text is urldecoded * and uses underscores, but not otherwise munged. This function * removes illegal characters, splits off the interwiki and * namespace prefixes, sets the other forms, and canonicalizes * everything. * * If this method returns normally, the Title is valid. * * @param string $text * @param int|null $defaultNamespace * * @throws MalformedTitleException On malformed titles */ private function secureAndSplit( $text, $defaultNamespace = null ) { $defaultNamespace ??= self::DEFAULT_NAMESPACE; // @note: splitTitleString() is a temporary hack to allow MediaWikiTitleCodec to share // the parsing code with Title, while avoiding massive refactoring. // @todo: get rid of secureAndSplit, refactor parsing code. // @note: getTitleParser() returns a TitleParser implementation which does not have a // splitTitleString method, but the only implementation (MediaWikiTitleCodec) does /** @var MediaWikiTitleCodec $titleCodec */ $titleCodec = MediaWikiServices::getInstance()->getTitleParser(); '@phan-var MediaWikiTitleCodec $titleCodec'; // MalformedTitleException can be thrown here $parts = $titleCodec->splitTitleString( $text, $defaultNamespace ); # Fill fields $this->setFragment( '#' . $parts['fragment'] ); $this->mInterwiki = $parts['interwiki']; $this->mLocalInterwiki = $parts['local_interwiki']; $this->mNamespace = $parts['namespace']; $this->mDbkeyform = $parts['dbkey']; $this->mUrlform = wfUrlencode( $this->mDbkeyform ); $this->mTextform = strtr( $this->mDbkeyform, '_', ' ' ); // splitTitleString() guarantees that this title is valid. $this->mIsValid = true; # We already know that some pages won't be in the database! if ( $this->isExternal() || $this->isSpecialPage() || $this->mTextform === '' ) { $this->mArticleID = 0; } } /** * Get an array of Title objects linking to this Title * Also stores the IDs in the link cache. * * WARNING: do not use this function on arbitrary user-supplied titles! * On heavily-used templates it will max out the memory. * * @param array $options May be FOR UPDATE * @param string $table Table name * @param string $prefix Fields prefix * @return Title[] */ public function getLinksTo( $options = [], $table = 'pagelinks', $prefix = 'pl' ) { if ( count( $options ) > 0 ) { $db = $this->getDbProvider()->getPrimaryDatabase(); } else { $db = $this->getDbProvider()->getReplicaDatabase(); } $linksMigration = MediaWikiServices::getInstance()->getLinksMigration(); if ( isset( $linksMigration::$mapping[$table] ) ) { $titleConds = $linksMigration->getLinksConditions( $table, $this ); } else { $titleConds = [ "{$prefix}_namespace" => $this->mNamespace, "{$prefix}_title" => $this->mDbkeyform ]; } $res = $db->newSelectQueryBuilder() ->select( LinkCache::getSelectFields() ) ->from( $table ) ->join( 'page', null, "{$prefix}_from=page_id" ) ->where( $titleConds ) ->options( $options ) ->caller( __METHOD__ ) ->fetchResultSet(); $retVal = []; if ( $res->numRows() ) { $linkCache = MediaWikiServices::getInstance()->getLinkCache(); foreach ( $res as $row ) { $titleObj = self::makeTitle( $row->page_namespace, $row->page_title ); if ( $titleObj ) { $linkCache->addGoodLinkObjFromRow( $titleObj, $row ); $retVal[] = $titleObj; } } } return $retVal; } /** * Get an array of Title objects using this Title as a template * Also stores the IDs in the link cache. * * WARNING: do not use this function on arbitrary user-supplied titles! * On heavily-used templates it will max out the memory. * * @param array $options Query option to Database::select() * @return Title[] */ public function getTemplateLinksTo( $options = [] ) { return $this->getLinksTo( $options, 'templatelinks', 'tl' ); } /** * Get an array of Title objects linked from this Title * Also stores the IDs in the link cache. * * WARNING: do not use this function on arbitrary user-supplied titles! * On heavily-used templates it will max out the memory. * * @param array $options Query option to Database::select() * @param string $table Table name * @param string $prefix Fields prefix * @return Title[] List of Titles linking here */ public function getLinksFrom( $options = [], $table = 'pagelinks', $prefix = 'pl' ) { $id = $this->getArticleID(); # If the page doesn't exist; there can't be any link from this page if ( !$id ) { return []; } $db = $this->getDbProvider()->getReplicaDatabase(); $linksMigration = MediaWikiServices::getInstance()->getLinksMigration(); $queryBuilder = $db->newSelectQueryBuilder(); if ( isset( $linksMigration::$mapping[$table] ) ) { [ $blNamespace, $blTitle ] = $linksMigration->getTitleFields( $table ); $linktargetQueryInfo = $linksMigration->getQueryInfo( $table ); $queryBuilder->queryInfo( $linktargetQueryInfo ); } else { $blNamespace = "{$prefix}_namespace"; $blTitle = "{$prefix}_title"; $queryBuilder->select( [ $blNamespace, $blTitle ] ) ->from( $table ); } $pageQuery = WikiPage::getQueryInfo(); $res = $queryBuilder ->where( [ "{$prefix}_from" => $id ] ) ->leftJoin( 'page', null, [ "page_namespace=$blNamespace", "page_title=$blTitle" ] ) ->fields( $pageQuery['fields'] ) ->options( $options ) ->caller( __METHOD__ ) ->fetchResultSet(); $retVal = []; $linkCache = MediaWikiServices::getInstance()->getLinkCache(); foreach ( $res as $row ) { if ( $row->page_id ) { $titleObj = self::newFromRow( $row ); } else { $titleObj = self::makeTitle( $row->$blNamespace, $row->$blTitle ); $linkCache->addBadLinkObj( $titleObj ); } $retVal[] = $titleObj; } return $retVal; } /** * Get an array of Title objects used on this Title as a template * Also stores the IDs in the link cache. * * WARNING: do not use this function on arbitrary user-supplied titles! * On heavily-used templates it will max out the memory. * * @param array $options May be FOR UPDATE * @return Title[] */ public function getTemplateLinksFrom( $options = [] ) { return $this->getLinksFrom( $options, 'templatelinks', 'tl' ); } /** * Locks the page row and check if this page is single revision redirect * * This updates the cached fields of this instance via Title::loadFromRow() * * @return bool */ public function isSingleRevRedirect() { $dbw = $this->getDbProvider()->getPrimaryDatabase(); $dbw->startAtomic( __METHOD__ ); $pageStore = MediaWikiServices::getInstance()->getPageStore(); $row = $dbw->newSelectQueryBuilder() ->select( $pageStore->getSelectFields() ) ->from( 'page' ) ->where( $this->pageCond() ) ->caller( __METHOD__ )->fetchRow(); // Update the cached fields $this->loadFromRow( $row ); if ( $this->mRedirect && $this->mLatestID ) { $isSingleRevRedirect = !$dbw->newSelectQueryBuilder() ->select( '1' ) ->forUpdate() ->from( 'revision' ) ->where( [ 'rev_page' => $this->mArticleID, $dbw->expr( 'rev_id', '!=', (int)$this->mLatestID ) ] ) ->caller( __METHOD__ )->fetchField(); } else { $isSingleRevRedirect = false; } $dbw->endAtomic( __METHOD__ ); return $isSingleRevRedirect; } /** * Get categories to which this Title belongs and return an array of * categories' names. * * @return string[] Array of parents in the form: * $parent => $currentarticle */ public function getParentCategories() { $data = []; $titleKey = $this->getArticleID(); if ( $titleKey === 0 ) { return $data; } $dbr = $this->getDbProvider()->getReplicaDatabase(); $res = $dbr->newSelectQueryBuilder() ->select( 'cl_to' ) ->from( 'categorylinks' ) ->where( [ 'cl_from' => $titleKey ] ) ->caller( __METHOD__ )->fetchResultSet(); if ( $res->numRows() > 0 ) { $contLang = MediaWikiServices::getInstance()->getContentLanguage(); foreach ( $res as $row ) { // $data[] = Title::newFromText( $contLang->getNsText ( NS_CATEGORY ).':'.$row->cl_to); $data[$contLang->getNsText( NS_CATEGORY ) . ':' . $row->cl_to] = $this->getFullText(); } } return $data; } /** * Get a tree of parent categories * * @param array $children Array with the children in the keys, to check for circular refs * @return array Tree of parent categories */ public function getParentCategoryTree( $children = [] ) { $stack = []; $parents = $this->getParentCategories(); if ( $parents ) { foreach ( $parents as $parent => $current ) { if ( array_key_exists( $parent, $children ) ) { # Circular reference $stack[$parent] = []; } else { $nt = self::newFromText( $parent ); if ( $nt ) { $stack[$parent] = $nt->getParentCategoryTree( $children + [ $parent => 1 ] ); } } } } return $stack; } /** * Get an associative array for selecting this title from * the "page" table * * @return array Array suitable for the $where parameter of DB::select() */ public function pageCond() { if ( $this->mArticleID > 0 ) { // PK avoids secondary lookups in InnoDB, shouldn't hurt other DBs return [ 'page_id' => $this->mArticleID ]; } else { return [ 'page_namespace' => $this->mNamespace, 'page_title' => $this->mDbkeyform ]; } } /** * Check if this is a new page. * * @note This returns false if the page does not exist. * @param int $flags one of the READ_XXX constants. * * @return bool */ public function isNewPage( $flags = IDBAccessObject::READ_NORMAL ) { // NOTE: we rely on PHP casting "0" to false here. return (bool)$this->getFieldFromPageStore( 'page_is_new', $flags ); } /** * Check whether the number of revisions of this page surpasses $wgDeleteRevisionsLimit * @deprecated since 1.37 External callers shouldn't need to know about this. * * @return bool */ public function isBigDeletion() { global $wgDeleteRevisionsLimit; if ( !$wgDeleteRevisionsLimit ) { return false; } if ( $this->mIsBigDeletion === null ) { $dbr = $this->getDbProvider()->getReplicaDatabase(); $revCount = $dbr->newSelectQueryBuilder() ->select( '1' ) ->from( 'revision' ) ->where( [ 'rev_page' => $this->getArticleID() ] ) ->limit( $wgDeleteRevisionsLimit + 1 ) ->caller( __METHOD__ )->fetchRowCount(); $this->mIsBigDeletion = $revCount > $wgDeleteRevisionsLimit; } return $this->mIsBigDeletion; } /** * Get the approximate revision count of this page. * * @return int */ public function estimateRevisionCount() { if ( !$this->exists() ) { return 0; } if ( $this->mEstimateRevisions === null ) { $dbr = $this->getDbProvider()->getReplicaDatabase(); $this->mEstimateRevisions = $dbr->newSelectQueryBuilder() ->select( '*' ) ->from( 'revision' ) ->where( [ 'rev_page' => $this->getArticleID() ] ) ->caller( __METHOD__ ) ->estimateRowCount(); } return $this->mEstimateRevisions; } /** * Compares with another Title. * * A Title object is considered equal to another Title if it has the same text, * the same interwiki prefix, and the same namespace. * * @note This is different from isSameLinkAs(), which also compares the fragment part, * and from isSamePageAs(), which takes into account the page ID. * * @phpcs:disable MediaWiki.Commenting.FunctionComment.ObjectTypeHintParam * @param Title|object $other * * @return bool true if $other is a Title and refers to the same page. */ public function equals( object $other ) { // NOTE: In contrast to isSameLinkAs(), this ignores the fragment part! // NOTE: In contrast to isSamePageAs(), this ignores the page ID! // NOTE: === is necessary for proper matching of number-like titles return $other instanceof Title && $this->getInterwiki() === $other->getInterwiki() && $this->getNamespace() === $other->getNamespace() && $this->getDBkey() === $other->getDBkey(); } /** * @inheritDoc * @since 1.36 */ public function isSamePageAs( PageReference $other ): bool { // NOTE: keep in sync with PageReferenceValue::isSamePageAs()! return $this->getWikiId() === $other->getWikiId() && $this->getNamespace() === $other->getNamespace() && $this->getDBkey() === $other->getDBkey(); } /** * Check if this title is a subpage of another title * * @param Title $title * @return bool */ public function isSubpageOf( Title $title ) { return $this->mInterwiki === $title->mInterwiki && $this->mNamespace == $title->mNamespace && str_starts_with( $this->mDbkeyform, $title->mDbkeyform . '/' ); } /** * Check if page exists. For historical reasons, this function simply * checks for the existence of the title in the page table, and will * thus return false for interwiki links, special pages and the like. * If you want to know if a title can be meaningfully viewed, you should * probably call the isKnown() method instead. * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * @return bool */ public function exists( $flags = 0 ): bool { $exists = $this->getArticleID( $flags ) != 0; ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )->onTitleExists( $this, $exists ); return $exists; } /** * Should links to this title be shown as potentially viewable (i.e. as * "bluelinks"), even if there's no record by this title in the page * table? * * This function is semi-deprecated for public use, as well as somewhat * misleadingly named. You probably just want to call isKnown(), which * calls this function internally. * * (ISSUE: Most of these checks are cheap, but the file existence check * can potentially be quite expensive. Including it here fixes a lot of * existing code, but we might want to add an optional parameter to skip * it and any other expensive checks.) * * @return bool */ public function isAlwaysKnown() { $isKnown = null; $services = MediaWikiServices::getInstance(); ( new HookRunner( $services->getHookContainer() ) )->onTitleIsAlwaysKnown( $this, $isKnown ); if ( $isKnown !== null ) { return $isKnown; } if ( $this->isExternal() ) { return true; // any interwiki link might be viewable, for all we know } switch ( $this->mNamespace ) { case NS_MEDIA: case NS_FILE: // file exists, possibly in a foreign repo return (bool)$services->getRepoGroup()->findFile( $this ); case NS_SPECIAL: // valid special page return $services->getSpecialPageFactory()->exists( $this->mDbkeyform ); case NS_MAIN: // selflink, possibly with fragment return $this->mDbkeyform == ''; case NS_MEDIAWIKI: // known system message return $this->hasSourceText() !== false; default: return false; } } /** * Does this title refer to a page that can (or might) be meaningfully * viewed? In particular, this function may be used to determine if * links to the title should be rendered as "bluelinks" (as opposed to * "redlinks" to non-existent pages). * Adding something else to this function will cause inconsistency * since LinkHolderArray calls isAlwaysKnown() and does its own * page existence check. * * @return bool */ public function isKnown() { return $this->isAlwaysKnown() || $this->exists(); } /** * Does this page have source text? * * @return bool */ public function hasSourceText() { if ( $this->exists() ) { return true; } if ( $this->mNamespace === NS_MEDIAWIKI ) { $services = MediaWikiServices::getInstance(); // If the page doesn't exist but is a known system message, default // message content will be displayed, same for language subpages- // Use always content language to avoid loading hundreds of languages // to get the link color. $contLang = $services->getContentLanguage(); [ $name, ] = $services->getMessageCache()->figureMessage( $contLang->lcfirst( $this->getText() ) ); $message = wfMessage( $name )->inLanguage( $contLang )->useDatabase( false ); return $message->exists(); } return false; } /** * Get the default (plain) message contents for a page that overrides an * interface message key. * * Primary use cases: * * - Article: * - Show default when viewing the page. The Article::getSubstituteContent * method displays the default message content, instead of the * 'noarticletext' placeholder message normally used. * * - EditPage: * - Title of edit page. When creating an interface message override, * the editor is told they are "Editing the page", instead of * "Creating the page". (EditPage::setHeaders) * - Edit notice. The 'translateinterface' edit notice is shown when creating * or editing an interface message override. (EditPage::showIntro) * - Opening the editor. The contents of the localisation message are used * as contents of the editor when creating a new page in the MediaWiki * namespace. This simplifies the process for editors when "changing" * an interface message by creating an override. (EditPage::getContentObject) * - Showing a diff. The left-hand side of a diff when an editor is * previewing their changes before saving the creation of a page in the * MediaWiki namespace. (EditPage::showDiff) * - Disallowing a save. When attempting to create a MediaWiki-namespace * page with the proposed content matching the interface message default, * the save is rejected, the same way we disallow blank pages from being * created. (EditPage using DefaultTextConstraint) * * - ApiEditPage: * - Default content, when using the 'prepend' or 'append' feature. * * - SkinTemplate: * - Label the create action as "Edit", if the page can be an override. * * @return string|false */ public function getDefaultMessageText() { $message = $this->getDefaultSystemMessage(); return $message ? $message->plain() : false; } /** * Same as getDefaultMessageText, but returns a Message object. * * @see ::getDefaultMessageText * * @return ?Message */ public function getDefaultSystemMessage(): ?Message { if ( $this->mNamespace !== NS_MEDIAWIKI ) { // Just in case return null; } [ $name, $lang ] = MediaWikiServices::getInstance()->getMessageCache()->figureMessage( MediaWikiServices::getInstance()->getContentLanguage()->lcfirst( $this->getText() ) ); if ( wfMessage( $name )->inLanguage( $lang )->useDatabase( false )->exists() ) { return wfMessage( $name )->inLanguage( $lang ); } else { return null; } } /** * Updates page_touched for this page; called from LinksUpdate.php * * @param string|null $purgeTime [optional] TS_MW timestamp * @return bool True if the update succeeded */ public function invalidateCache( $purgeTime = null ) { if ( MediaWikiServices::getInstance()->getReadOnlyMode()->isReadOnly() ) { return false; } if ( $this->mArticleID === 0 ) { // avoid gap locking if we know it's not there return true; } $conds = $this->pageCond(); // Periodically recompute page_random (T309477). This mitigates bias on // Special:Random due deleted pages leaving "gaps" in the distribution. // // Optimization: Update page_random only for 10% of updates. // Optimization: Do this outside the main transaction to avoid locking for too long. // Optimization: Update page_random alongside page_touched to avoid extra database writes. DeferredUpdates::addUpdate( new AutoCommitUpdate( $this->getDbProvider()->getPrimaryDatabase(), __METHOD__, function ( IDatabase $dbw, $fname ) use ( $conds, $purgeTime ) { $dbTimestamp = $dbw->timestamp( $purgeTime ?: time() ); $update = $dbw->newUpdateQueryBuilder() ->update( 'page' ) ->set( [ 'page_touched' => $dbTimestamp ] ) ->where( $conds ) ->andWhere( $dbw->expr( 'page_touched', '<', $dbTimestamp ) ); if ( mt_rand( 1, 10 ) === 1 ) { $update->andSet( [ 'page_random' => wfRandom() ] ); } $update->caller( $fname )->execute(); MediaWikiServices::getInstance()->getLinkCache()->invalidateTitle( $this ); WikiModule::invalidateModuleCache( $this, null, null, $dbw->getDomainID() ); } ), DeferredUpdates::PRESEND ); return true; } /** * Update page_touched timestamps and send CDN purge messages for * pages linking to this title. May be sent to the job queue depending * on the number of links. Typically called on create and delete. */ public function touchLinks() { $jobs = []; $jobs[] = HTMLCacheUpdateJob::newForBacklinks( $this, 'pagelinks', [ 'causeAction' => 'page-touch' ] ); if ( $this->mNamespace === NS_CATEGORY ) { $jobs[] = HTMLCacheUpdateJob::newForBacklinks( $this, 'categorylinks', [ 'causeAction' => 'category-touch' ] ); } MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush( $jobs ); } /** * Get the last touched timestamp * * @param int $flags one of the READ_XXX constants. * @return string|false Last-touched timestamp */ public function getTouched( int $flags = IDBAccessObject::READ_NORMAL ) { $touched = $this->getFieldFromPageStore( 'page_touched', $flags ); return $touched ? MWTimestamp::convert( TS_MW, $touched ) : false; } /** * Generate strings used for xml 'id' names in monobook tabs * * @param string $prepend Defaults to 'nstab-' * @return string XML 'id' name */ public function getNamespaceKey( $prepend = 'nstab-' ) { // Gets the subject namespace of this title $nsInfo = MediaWikiServices::getInstance()->getNamespaceInfo(); $subjectNS = $nsInfo->getSubject( $this->mNamespace ); // Prefer canonical namespace name for HTML IDs $namespaceKey = $nsInfo->getCanonicalName( $subjectNS ); if ( $namespaceKey === false ) { // Fallback to localised text $namespaceKey = $this->getSubjectNsText(); } // Makes namespace key lowercase $namespaceKey = MediaWikiServices::getInstance()->getContentLanguage()->lc( $namespaceKey ); // Uses main if ( $namespaceKey == '' ) { $namespaceKey = 'main'; } // Changes file to image for backwards compatibility if ( $namespaceKey == 'file' ) { $namespaceKey = 'image'; } return $prepend . $namespaceKey; } /** * Get all extant redirects to this Title * * @param int|null $ns Single namespace to consider; null to consider all namespaces * @return Title[] */ public function getRedirectsHere( $ns = null ) { $redirs = []; $queryBuilder = $this->getDbProvider()->getReplicaDatabase()->newSelectQueryBuilder() ->select( [ 'page_namespace', 'page_title' ] ) ->from( 'redirect' ) ->join( 'page', null, 'rd_from = page_id' ) ->where( [ 'rd_namespace' => $this->mNamespace, 'rd_title' => $this->mDbkeyform, 'rd_interwiki' => $this->isExternal() ? $this->mInterwiki : '', ] ); if ( $ns !== null ) { $queryBuilder->andWhere( [ 'page_namespace' => $ns ] ); } $res = $queryBuilder->caller( __METHOD__ )->fetchResultSet(); foreach ( $res as $row ) { $redirs[] = self::newFromRow( $row ); } return $redirs; } /** * Check if this Title is a valid redirect target * * @return bool */ public function isValidRedirectTarget() { global $wgInvalidRedirectTargets; if ( $this->isSpecialPage() ) { // invalid redirect targets are stored in a global array, but explicitly disallow Userlogout here foreach ( [ 'Userlogout', ...$wgInvalidRedirectTargets ] as $target ) { if ( $this->isSpecial( $target ) ) { return false; } } return true; } // relative section links are not valid redirect targets (T278367) return $this->getDBkey() !== '' && $this->isValid(); } /** * Whether the magic words __INDEX__ and __NOINDEX__ function for this page. * * @return bool */ public function canUseNoindex() { global $wgExemptFromUserRobotsControl; $bannedNamespaces = $wgExemptFromUserRobotsControl ?? MediaWikiServices::getInstance()->getNamespaceInfo()->getContentNamespaces(); return !in_array( $this->mNamespace, $bannedNamespaces ); } /** * Returns the raw sort key to be used for categories, with the specified * prefix. This will be fed to Collation::getSortKey() to get a * binary sortkey that can be used for actual sorting. * * @param string $prefix The prefix to be used, specified using * {{defaultsort:}} or like [[Category:Foo|prefix]]. Empty for no * prefix. * @return string */ public function getCategorySortkey( $prefix = '' ) { $unprefixed = $this->getText(); // Anything that uses this hook should only depend // on the Title object passed in, and should probably // tell the users to run updateCollations.php --force // in order to re-sort existing category relations. ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) ) ->onGetDefaultSortkey( $this, $unprefixed ); if ( $prefix !== '' ) { # Separate with a line feed, so the unprefixed part is only used as # a tiebreaker when two pages have the exact same prefix. # In UCA, tab is the only character that can sort above LF # so we strip both of them from the original prefix. $prefix = strtr( $prefix, "\n\t", ' ' ); return "$prefix\n$unprefixed"; } return $unprefixed; } /** * Returns the page language code saved in the database, if $wgPageLanguageUseDB is set * to true in LocalSettings.php, otherwise returns null. If there is no language saved in * the database, it will return null. * * @param int $flags * * @return ?string */ private function getDbPageLanguageCode( int $flags = 0 ): ?string { global $wgPageLanguageUseDB; // check, if the page language could be saved in the database, and if so and // the value is not requested already, lookup the page language using PageStore if ( $wgPageLanguageUseDB && $this->mDbPageLanguage === false ) { $this->mDbPageLanguage = $this->getFieldFromPageStore( 'page_lang', $flags ) ?: null; } return $this->mDbPageLanguage ?: null; } /** * Returns the Language object from the page language code saved in the database. * If $wgPageLanguageUseDB is set to false or there is no language saved in the database * or the language code in the database is invalid or unsupported, it will return null. * * @return Language|null */ private function getDbPageLanguage(): ?Language { $languageCode = $this->getDbPageLanguageCode(); if ( $languageCode === null ) { return null; } $services = MediaWikiServices::getInstance(); if ( !$services->getLanguageNameUtils()->isKnownLanguageTag( $languageCode ) ) { return null; } return $services->getLanguageFactory()->getLanguage( $languageCode ); } /** * Get the language in which the content of this page is written in * wikitext. Defaults to content language, but in certain cases it can be * e.g. $wgLang (such as special pages, which are in the user language). * * @since 1.18 * @return Language */ public function getPageLanguage() { global $wgLanguageCode; if ( $this->isSpecialPage() ) { // special pages are in the user language return RequestContext::getMain()->getLanguage(); } // Checking if DB language is set $dbPageLanguage = $this->getDbPageLanguage(); if ( $dbPageLanguage ) { return $dbPageLanguage; } $services = MediaWikiServices::getInstance(); if ( !$this->mPageLanguage || $this->mPageLanguage[1] !== $wgLanguageCode ) { // Note that this may depend on user settings, so the cache should // be only per-request. // NOTE: ContentHandler::getPageLanguage() may need to load the // content to determine the page language! // Checking $wgLanguageCode hasn't changed for the benefit of unit // tests. $contentHandler = $services->getContentHandlerFactory() ->getContentHandler( $this->getContentModel() ); $langObj = $contentHandler->getPageLanguage( $this ); $this->mPageLanguage = [ $langObj->getCode(), $wgLanguageCode ]; } else { $langObj = $services->getLanguageFactory() ->getLanguage( $this->mPageLanguage[0] ); } return $langObj; } /** * Get the language in which the content of this page is written when * viewed by user. Defaults to content language, but in certain cases it can be * e.g. the user language (such as special pages). * * @deprecated since 1.42 Use ParserOutput::getLanguage instead. See also OutputPage::getContLangForJS. * Hard-deprecated since 1.43. * @since 1.20 * @return Language */ public function getPageViewLanguage() { wfDeprecated( __METHOD__, '1.42' ); $services = MediaWikiServices::getInstance(); if ( $this->isSpecialPage() ) { // If the user chooses a variant, the content is actually // in a language whose code is the variant code. $userLang = RequestContext::getMain()->getLanguage(); $variant = $this->getLanguageConverter( $userLang )->getPreferredVariant(); if ( $userLang->getCode() !== $variant ) { return $services->getLanguageFactory() ->getLanguage( $variant ); } return $userLang; } // Checking if DB language is set $pageLang = $this->getDbPageLanguage(); if ( $pageLang ) { $variant = $this->getLanguageConverter( $pageLang )->getPreferredVariant(); if ( $pageLang->getCode() !== $variant ) { return $services->getLanguageFactory() ->getLanguage( $variant ); } return $pageLang; } // @note Can't be cached persistently, depends on user settings. // @note ContentHandler::getPageViewLanguage() may need to load the // content to determine the page language! $contentHandler = $services->getContentHandlerFactory() ->getContentHandler( $this->getContentModel() ); $pageLang = $contentHandler->getPageViewLanguage( $this ); return $pageLang; } /** * Get a list of rendered edit notices for this page. * * Array is keyed by the original message key, and values are rendered using parseAsBlock, so * they will already be wrapped in paragraphs. * * @since 1.21 * @param int $oldid Revision ID that's being edited * @return string[] */ public function getEditNotices( $oldid = 0 ) { $notices = []; $editnotice_base = 'editnotice-' . $this->mNamespace; // Optional notice for the entire namespace $messages = [ $editnotice_base => 'namespace' ]; if ( MediaWikiServices::getInstance()->getNamespaceInfo()-> hasSubpages( $this->mNamespace ) ) { // Optional notice for page itself and any parent page foreach ( explode( '/', $this->mDbkeyform ) as $part ) { $editnotice_base .= '-' . $part; $messages[$editnotice_base] = 'base'; } } else { // Even if there are no subpages in namespace, we still don't want "/" in MediaWiki message keys $messages[$editnotice_base . '-' . strtr( $this->mDbkeyform, '/', '-' )] = 'page'; } foreach ( $messages as $editnoticeText => $class ) { // The following messages are used here: // * editnotice-0 // * editnotice-0-Title // * editnotice-0-Title-Subpage // * editnotice-… $msg = wfMessage( $editnoticeText )->page( $this ); if ( $msg->exists() ) { $html = $msg->parseAsBlock(); // Edit notices may have complex logic, but output nothing (T91715) if ( trim( $html ) !== '' ) { $notices[$editnoticeText] = Html::rawElement( 'div', [ 'class' => [ 'mw-editnotice', // The following classes are used here: // * mw-editnotice-namespace // * mw-editnotice-base // * mw-editnotice-page "mw-editnotice-$class", // The following classes are used here: // * mw-editnotice-0 // * mw-editnotice-… Sanitizer::escapeClass( "mw-$editnoticeText" ) ] ], $html ); } } } ( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) ) ->onTitleGetEditNotices( $this, $oldid, $notices ); return $notices; } /** * @param string $field * @param int $flags Bitfield of IDBAccessObject::READ_* constants * @return string|false */ private function getFieldFromPageStore( $field, $flags ) { $pageStore = MediaWikiServices::getInstance()->getPageStore(); if ( !in_array( $field, $pageStore->getSelectFields(), true ) ) { throw new InvalidArgumentException( "Unknown field: $field" ); } if ( $flags === IDBAccessObject::READ_NORMAL && $this->mArticleID === 0 ) { // page does not exist return false; } if ( !$this->canExist() ) { return false; } $page = $pageStore->getPageByReference( $this, $flags ); if ( $page instanceof PageStoreRecord ) { return $page->getField( $field ); } else { // The page record failed to load, remember the page as non-existing. // Note that this can happen even if a page ID was known before under some // rare circumstances, if this method is called with the READ_LATEST bit set // and the page has been deleted since the ID had initially been determined. $this->mArticleID = 0; return false; } } /** * @return array */ public function __sleep() { return [ 'mNamespace', 'mDbkeyform', 'mFragment', 'mInterwiki', 'mLocalInterwiki', ]; } public function __wakeup() { $this->mArticleID = ( $this->mNamespace >= 0 ) ? -1 : 0; $this->mUrlform = wfUrlencode( $this->mDbkeyform ); $this->mTextform = strtr( $this->mDbkeyform, '_', ' ' ); } public function __clone() { $this->mInstanceCacheKey = null; } /** * Returns false to indicate that this Title belongs to the local wiki. * * @note The behavior of this method is considered undefined for interwiki links. * At the moment, this method always returns false. But this may change in the future. * * @since 1.36 * @return string|false Always self::LOCAL */ public function getWikiId() { return self::LOCAL; } /** * Returns the page ID. * * If this ID is 0, this means the page does not exist. * * @see getArticleID() * @since 1.36, since 1.35.6 as an alias of getArticleID() * * @param string|false $wikiId The wiki ID expected by the caller. * * @throws PreconditionException if this Title instance does not represent a proper page, * that is, if it is a section link, interwiki link, link to a special page, or such. * @throws PreconditionException if $wikiId is not false. * * @return int */ public function getId( $wikiId = self::LOCAL ): int { $this->assertWiki( $wikiId ); $this->assertProperPage(); return $this->getArticleID(); } /** * Code that requires this Title to be a "proper page" in the sense * defined by PageIdentity should call this method. * * For the purpose of the Title class, a proper page is one that can * exist in the page table. That is, a Title represents a proper page * if canExist() returns true. * * @see canExist() * * @throws PreconditionException */ private function assertProperPage() { Assert::precondition( $this->canExist(), 'This Title instance does not represent a proper page, but merely a link target.' ); } /** * Returns the page represented by this Title as a ProperPageIdentity. * The ProperPageIdentity returned by this method is guaranteed to be immutable. * If this Title does not represent a proper page, an exception is thrown. * * It is preferred to use this method rather than using the Title as a PageIdentity directly. * * @return ProperPageIdentity * @throws PreconditionException if the page is not a proper page, that is, if it is a section * link, interwiki link, link to a special page, or such. * @since 1.36 */ public function toPageIdentity(): ProperPageIdentity { // TODO: replace individual member fields with a PageIdentityValue that is always present $this->assertProperPage(); return new PageIdentityValue( $this->getId(), $this->getNamespace(), $this->getDBkey(), $this->getWikiId() ); } /** * Returns the page represented by this Title as a ProperPageRecord. * The PageRecord returned by this method is guaranteed to be immutable, * the page is guaranteed to exist. * * @note For now, this method queries the database on every call. * @since 1.36 * * @param int $flags A bitfield of IDBAccessObject::READ_* constants * * @return ExistingPageRecord * @throws PreconditionException if the page does not exist, or is not a proper page, * that is, if it is a section link, interwiki link, link to a special page, or such. */ public function toPageRecord( $flags = 0 ): ExistingPageRecord { // TODO: Cache this? Construct is more efficiently? $this->assertProperPage(); Assert::precondition( $this->exists( $flags ), 'This Title instance does not represent an existing page: ' . $this ); return new PageStoreRecord( (object)[ 'page_id' => $this->getArticleID( $flags ), 'page_namespace' => $this->getNamespace(), 'page_title' => $this->getDBkey(), 'page_wiki_id' => $this->getWikiId(), 'page_latest' => $this->getLatestRevID( $flags ), 'page_is_new' => $this->isNewPage( $flags ), 'page_is_redirect' => $this->isRedirect( $flags ), 'page_touched' => $this->getTouched( $flags ), 'page_lang' => $this->getDbPageLanguageCode( $flags ), ], PageIdentity::LOCAL ); } } /** @deprecated class alias since 1.40 */ class_alias( Title::class, 'Title' ); PK ! \Ts/ / ForeignTitle.phpnu �Iw�� <?php /** * A structure to hold the title of a page on a foreign MediaWiki installation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author This, that and the other */ namespace MediaWiki\Title; use RuntimeException; use Stringable; /** * A simple, immutable structure to hold the title of a page on a foreign * MediaWiki installation. */ class ForeignTitle implements Stringable { /** * @var int|null * Null if we don't know the namespace ID (e.g. interwiki links) */ private $namespaceId; /** @var string */ private $namespaceName; /** @var string */ private $pageName; /** * Creates a new ForeignTitle object. * * @param int|null $namespaceId Null if the namespace ID is unknown (e.g. * interwiki links) * @param string $namespaceName * @param string $pageName */ public function __construct( $namespaceId, $namespaceName, $pageName ) { if ( $namespaceId === null ) { $this->namespaceId = null; } else { $this->namespaceId = intval( $namespaceId ); } $this->namespaceName = str_replace( ' ', '_', $namespaceName ); $this->pageName = str_replace( ' ', '_', $pageName ); } /** * Do we know the namespace ID of the page on the foreign wiki? * @return bool */ public function isNamespaceIdKnown() { return $this->namespaceId !== null; } /** * @note Callers should make sure that isNamespaceIdKnown() is true before calling this method. * @return int */ public function getNamespaceId() { if ( $this->namespaceId === null ) { throw new RuntimeException( "Attempted to call getNamespaceId when the namespace ID is not known" ); } return $this->namespaceId; } /** @return string */ public function getNamespaceName() { return $this->namespaceName; } /** @return string */ public function getText() { return $this->pageName; } /** @return string */ public function getFullText() { $result = ''; if ( $this->namespaceName ) { $result .= $this->namespaceName . ':'; } $result .= $this->pageName; return $result; } /** * Returns a string representation of the title, for logging. This is purely * informative and must not be used programmatically. Use the appropriate * ImportTitleFactory to generate the correct string representation for a * given use. * * @return string */ public function __toString() { $name = ''; if ( $this->isNamespaceIdKnown() ) { $name .= '{ns' . $this->namespaceId . '}'; } else { $name .= '{ns??}'; } $name .= $this->namespaceName . ':' . $this->pageName; return $name; } } /** @deprecated class alias since 1.41 */ class_alias( ForeignTitle::class, 'ForeignTitle' ); PK ! Pb NaiveImportTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use MediaWiki\Language\Language; /** * A class to convert page titles on a foreign wiki (ForeignTitle objects) into * page titles on the local wiki (Title objects), using a default namespace * mapping. * * For built-in namespaces (0 <= ID < 100), we try to find a local namespace * with the same namespace ID as the foreign page. If no such namespace exists, * or the namespace ID is unknown or > 100, we look for a local namespace with * a matching namespace name. If that can't be found, we dump the page in the * main namespace as a last resort. */ class NaiveImportTitleFactory implements ImportTitleFactory { private Language $contentLanguage; private NamespaceInfo $namespaceInfo; private TitleFactory $titleFactory; public function __construct( Language $contentLanguage, NamespaceInfo $namespaceInfo, TitleFactory $titleFactory ) { $this->contentLanguage = $contentLanguage; $this->namespaceInfo = $namespaceInfo; $this->titleFactory = $titleFactory; } /** * Determines which local title best corresponds to the given foreign title. * If such a title can't be found or would be locally invalid, null is * returned. * * @param ForeignTitle $foreignTitle The ForeignTitle to convert * @return Title|null */ public function createTitleFromForeignTitle( ForeignTitle $foreignTitle ) { if ( $foreignTitle->isNamespaceIdKnown() ) { $foreignNs = $foreignTitle->getNamespaceId(); // For built-in namespaces (0 <= ID < 100), we try to find a local NS with // the same namespace ID if ( $foreignNs < 100 && $this->namespaceInfo->exists( $foreignNs ) ) { return $this->titleFactory->makeTitleSafe( $foreignNs, $foreignTitle->getText() ); } } // Do we have a local namespace by the same name as the foreign // namespace? $targetNs = $this->contentLanguage->getNsIndex( $foreignTitle->getNamespaceName() ); if ( $targetNs !== false ) { return $this->titleFactory->makeTitleSafe( $targetNs, $foreignTitle->getText() ); } // Otherwise, just fall back to main namespace return $this->titleFactory->makeTitleSafe( 0, $foreignTitle->getFullText() ); } } /** @deprecated class alias since 1.41 */ class_alias( NaiveImportTitleFactory::class, 'NaiveImportTitleFactory' ); PK ! ��R� � TitleFormatter.phpnu �Iw�� <?php /** * A title formatter service for MediaWiki. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Daniel Kinzler */ namespace MediaWiki\Title; use MediaWiki\Linker\LinkTarget; use MediaWiki\Page\PageReference; /** * A title formatter service for MediaWiki. * * This is designed to encapsulate knowledge about conventions for the title * forms to be used in the database, in urls, in wikitext, etc. * * @see https://www.mediawiki.org/wiki/Requests_for_comment/TitleValue * @since 1.23 */ interface TitleFormatter { /** * Returns the title formatted for display. * By default, this includes the namespace but not the fragment. * * @note Normalization is applied if $title is not in TitleValue::TITLE_FORM. * * @param int|bool $namespace The namespace ID (or false, if the namespace should be ignored) * @param string $text The page title * @param string $fragment The fragment name (may be empty). * @param string $interwiki The interwiki prefix (may be empty). * * @return string */ public function formatTitle( $namespace, $text, $fragment = '', $interwiki = '' ); /** * Returns the title text formatted for display, without namespace or fragment. * * @param LinkTarget|PageReference $title The title to format * * @return string */ public function getText( $title ); /** * Returns the title formatted for display, including the namespace name. * * @param LinkTarget|PageReference $title The title to format * * @return string */ public function getPrefixedText( $title ); /** * Return the title in prefixed database key form, with interwiki * and namespace. * * @since 1.27 * * @param LinkTarget|PageReference $target * * @return string */ public function getPrefixedDBkey( $target ); /** * Returns the title formatted for display, with namespace and fragment. * * @param LinkTarget|PageReference $title The title to format * * @return string */ public function getFullText( $title ); /** * Returns the name of the namespace for the given title. * * @note This must take into account gender sensitive namespace names. * @todo Move this to a separate interface * * @param int $namespace * @param string $text * * @return string Namespace name with underscores (not spaces), e.g. 'User_talk' */ public function getNamespaceName( $namespace, $text ); } /** @deprecated class alias since 1.41 */ class_alias( TitleFormatter::class, 'TitleFormatter' ); PK ! ��q�� � ImportTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; /** * Represents an object that can convert page titles on a foreign wiki * (ForeignTitle objects) into page titles on the local wiki (Title objects). */ interface ImportTitleFactory { /** * Determines which local title best corresponds to the given foreign title. * If such a title can't be found or would be locally invalid, null is * returned. * * @param ForeignTitle $foreignTitle The ForeignTitle to convert * @return Title|null */ public function createTitleFromForeignTitle( ForeignTitle $foreignTitle ); } /** @deprecated class alias since 1.41 */ class_alias( ImportTitleFactory::class, 'ImportTitleFactory' ); PK ! Ѯ�bH bH NamespaceInfo.phpnu �Iw�� <?php /** * Provide things related to namespaces. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use InvalidArgumentException; use MediaWiki\Config\ServiceOptions; use MediaWiki\HookContainer\HookContainer; use MediaWiki\HookContainer\HookRunner; use MediaWiki\Linker\LinkTarget; use MediaWiki\MainConfigNames; use MWException; /** * This is a utility class for dealing with namespaces that encodes all the "magic" behaviors of * them based on index. The textual names of the namespaces are handled by Language.php. * * @since 1.34 */ class NamespaceInfo { /** * These namespaces should always be first-letter capitalized, now and * forevermore. Historically, they could've probably been lowercased too, * but some things are just too ingrained now. :) */ private const ALWAYS_CAPITALIZED_NAMESPACES = [ NS_SPECIAL, NS_USER, NS_MEDIAWIKI ]; /** @var string[]|null Canonical namespaces cache */ private $canonicalNamespaces = null; /** @var array|false Canonical namespaces index cache */ private $namespaceIndexes = false; /** @var int[]|null Valid namespaces cache */ private $validNamespaces = null; private ServiceOptions $options; private HookRunner $hookRunner; private array $extensionNamespaces; private array $extensionImmovableNamespaces; /** * Definitions of the NS_ constants are in Defines.php * * @internal */ public const CANONICAL_NAMES = [ NS_MEDIA => 'Media', NS_SPECIAL => 'Special', NS_MAIN => '', NS_TALK => 'Talk', NS_USER => 'User', NS_USER_TALK => 'User_talk', NS_PROJECT => 'Project', NS_PROJECT_TALK => 'Project_talk', NS_FILE => 'File', NS_FILE_TALK => 'File_talk', NS_MEDIAWIKI => 'MediaWiki', NS_MEDIAWIKI_TALK => 'MediaWiki_talk', NS_TEMPLATE => 'Template', NS_TEMPLATE_TALK => 'Template_talk', NS_HELP => 'Help', NS_HELP_TALK => 'Help_talk', NS_CATEGORY => 'Category', NS_CATEGORY_TALK => 'Category_talk', ]; /** * @internal For use by ServiceWiring */ public const CONSTRUCTOR_OPTIONS = [ MainConfigNames::CanonicalNamespaceNames, MainConfigNames::CapitalLinkOverrides, MainConfigNames::CapitalLinks, MainConfigNames::ContentNamespaces, MainConfigNames::ExtraNamespaces, MainConfigNames::ExtraSignatureNamespaces, MainConfigNames::NamespaceContentModels, MainConfigNames::NamespacesWithSubpages, MainConfigNames::NonincludableNamespaces, ]; public function __construct( ServiceOptions $options, HookContainer $hookContainer, array $extensionNamespaces, array $extensionImmovableNamespaces ) { $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS ); $this->options = $options; $this->hookRunner = new HookRunner( $hookContainer ); $this->extensionNamespaces = $extensionNamespaces; $this->extensionImmovableNamespaces = $extensionImmovableNamespaces; } /** * Throw an exception when trying to get the subject or talk page * for a given namespace where it does not make sense. * Special namespaces are defined in includes/Defines.php and have * a value below 0 (ex: NS_SPECIAL = -1 , NS_MEDIA = -2) * * @param int $index * @param string $method * * @throws MWException * @return bool */ private function isMethodValidFor( $index, $method ) { if ( $index < NS_MAIN ) { throw new MWException( "$method does not make any sense for given namespace $index" ); } return true; } /** * Throw if given index isn't an integer or integer-like string and so can't be a valid namespace. * * @param int|string $index * @param string $method * * @throws InvalidArgumentException * @return int Cleaned up namespace index */ private function makeValidNamespace( $index, $method ) { if ( !( is_int( $index ) // Namespace index numbers as strings || ctype_digit( $index ) // Negative numbers as strings || ( $index[0] === '-' && ctype_digit( substr( $index, 1 ) ) ) ) ) { throw new InvalidArgumentException( "$method called with non-integer (" . get_debug_type( $index ) . ") namespace '$index'" ); } return intval( $index ); } /** * Can pages in the given namespace be moved? * * @param int $index Namespace index * @return bool */ public function isMovable( $index ) { $result = $index >= NS_MAIN && !in_array( $index, $this->extensionImmovableNamespaces ); /** * @since 1.20 */ $this->hookRunner->onNamespaceIsMovable( $index, $result ); return $result; } /** * Is the given namespace is a subject (non-talk) namespace? * * @param int $index Namespace index * @return bool */ public function isSubject( $index ) { return !$this->isTalk( $index ); } /** * Is the given namespace a talk namespace? * * @param int $index Namespace index * @return bool */ public function isTalk( $index ) { $index = $this->makeValidNamespace( $index, __METHOD__ ); return $index > NS_MAIN && $index % 2 === 1; } /** * Get the talk namespace index for a given namespace * * @param int $index Namespace index * @return int * @throws MWException if the given namespace doesn't have an associated talk namespace * (e.g. NS_SPECIAL). */ public function getTalk( $index ) { $index = $this->makeValidNamespace( $index, __METHOD__ ); $this->isMethodValidFor( $index, __METHOD__ ); return $this->isTalk( $index ) ? $index : $index + 1; } /** * Get a LinkTarget referring to the talk page of $target. * * @see canHaveTalkPage * @param LinkTarget $target * @return LinkTarget Talk page for $target * @throws MWException if $target doesn't have talk pages, e.g. because it's in NS_SPECIAL, * because it's a relative section-only link, or it's an interwiki link. */ public function getTalkPage( LinkTarget $target ): LinkTarget { if ( $target->getText() === '' ) { throw new MWException( 'Can\'t determine talk page associated with relative section link' ); } if ( $target->getInterwiki() !== '' ) { throw new MWException( 'Can\'t determine talk page associated with interwiki link' ); } if ( $this->isTalk( $target->getNamespace() ) ) { return $target; } // NOTE: getTalk throws on bad namespaces! return new TitleValue( $this->getTalk( $target->getNamespace() ), $target->getDBkey() ); } /** * Can the title have a corresponding talk page? * * False for relative section-only links (with getText() === ''), * interwiki links (with getInterwiki() !== ''), and pages in NS_SPECIAL. * * @see getTalkPage * * @param LinkTarget $target * @return bool True if this title either is a talk page or can have a talk page associated. */ public function canHaveTalkPage( LinkTarget $target ) { return $target->getNamespace() >= NS_MAIN && !$target->isExternal() && $target->getText() !== ''; } /** * Get the subject namespace index for a given namespace * Special namespaces (NS_MEDIA, NS_SPECIAL) are always the subject. * * @param int $index Namespace index * @return int */ public function getSubject( $index ) { $index = $this->makeValidNamespace( $index, __METHOD__ ); # Handle special namespaces if ( $index < NS_MAIN ) { return $index; } return $this->isTalk( $index ) ? $index - 1 : $index; } /** * @param LinkTarget $target * @return LinkTarget Subject page for $target */ public function getSubjectPage( LinkTarget $target ): LinkTarget { if ( $this->isSubject( $target->getNamespace() ) ) { return $target; } return new TitleValue( $this->getSubject( $target->getNamespace() ), $target->getDBkey() ); } /** * Get the associated namespace. * For talk namespaces, returns the subject (non-talk) namespace * For subject (non-talk) namespaces, returns the talk namespace * * @param int $index Namespace index * @return int * @throws MWException if called on a namespace that has no talk pages (e.g., NS_SPECIAL) */ public function getAssociated( $index ) { $this->isMethodValidFor( $index, __METHOD__ ); if ( $this->isSubject( $index ) ) { return $this->getTalk( $index ); } return $this->getSubject( $index ); } /** * @param LinkTarget $target * @return LinkTarget Talk page for $target if it's a subject page, subject page if it's a talk * page * @throws MWException if $target's namespace doesn't have talk pages (e.g., NS_SPECIAL) */ public function getAssociatedPage( LinkTarget $target ): LinkTarget { if ( $target->getText() === '' ) { throw new MWException( 'Can\'t determine talk page associated with relative section link' ); } if ( $target->getInterwiki() !== '' ) { throw new MWException( 'Can\'t determine talk page associated with interwiki link' ); } return new TitleValue( $this->getAssociated( $target->getNamespace() ), $target->getDBkey() ); } /** * Returns whether the specified namespace exists * * @param int $index * * @return bool */ public function exists( $index ) { $nslist = $this->getCanonicalNamespaces(); return isset( $nslist[$index] ); } /** * Returns whether the specified namespaces are the same namespace * * @note It's possible that in the future we may start using something * other than just namespace indexes. Under that circumstance making use * of this function rather than directly doing comparison will make * sure that code will not potentially break. * * @param int $ns1 The first namespace index * @param int $ns2 The second namespace index * * @return bool */ public function equals( $ns1, $ns2 ) { return $ns1 == $ns2; } /** * Returns whether the specified namespaces share the same subject. * eg: NS_USER and NS_USER wil return true, as well * NS_USER and NS_USER_TALK will return true. * * @param int $ns1 The first namespace index * @param int $ns2 The second namespace index * * @return bool */ public function subjectEquals( $ns1, $ns2 ) { return $this->getSubject( $ns1 ) == $this->getSubject( $ns2 ); } /** * Returns array of all defined namespaces with their canonical * (English) names. * * @return string[] */ public function getCanonicalNamespaces() { if ( $this->canonicalNamespaces === null ) { $this->canonicalNamespaces = [ NS_MAIN => '' ] + $this->options->get( MainConfigNames::CanonicalNamespaceNames ); $this->canonicalNamespaces += $this->extensionNamespaces; if ( is_array( $this->options->get( MainConfigNames::ExtraNamespaces ) ) ) { $this->canonicalNamespaces += $this->options->get( MainConfigNames::ExtraNamespaces ); } $this->hookRunner->onCanonicalNamespaces( $this->canonicalNamespaces ); } return $this->canonicalNamespaces; } /** * Returns the canonical (English) name for a given index * * @param int $index Namespace index * @return string|false If no canonical definition. */ public function getCanonicalName( $index ) { $nslist = $this->getCanonicalNamespaces(); return $nslist[$index] ?? false; } /** * Returns the index for a given canonical name, or NULL * The input *must* be converted to lower case first * * @param string $name Namespace name * @return int|null */ public function getCanonicalIndex( $name ) { if ( $this->namespaceIndexes === false ) { $this->namespaceIndexes = []; foreach ( $this->getCanonicalNamespaces() as $i => $text ) { $this->namespaceIndexes[strtolower( $text )] = $i; } } if ( array_key_exists( $name, $this->namespaceIndexes ) ) { return $this->namespaceIndexes[$name]; } else { return null; } } /** * Returns an array of the namespaces (by integer id) that exist on the wiki. Used primarily by * the API in help documentation. The array is sorted numerically and omits negative namespaces. * @return array */ public function getValidNamespaces() { if ( $this->validNamespaces === null ) { $this->validNamespaces = []; foreach ( $this->getCanonicalNamespaces() as $ns => $_ ) { if ( $ns >= 0 ) { $this->validNamespaces[] = $ns; } } // T109137: sort numerically sort( $this->validNamespaces, SORT_NUMERIC ); } return $this->validNamespaces; } /** * Does this namespace ever have a talk namespace? * * @param int $index Namespace ID * @return bool True if this namespace either is or has a corresponding talk namespace. */ public function hasTalkNamespace( $index ) { return $index >= NS_MAIN; } /** * Does this namespace contain content, for the purposes of calculating * statistics, etc? * * @param int $index Index to check * @return bool */ public function isContent( $index ) { return $index == NS_MAIN || in_array( $index, $this->options->get( MainConfigNames::ContentNamespaces ) ); } /** * Might pages in this namespace require the use of the Signature button on * the edit toolbar? * * @param int $index Index to check * @return bool */ public function wantSignatures( $index ) { return $this->isTalk( $index ) || in_array( $index, $this->options->get( MainConfigNames::ExtraSignatureNamespaces ) ); } /** * Can pages in a namespace be watched? * * @param int $index * @return bool */ public function isWatchable( $index ) { return $index >= NS_MAIN; } /** * Does the namespace allow subpages? Note that this refers to structured * handling of subpages, and does not include SpecialPage subpage parameters. * * @param int $index Index to check * @return bool */ public function hasSubpages( $index ) { return !empty( $this->options->get( MainConfigNames::NamespacesWithSubpages )[$index] ); } /** * Get a list of all namespace indices which are considered to contain content * @return int[] Array of namespace indices */ public function getContentNamespaces() { $contentNamespaces = $this->options->get( MainConfigNames::ContentNamespaces ); if ( !is_array( $contentNamespaces ) || $contentNamespaces === [] ) { return [ NS_MAIN ]; } elseif ( !in_array( NS_MAIN, $contentNamespaces ) ) { // always force NS_MAIN to be part of array (to match the algorithm used by isContent) return array_merge( [ NS_MAIN ], $contentNamespaces ); } else { return $contentNamespaces; } } /** * List all namespace indices which are considered subject, aka not a talk * or special namespace. See also NamespaceInfo::isSubject * * @return int[] Array of namespace indices */ public function getSubjectNamespaces() { return array_filter( $this->getValidNamespaces(), [ $this, 'isSubject' ] ); } /** * List all namespace indices which are considered talks, aka not a subject * or special namespace. See also NamespaceInfo::isTalk * * @return int[] Array of namespace indices */ public function getTalkNamespaces() { return array_filter( $this->getValidNamespaces(), [ $this, 'isTalk' ] ); } /** * Is the namespace first-letter capitalized? * * @param int $index Index to check * @return bool */ public function isCapitalized( $index ) { // Turn NS_MEDIA into NS_FILE $index = $index === NS_MEDIA ? NS_FILE : $index; // Make sure to get the subject of our namespace $index = $this->getSubject( $index ); // Some namespaces are special and should always be upper case if ( in_array( $index, self::ALWAYS_CAPITALIZED_NAMESPACES ) ) { return true; } $overrides = $this->options->get( MainConfigNames::CapitalLinkOverrides ); if ( isset( $overrides[$index] ) ) { // CapitalLinkOverrides is explicitly set return $overrides[$index]; } // Default to the global setting return $this->options->get( MainConfigNames::CapitalLinks ); } /** * Does the namespace (potentially) have different aliases for different * genders. Not all languages make a distinction here. * * @param int $index Index to check * @return bool */ public function hasGenderDistinction( $index ) { return $index == NS_USER || $index == NS_USER_TALK; } /** * It is not possible to use pages from this namespace as template? * * @param int $index Index to check * @return bool */ public function isNonincludable( $index ) { $namespaces = $this->options->get( MainConfigNames::NonincludableNamespaces ); return $namespaces && in_array( $index, $namespaces ); } /** * Get the default content model for a namespace * This does not mean that all pages in that namespace have the model * * @note To determine the default model for a new page's main slot, or any slot in general, * use SlotRoleHandler::getDefaultModel() together with SlotRoleRegistry::getRoleHandler(). * * @param int $index Index to check * @return null|string Default model name for the given namespace, if set */ public function getNamespaceContentModel( $index ) { return $this->options->get( MainConfigNames::NamespaceContentModels )[$index] ?? null; } /** * Returns the link type to be used for categories. * * This determines which section of a category page titles * in the namespace will appear within. * * @param int $index Namespace index * @return string One of 'subcat', 'file', 'page' */ public function getCategoryLinkType( $index ) { $this->isMethodValidFor( $index, __METHOD__ ); if ( $index == NS_CATEGORY ) { return 'subcat'; } elseif ( $index == NS_FILE ) { return 'file'; } else { return 'page'; } } /** * Retrieve the indexes for the namespaces defined by core. * * @since 1.34 * * @return int[] */ public static function getCommonNamespaces() { return array_keys( self::CANONICAL_NAMES ); } } /** @deprecated class alias since 1.41 */ class_alias( NamespaceInfo::class, 'NamespaceInfo' ); PK ! (=�i i NamespaceImportTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use InvalidArgumentException; /** * A class to convert page titles on a foreign wiki (ForeignTitle objects) into * page titles on the local wiki (Title objects), placing all pages in a fixed * local namespace. */ class NamespaceImportTitleFactory implements ImportTitleFactory { private TitleFactory $titleFactory; private int $ns; /** * @param NamespaceInfo $namespaceInfo * @param TitleFactory $titleFactory * @param int $ns The namespace to use for all pages */ public function __construct( NamespaceInfo $namespaceInfo, TitleFactory $titleFactory, int $ns ) { if ( !$namespaceInfo->exists( $ns ) ) { throw new InvalidArgumentException( "Namespace $ns doesn't exist on this wiki" ); } $this->titleFactory = $titleFactory; $this->ns = $ns; } /** * Determines which local title best corresponds to the given foreign title. * If such a title can't be found or would be locally invalid, null is * returned. * * @param ForeignTitle $foreignTitle The ForeignTitle to convert * @return Title|null */ public function createTitleFromForeignTitle( ForeignTitle $foreignTitle ) { return $this->titleFactory->makeTitleSafe( $this->ns, $foreignTitle->getText() ); } } /** @deprecated class alias since 1.41 */ class_alias( NamespaceImportTitleFactory::class, 'NamespaceImportTitleFactory' ); PK ! �|� Hook/NamespaceIsMovableHook.phpnu �Iw�� <?php namespace MediaWiki\Hook; /** * This is a hook handler interface, see docs/Hooks.md. * Use the hook name "NamespaceIsMovable" to register handlers implementing this interface. * * @stable to implement * @ingroup Hooks */ interface NamespaceIsMovableHook { /** * This hook is called when determining if it is possible to move pages in a * namespace. * * @since 1.35 * * @param int $index Index of the namespace being checked * @param bool &$result Whether MediaWiki currently thinks that pages in this * namespace are movable. Hooks may change this value to override the return * value of NamespaceInfo::isMovable(). * @return bool|void True or no return value to continue or false to abort */ public function onNamespaceIsMovable( $index, &$result ); } PK ! � ᬋ � Hook/CanonicalNamespacesHook.phpnu �Iw�� <?php namespace MediaWiki\Hook; /** * This is a hook handler interface, see docs/Hooks.md. * Use the hook name "CanonicalNamespaces" to register handlers implementing this interface. * * @stable to implement * @ingroup Hooks */ interface CanonicalNamespacesHook { /** * Use this hook to add namespaces or alter the defaults. * Note that if you need to specify namespace protection or content model for * a namespace that is added in a CanonicalNamespaces hook handler, you * should do so by altering $wgNamespaceProtection and * $wgNamespaceContentModels outside the handler, in top-level scope. The * point at which the CanonicalNamespaces hook fires is too late for altering * these variables. This applies even if the namespace addition is * conditional; it is permissible to declare a content model and protection * for a namespace and then decline to actually register it. * * @since 1.35 * * @param string[] &$namespaces Array of namespace numbers with corresponding canonical names * @return bool|void True or no return value to continue or false to abort */ public function onCanonicalNamespaces( &$namespaces ); } PK ! ,1�� � TitleArrayFromResult.phpnu �Iw�� <?php /** * Class to walk into a list of Title objects. * * Note: this entire file is a byte-for-byte copy of UserArrayFromResult.php * with s/User/Title/. If anyone can figure out how to do this nicely * with inheritance or something, please do so. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use Countable; use Iterator; use Wikimedia\Rdbms\IResultWrapper; /** * @newable * @note marked as newable in 1.35 for lack of a better alternative, * but should probably become part of the TitleFactory service. */ class TitleArrayFromResult implements Countable, Iterator { /** @var IResultWrapper */ public $res; /** @var int */ public $key; /** @var Title|false */ public $current; /** * @stable to call * * @param IResultWrapper $res */ public function __construct( $res ) { $this->res = $res; $this->key = 0; $this->setCurrent( $this->res->current() ); } /** * @param \stdClass|false $row * @return void */ protected function setCurrent( $row ) { if ( $row === false ) { $this->current = false; } else { $this->current = Title::newFromRow( $row ); } } /** * @return int */ public function count(): int { return $this->res->numRows(); } public function current(): Title { return $this->current; } public function key(): int { return $this->key; } public function next(): void { $row = $this->res->fetchObject(); $this->setCurrent( $row ); $this->key++; } public function rewind(): void { $this->res->rewind(); $this->key = 0; $this->setCurrent( $this->res->current() ); } /** * @return bool */ public function valid(): bool { return $this->current !== false; } } /** @deprecated class alias since 1.41 */ class_alias( TitleArrayFromResult::class, 'TitleArrayFromResult' ); PK ! @�L�kN kN MediaWikiTitleCodec.phpnu �Iw�� <?php /** * A codec for MediaWiki page titles. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Daniel Kinzler */ namespace MediaWiki\Title; use InvalidArgumentException; use LogicException; use MediaWiki\Cache\GenderCache; use MediaWiki\Interwiki\InterwikiLookup; use MediaWiki\Language\Language; use MediaWiki\Linker\LinkTarget; use MediaWiki\Message\Message; use MediaWiki\Page\PageReference; use MediaWiki\Parser\Sanitizer; use Wikimedia\IPUtils; /** * A codec for MediaWiki page titles. * * @note Normalization and validation is applied while parsing, not when formatting. * It's possible to construct a TitleValue with an invalid title, and use MediaWikiTitleCodec * to generate an (invalid) title string from it. TitleValues should be constructed only * via parseTitle() or from a (semi)trusted source, such as the database. * * @see https://www.mediawiki.org/wiki/Requests_for_comment/TitleValue * @since 1.23 */ class MediaWikiTitleCodec implements TitleFormatter, TitleParser { protected Language $language; protected GenderCache $genderCache; /** @var string[] */ protected array $localInterwikis; protected InterwikiLookup $interwikiLookup; protected NamespaceInfo $nsInfo; /** * The code here can throw MalformedTitleException, which cannot be created in * unit tests (see T281935). Until that changes, we use this helper callback * that can be overridden in unit tests to return a mock instead. * * @var callable */ private $createMalformedTitleException; /** * @param Language $language The language object to use for localizing namespace names, * capitalization, etc. * @param GenderCache $genderCache The gender cache for generating gendered namespace names * @param string[]|string $localInterwikis * @param InterwikiLookup $interwikiLookup * @param NamespaceInfo $nsInfo */ public function __construct( Language $language, GenderCache $genderCache, $localInterwikis, InterwikiLookup $interwikiLookup, NamespaceInfo $nsInfo ) { $this->language = $language; $this->genderCache = $genderCache; $this->localInterwikis = (array)$localInterwikis; $this->interwikiLookup = $interwikiLookup; $this->nsInfo = $nsInfo; // Default callback is to return a real MalformedTitleException, // callback signature matches constructor $this->createMalformedTitleException = static function ( $errorMessage, $titleText = null, $errorMessageParameters = [] ): MalformedTitleException { return new MalformedTitleException( $errorMessage, $titleText, $errorMessageParameters ); }; } /** * @internal * @param callable $callback */ public function overrideCreateMalformedTitleExceptionCallback( callable $callback ) { // @codeCoverageIgnoreStart if ( !defined( 'MW_PHPUNIT_TEST' ) ) { throw new LogicException( __METHOD__ . ' can only be used in tests' ); } // @codeCoverageIgnoreEnd $this->createMalformedTitleException = $callback; } /** * @see TitleFormatter::getNamespaceName() * * @param int $namespace * @param string $text * * @throws InvalidArgumentException If the namespace is invalid * @return string Namespace name with underscores (not spaces), e.g. 'User_talk' */ public function getNamespaceName( $namespace, $text ) { if ( $this->language->needsGenderDistinction() && $this->nsInfo->hasGenderDistinction( $namespace ) ) { // NOTE: we are assuming here that the title text is a user name! $gender = $this->genderCache->getGenderOf( $text, __METHOD__ ); $name = $this->language->getGenderNsText( $namespace, $gender ); } else { $name = $this->language->getNsText( $namespace ); } if ( $name === false ) { throw new InvalidArgumentException( 'Unknown namespace ID: ' . $namespace ); } return $name; } /** * @see TitleFormatter::formatTitle() * * @param int|false $namespace The namespace ID (or false, if the namespace should be ignored) * @param string $text The page title. Should be valid. Only minimal normalization is applied. * Underscores will be replaced. * @param string $fragment The fragment name (may be empty). * @param string $interwiki The interwiki name (may be empty). * * @throws InvalidArgumentException If the namespace is invalid * @return string */ public function formatTitle( $namespace, $text, $fragment = '', $interwiki = '' ) { $out = ''; if ( $interwiki !== '' ) { $out = $interwiki . ':'; } if ( $namespace != 0 ) { try { $nsName = $this->getNamespaceName( $namespace, $text ); } catch ( InvalidArgumentException $e ) { // See T165149. Awkward, but better than erroneously linking to the main namespace. $nsName = $this->language->getNsText( NS_SPECIAL ) . ":Badtitle/NS{$namespace}"; } $out .= $nsName . ':'; } $out .= $text; if ( $fragment !== '' ) { $out .= '#' . $fragment; } $out = str_replace( '_', ' ', $out ); return $out; } /** * Parses the given text and constructs a TitleValue. * * @param string $text The text to parse * @param int $defaultNamespace Namespace to assume by default (usually NS_MAIN) * * @throws MalformedTitleException * @return TitleValue */ public function parseTitle( $text, $defaultNamespace = NS_MAIN ) { // Convert things like é ā or 〗 into normalized (T16952) text $filteredText = Sanitizer::decodeCharReferencesAndNormalize( $text ); // NOTE: this is an ugly kludge that allows this class to share the // code for parsing with the old Title class. The parser code should // be refactored to avoid this. $parts = $this->splitTitleString( $filteredText, $defaultNamespace ); return new TitleValue( $parts['namespace'], $parts['dbkey'], $parts['fragment'], $parts['interwiki'] ); } /** * Given a namespace and title, return a TitleValue if valid, or null if invalid. * * @param int $namespace * @param string $text * @param string $fragment * @param string $interwiki * * @return TitleValue|null */ public function makeTitleValueSafe( $namespace, $text, $fragment = '', $interwiki = '' ) { if ( !$this->nsInfo->exists( $namespace ) ) { return null; } $canonicalNs = $this->nsInfo->getCanonicalName( $namespace ); $fullText = $canonicalNs == '' ? $text : "$canonicalNs:$text"; if ( strval( $interwiki ) != '' ) { $fullText = "$interwiki:$fullText"; } if ( strval( $fragment ) != '' ) { $fullText .= '#' . $fragment; } try { $parts = $this->splitTitleString( $fullText ); } catch ( MalformedTitleException $e ) { return null; } return new TitleValue( $parts['namespace'], $parts['dbkey'], $parts['fragment'], $parts['interwiki'] ); } /** * @see TitleFormatter::getText() * * @param LinkTarget|PageReference $title * * @return string */ public function getText( $title ) { if ( $title instanceof LinkTarget ) { return $title->getText(); } elseif ( $title instanceof PageReference ) { return strtr( $title->getDBKey(), '_', ' ' ); } else { throw new InvalidArgumentException( '$title has invalid type: ' . get_class( $title ) ); } } /** * @see TitleFormatter::getText() * * @param LinkTarget|PageReference $title * * @return string * @suppress PhanUndeclaredProperty */ public function getPrefixedText( $title ) { if ( $title instanceof LinkTarget ) { if ( !isset( $title->prefixedText ) ) { $title->prefixedText = $this->formatTitle( $title->getNamespace(), $title->getText(), '', $title->getInterwiki() ); } return $title->prefixedText; } elseif ( $title instanceof PageReference ) { $title->assertWiki( PageReference::LOCAL ); return $this->formatTitle( $title->getNamespace(), $this->getText( $title ) ); } else { throw new InvalidArgumentException( '$title has invalid type: ' . get_class( $title ) ); } } /** * @since 1.27 * @see TitleFormatter::getPrefixedDBkey() * @param LinkTarget|PageReference $target * @return string */ public function getPrefixedDBkey( $target ) { if ( $target instanceof LinkTarget ) { return strtr( $this->formatTitle( $target->getNamespace(), $target->getDBkey(), '', $target->getInterwiki() ), ' ', '_' ); } elseif ( $target instanceof PageReference ) { $target->assertWiki( PageReference::LOCAL ); return strtr( $this->formatTitle( $target->getNamespace(), $target->getDBkey() ), ' ', '_' ); } else { throw new InvalidArgumentException( '$title has invalid type: ' . get_class( $target ) ); } } /** * @see TitleFormatter::getText() * * @param LinkTarget|PageReference $title * * @return string */ public function getFullText( $title ) { if ( $title instanceof LinkTarget ) { return $this->formatTitle( $title->getNamespace(), $title->getText(), $title->getFragment(), $title->getInterwiki() ); } elseif ( $title instanceof PageReference ) { $title->assertWiki( PageReference::LOCAL ); return $this->formatTitle( $title->getNamespace(), $this->getText( $title ) ); } else { throw new InvalidArgumentException( '$title has invalid type: ' . get_class( $title ) ); } } /** * Validates, normalizes and splits a title string. * This is the "source of truth" for title validity. * * This function removes illegal characters, splits off the interwiki and * namespace prefixes, sets the other forms, and canonicalizes * everything. * * @todo this method is only exposed as a temporary measure to ease refactoring. * It was copied with minimal changes from Title::secureAndSplit(). * * @todo This method should be split up and an appropriate interface * defined for use by the Title class. * * @param string $text * @param int $defaultNamespace * * @internal * @throws MalformedTitleException If $text is not a valid title string. * @return array A map with the fields 'interwiki', 'fragment', 'namespace', and 'dbkey'. */ public function splitTitleString( $text, $defaultNamespace = NS_MAIN ) { $dbkey = str_replace( ' ', '_', $text ); # Initialisation $parts = [ 'interwiki' => '', 'local_interwiki' => false, 'fragment' => '', 'namespace' => (int)$defaultNamespace, 'dbkey' => $dbkey, ]; # Strip Unicode bidi override characters. # Sometimes they slip into cut-n-pasted page titles, where the # override chars get included in list displays. $dbkey = preg_replace( '/[\x{200E}\x{200F}\x{202A}-\x{202E}]+/u', '', $dbkey ); if ( $dbkey === null ) { # Regex had an error. Most likely this is caused by invalid UTF-8 $exception = ( $this->createMalformedTitleException )( 'title-invalid-utf8', $text ); throw $exception; } # Clean up whitespace $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey ); $dbkey = trim( $dbkey, '_' ); if ( strpos( $dbkey, \UtfNormal\Constants::UTF8_REPLACEMENT ) !== false ) { # Contained illegal UTF-8 sequences or forbidden Unicode chars. $exception = ( $this->createMalformedTitleException )( 'title-invalid-utf8', $text ); throw $exception; } $parts['dbkey'] = $dbkey; # Initial colon indicates main namespace rather than specified default # but should not create invalid {ns,title} pairs such as {0,Project:Foo} if ( $dbkey !== '' && $dbkey[0] == ':' ) { $parts['namespace'] = NS_MAIN; $dbkey = substr( $dbkey, 1 ); # remove the colon but continue processing $dbkey = trim( $dbkey, '_' ); # remove any subsequent whitespace } if ( $dbkey == '' ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-empty', $text ); throw $exception; } # Namespace or interwiki prefix $prefixRegexp = "/^(.+?)_*:_*(.*)$/S"; do { $m = []; if ( preg_match( $prefixRegexp, $dbkey, $m ) ) { $p = $m[1]; $ns = $this->language->getNsIndex( $p ); if ( $ns !== false ) { # Ordinary namespace $dbkey = $m[2]; $parts['namespace'] = $ns; # For Talk:X pages, check if X has a "namespace" prefix if ( $ns === NS_TALK && preg_match( $prefixRegexp, $dbkey, $x ) ) { if ( $this->language->getNsIndex( $x[1] ) ) { # Disallow Talk:File:x type titles... $exception = ( $this->createMalformedTitleException )( 'title-invalid-talk-namespace', $text ); throw $exception; } elseif ( $this->interwikiLookup->isValidInterwiki( $x[1] ) ) { # Disallow Talk:Interwiki:x type titles... $exception = ( $this->createMalformedTitleException )( 'title-invalid-talk-namespace', $text ); throw $exception; } } } elseif ( $this->interwikiLookup->isValidInterwiki( $p ) ) { # Interwiki link $dbkey = $m[2]; $parts['interwiki'] = $this->language->lc( $p ); # Redundant interwiki prefix to the local wiki foreach ( $this->localInterwikis as $localIW ) { if ( strcasecmp( $parts['interwiki'], $localIW ) == 0 ) { if ( $dbkey == '' ) { # Empty self-links should point to the Main Page, to ensure # compatibility with cross-wiki transclusions and the like. $mainPage = Title::newMainPage(); return [ 'interwiki' => $mainPage->getInterwiki(), 'local_interwiki' => true, 'fragment' => $mainPage->getFragment(), 'namespace' => $mainPage->getNamespace(), 'dbkey' => $mainPage->getDBkey(), ]; } $parts['interwiki'] = ''; # local interwikis should behave like initial-colon links $parts['local_interwiki'] = true; # Do another namespace split... continue 2; } } # If there's an initial colon after the interwiki, that also # resets the default namespace if ( $dbkey !== '' && $dbkey[0] == ':' ) { $parts['namespace'] = NS_MAIN; $dbkey = substr( $dbkey, 1 ); $dbkey = trim( $dbkey, '_' ); } } # If there's no recognized interwiki or namespace, # then let the colon expression be part of the title. } break; } while ( true ); $fragment = strstr( $dbkey, '#' ); if ( $fragment !== false ) { $parts['fragment'] = str_replace( '_', ' ', substr( $fragment, 1 ) ); $dbkey = substr( $dbkey, 0, strlen( $dbkey ) - strlen( $fragment ) ); # remove whitespace again: prevents "Foo_bar_#" # becoming "Foo_bar_" $dbkey = rtrim( $dbkey, "_" ); } # Reject illegal characters. $rxTc = self::getTitleInvalidRegex(); $matches = []; if ( preg_match( $rxTc, $dbkey, $matches ) ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-characters', $text, [ $matches[0] ] ); throw $exception; } # Pages with "/./" or "/../" appearing in the URLs will often be un- # reachable due to the way web browsers deal with 'relative' URLs. # Also, they conflict with subpage syntax. Forbid them explicitly. if ( str_contains( $dbkey, '.' ) && ( $dbkey === '.' || $dbkey === '..' || str_starts_with( $dbkey, './' ) || str_starts_with( $dbkey, '../' ) || str_contains( $dbkey, '/./' ) || str_contains( $dbkey, '/../' ) || str_ends_with( $dbkey, '/.' ) || str_ends_with( $dbkey, '/..' ) ) ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-relative', $text ); throw $exception; } # Magic tilde sequences? Nu-uh! if ( strpos( $dbkey, '~~~' ) !== false ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-magic-tilde', $text ); throw $exception; } # Limit the size of titles to 255 bytes. This is typically the size of the # underlying database field. We make an exception for special pages, which # don't need to be stored in the database, and may edge over 255 bytes due # to subpage syntax for long titles, e.g. [[Special:Block/Long name]] $maxLength = ( $parts['namespace'] !== NS_SPECIAL ) ? 255 : 512; if ( strlen( $dbkey ) > $maxLength ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-too-long', $text, [ Message::numParam( $maxLength ) ] ); throw $exception; } # Normally, all wiki links are forced to have an initial capital letter so [[foo]] # and [[Foo]] point to the same place. Don't force it for interwikis, since the # other site might be case-sensitive. if ( $parts['interwiki'] === '' && $this->nsInfo->isCapitalized( $parts['namespace'] ) ) { $dbkey = $this->language->ucfirst( $dbkey ); } # Can't make a link to a namespace alone... "empty" local links can only be # self-links with a fragment identifier. if ( $dbkey == '' && $parts['interwiki'] === '' && $parts['namespace'] !== NS_MAIN ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-empty', $text ); throw $exception; } // Allow IPv6 usernames to start with '::' by canonicalizing IPv6 titles. // IP names are not allowed for accounts, and can only be referring to // edits from the IP. Given '::' abbreviations and caps/lowercaps, // there are numerous ways to present the same IP. Having sp:contribs scan // them all is silly and having some show the edits and others not is // inconsistent. Same for talk/userpages. Keep them normalized instead. if ( $dbkey !== '' && ( $parts['namespace'] === NS_USER || $parts['namespace'] === NS_USER_TALK ) ) { $dbkey = IPUtils::sanitizeIP( $dbkey ); // IPUtils::sanitizeIP return null only for bad input '@phan-var string $dbkey'; } // Any remaining initial :s are illegal. if ( $dbkey !== '' && $dbkey[0] == ':' ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid-leading-colon', $text ); throw $exception; } // Fill fields $parts['dbkey'] = $dbkey; // Check to ensure that the return value can be used to construct a TitleValue. // All issues should in theory be caught above, this is here to enforce consistency. try { TitleValue::assertValidSpec( $parts['namespace'], $parts['dbkey'], $parts['fragment'], $parts['interwiki'] ); } catch ( InvalidArgumentException $ex ) { $exception = ( $this->createMalformedTitleException )( 'title-invalid', $text, [ $ex->getMessage() ] ); throw $exception; } return $parts; } /** * Returns a simple regex that will match on characters and sequences invalid in titles. * Note that this doesn't pick up many things that could be wrong with titles, but that * replacing this regex with something valid will make many titles valid. * Previously Title::getTitleInvalidRegex() * * @return string Regex string * @since 1.25 */ public static function getTitleInvalidRegex() { static $rxTc = false; if ( !$rxTc ) { # Matching titles will be held as illegal. $rxTc = '/' . # Any character not allowed is forbidden... '[^' . Title::legalChars() . ']' . # URL percent encoding sequences interfere with the ability # to round-trip titles -- you can't link to them consistently. '|%[0-9A-Fa-f]{2}' . # XML/HTML character references produce similar issues. '|&[A-Za-z0-9\x80-\xff]+;' . '/S'; } return $rxTc; } } /** @deprecated class alias since 1.41 */ class_alias( MediaWikiTitleCodec::class, 'MediaWikiTitleCodec' ); PK ! ��y�� � ForeignTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; /** * A parser that translates page titles into ForeignTitle objects. */ interface ForeignTitleFactory { /** * Create a ForeignTitle object. * * Based on the page title and optionally the namespace ID, of a page on a foreign wiki. * These values could be, for example, the `<title>` and `<ns>` attributes found in an * XML dump. * * @param string $title The page title * @param int|null $ns The namespace ID, or null if this data is not available * @return ForeignTitle */ public function createForeignTitle( $title, $ns = null ); } /** @deprecated class alias since 1.41 */ class_alias( ForeignTitleFactory::class, 'ForeignTitleFactory' ); PK ! 5���� � TitleFactory.phpnu �Iw�� <?php /** * Factory for creating Title objects without static coupling. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use MediaWiki\Linker\LinkTarget; use MediaWiki\Page\PageIdentity; use MediaWiki\Page\PageReference; use MessageLocalizer; use Wikimedia\Rdbms\IResultWrapper; /** * Creates Title objects. * * For now, there is nothing interesting in this class. It is meant for preventing static Title * methods causing problems in unit tests. * * @since 1.35 */ class TitleFactory { /** * @see Title::newFromDBkey * @param string $key * @return Title|null */ public function newFromDBkey( $key ): ?Title { return Title::newFromDBkey( $key ); } /** * @see Title::newFromLinkTarget * @param LinkTarget $linkTarget * @param string $forceClone * @return Title */ public function newFromLinkTarget( LinkTarget $linkTarget, $forceClone = '' ): Title { return Title::newFromLinkTarget( $linkTarget, $forceClone ); } /** * @see Title::castFromLinkTarget * @param LinkTarget|null $linkTarget * @return Title|null */ public function castFromLinkTarget( ?LinkTarget $linkTarget ): ?Title { return Title::castFromLinkTarget( $linkTarget ); } /** * @see Title::newFromPageIdentity * @since 1.41 * @param PageIdentity $pageIdentity * @return Title */ public function newFromPageIdentity( PageIdentity $pageIdentity ): Title { return Title::newFromPageIdentity( $pageIdentity ); } /** * @see Title::castFromPageIdentity * @since 1.36 * @param PageIdentity|null $pageIdentity * @return Title|null */ public function castFromPageIdentity( ?PageIdentity $pageIdentity ): ?Title { return Title::castFromPageIdentity( $pageIdentity ); } /** * @see Title::newFromPageReference * @since 1.41 * @param PageReference $pageReference * @return Title */ public function newFromPageReference( PageReference $pageReference ): Title { return Title::newFromPageReference( $pageReference ); } /** * @see Title::castFromPageReference * @since 1.37 * @param PageReference|null $pageReference * @return Title|null */ public function castFromPageReference( ?PageReference $pageReference ): ?Title { return Title::castFromPageReference( $pageReference ); } /** * @see Title::newFromText * @param string|int|null $text * @param int $defaultNamespace * @return Title|null * @throws \InvalidArgumentException */ public function newFromText( $text, $defaultNamespace = NS_MAIN ): ?Title { return Title::newFromText( $text, $defaultNamespace ); } /** * @see Title::newFromTextThrow * @param string $text * @param int $defaultNamespace * @return Title * @throws MalformedTitleException */ public function newFromTextThrow( $text, $defaultNamespace = NS_MAIN ): Title { return Title::newFromTextThrow( $text, $defaultNamespace ); } /** * @see Title::newFromURL * @param string $url * @return Title|null */ public function newFromURL( $url ): ?Title { return Title::newFromURL( $url ); } /** * @see Title::newFromID * @param int $id * @param int $flags * @return Title|null */ public function newFromID( $id, $flags = 0 ): ?Title { return Title::newFromID( $id, $flags ); } /** * @see Title::newFromRow * @param \stdClass $row * @return Title */ public function newFromRow( $row ): Title { return Title::newFromRow( $row ); } /** * @see Title::makeTitle * @param int $ns * @param string $title * @param string $fragment * @param string $interwiki * @return Title */ public function makeTitle( $ns, $title, $fragment = '', $interwiki = '' ): Title { return Title::makeTitle( $ns, $title, $fragment, $interwiki ); } /** * @see Title::makeTitleSafe * @param int $ns * @param string $title * @param string $fragment * @param string $interwiki * @return Title|null */ public function makeTitleSafe( $ns, $title, $fragment = '', $interwiki = '' ): ?Title { return Title::makeTitleSafe( $ns, $title, $fragment, $interwiki ); } /** * @see Title::newMainPage * @param MessageLocalizer|null $localizer * @return Title */ public function newMainPage( ?MessageLocalizer $localizer = null ): Title { return Title::newMainPage( $localizer ); } /** * @since 1.42 * @param IResultWrapper $result * @return TitleArrayFromResult */ public function newTitleArrayFromResult( IResultWrapper $result ) { return new TitleArrayFromResult( $result ); } } /** @deprecated class alias since 1.41 */ class_alias( TitleFactory::class, 'TitleFactory' ); PK ! �p��w w NaiveForeignTitleFactory.phpnu �Iw�� <?php /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file */ namespace MediaWiki\Title; use MediaWiki\Language\Language; /** * A parser that translates page titles on a foreign wiki into ForeignTitle * objects, with no knowledge of the namespace setup on the foreign site. */ class NaiveForeignTitleFactory implements ForeignTitleFactory { private Language $contentLanguage; public function __construct( Language $contentLanguage ) { $this->contentLanguage = $contentLanguage; } /** * Create a ForeignTitle object. * * Based on the page title and optionally the namespace ID, of a page on a foreign wiki. * These values could be, for example, the `<title>` and `<ns>` attributes found in an * XML dump. * * Although exported XML dumps have contained a map of namespace IDs to names * since MW 1.5, the importer used to completely ignore the `<siteinfo>` tag * before MW 1.25. It is therefore possible that custom XML dumps (i.e. not * generated by Special:Export) have been created without this metadata. * As a result, this code falls back to using namespace data for the local * wiki (similar to buggy pre-1.25 behaviour) if $ns is not supplied. * * @param string $title The page title * @param int|null $ns The namespace ID, or null if this data is not available * @return ForeignTitle */ public function createForeignTitle( $title, $ns = null ) { $pieces = explode( ':', $title, 2 ); /** * Can we assume that the part of the page title before the colon is a * namespace name? * * XML export schema version 0.5 and earlier (MW 1.18 and earlier) does not * contain a <ns> tag, so we need to be able to handle that case. * * If we know the namespace ID, we assume a non-zero namespace ID means * the ':' sets off a valid namespace name. If we don't know the namespace * ID, we fall back to using the local wiki's namespace names to resolve * this -- better than nothing, and mimics the old crappy behavior */ $isNamespacePartValid = $ns === null ? $this->contentLanguage->getNsIndex( $pieces[0] ) !== false : $ns != 0; if ( count( $pieces ) === 2 && $isNamespacePartValid ) { [ $namespaceName, $pageName ] = $pieces; } else { $namespaceName = ''; $pageName = $title; } return new ForeignTitle( $ns, $namespaceName, $pageName ); } } /** @deprecated class alias since 1.41 */ class_alias( NaiveForeignTitleFactory::class, 'NaiveForeignTitleFactory' ); PK ! E�[�� � MalformedTitleException.phpnu �Iw�� PK ! �I��C C % 7 NamespaceAwareForeignTitleFactory.phpnu �Iw�� PK ! 9t�( ( � TitleParser.phpnu �Iw�� PK ! �d�l 6' SubpageImportTitleFactory.phpnu �Iw�� PK ! �h �0 TitleValue.phpnu �Iw�� PK ! ps4r�� �� �P Title.phpnu �Iw�� PK ! \Ts/ / ForeignTitle.phpnu �Iw�� PK ! Pb v- NaiveImportTitleFactory.phpnu �Iw�� PK ! ��R� � �9 TitleFormatter.phpnu �Iw�� PK ! ��q�� � �F ImportTitleFactory.phpnu �Iw�� PK ! Ѯ�bH bH �L NamespaceInfo.phpnu �Iw�� PK ! (=�i i +� NamespaceImportTitleFactory.phpnu �Iw�� PK ! �|� � Hook/NamespaceIsMovableHook.phpnu �Iw�� PK ! � ᬋ � M� Hook/CanonicalNamespacesHook.phpnu �Iw�� PK ! ,1�� � (� TitleArrayFromResult.phpnu �Iw�� PK ! @�L�kN kN a� MediaWikiTitleCodec.phpnu �Iw�� PK ! ��y�� � � ForeignTitleFactory.phpnu �Iw�� PK ! 5���� � TitleFactory.phpnu �Iw�� PK ! �p��w w NaiveForeignTitleFactory.phpnu �Iw�� PK w �&
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.01 |
proxy
|
phpinfo
|
ÐаÑтройка