includes/context/DerivativeContext.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @author Daniel Friesen
  19  * @file
  20  */
  21
  22 namespace MediaWiki\Context;
  23
  24 use MediaWiki\Config\Config;
  25 use MediaWiki\Language\Language;
  26 use MediaWiki\MediaWikiServices;
  27 use MediaWiki\Message\Message;
  28 use MediaWiki\Output\OutputPage;
  29 use MediaWiki\Permissions\Authority;
  30 use MediaWiki\Request\WebRequest;
  31 use MediaWiki\Title\Title;
  32 use MediaWiki\User\User;
  33 use Skin;
  34 use Timing;
  35 use Wikimedia\Assert\Assert;
  36 use Wikimedia\Message\MessageParam;
  37 use Wikimedia\Message\MessageSpecifier;
  38 use WikiPage;
  39
  40 /**
  41  * An IContextSource implementation which will inherit context from another source
  42  * but allow individual pieces of context to be changed locally
  43  * eg: A ContextSource that can inherit from the main RequestContext but have
  44  *     a different Title instance set on it.
  45  * @newable
  46  * @since 1.19
  47  */
  48 class DerivativeContext extends ContextSource implements MutableContext {
  49         /**
  50          * @var WebRequest
  51          */
  52         private $request;
  53
  54         /**
  55          * @var Title
  56          */
  57         private $title;
  58
  59         /**
  60          * @var WikiPage
  61          */
  62         private $wikipage;
  63
  64         /**
  65          * @var string|null|false
  66          */
  67         private $action = false;
  68
  69         /**
  70          * @var OutputPage
  71          */
  72         private $output;
  73
  74         /**
  75          * @var User|null
  76          */
  77         private $user;
  78
  79         /**
  80          * @var Authority
  81          */
  82         private $authority;
  83
  84         /**
  85          * @var Language
  86          */
  87         private $lang;
  88
  89         /**
  90          * @var Skin
  91          */
  92         private $skin;
  93
  94         /**
  95          * @var Config
  96          */
  97         private $config;
  98
  99         /**
 100          * @var Timing
 101          */
 102         private $timing;
 103
 104         /**
 105          * @stable to call
 106          * @param IContextSource $context Context to inherit from
 107          */
 108         public function __construct( IContextSource $context ) {
 109                 $this->setContext( $context );
 110         }
 111
 112         public function setConfig( Config $config ) {
 113                 $this->config = $config;
 114         }
 115
 116         /**
 117          * @return Config
 118          */
 119         public function getConfig() {
 120                 return $this->config ?: $this->getContext()->getConfig();
 121         }
 122
 123         /**
 124          * @return Timing
 125          */
 126         public function getTiming() {
 127                 return $this->timing ?: $this->getContext()->getTiming();
 128         }
 129
 130         public function setRequest( WebRequest $request ) {
 131                 $this->request = $request;
 132         }
 133
 134         /**
 135          * @return WebRequest
 136          */
 137         public function getRequest() {
 138                 return $this->request ?: $this->getContext()->getRequest();
 139         }
 140
 141         public function setTitle( Title $title ) {
 142                 $this->title = $title;
 143                 $this->action = null;
 144         }
 145
 146         /**
 147          * @return Title|null
 148          */
 149         public function getTitle() {
 150                 return $this->title ?: $this->getContext()->getTitle();
 151         }
 152
 153         /**
 154          * Check whether a WikiPage object can be get with getWikiPage().
 155          * Callers should expect that an exception is thrown from getWikiPage()
 156          * if this method returns false.
 157          *
 158          * @since 1.19
 159          * @return bool
 160          */
 161         public function canUseWikiPage() {
 162                 if ( $this->wikipage !== null ) {
 163                         return true;
 164                 }
 165
 166                 if ( $this->title !== null ) {
 167                         return $this->title->canExist();
 168                 }
 169
 170                 return $this->getContext()->canUseWikiPage();
 171         }
 172
 173         /**
 174          * @since 1.19
 175          * @param WikiPage $wikiPage
 176          */
 177         public function setWikiPage( WikiPage $wikiPage ) {
 178                 $pageTitle = $wikiPage->getTitle();
 179                 if ( !$this->title || !$pageTitle->equals( $this->title ) ) {
 180                         $this->setTitle( $pageTitle );
 181                 }
 182                 $this->wikipage = $wikiPage;
 183                 $this->action = null;
 184         }
 185
 186         /**
 187          * Get the WikiPage object.
 188          * May throw an exception if there's no Title object set or the Title object
 189          * belongs to a special namespace that doesn't have WikiPage, so use first
 190          * canUseWikiPage() to check whether this method can be called safely.
 191          *
 192          * @since 1.19
 193          * @return WikiPage
 194          */
 195         public function getWikiPage() {
 196                 if ( !$this->wikipage && $this->title ) {
 197                         $this->wikipage = MediaWikiServices::getInstance()->getWikiPageFactory()->newFromTitle( $this->title );
 198                 }
 199
 200                 return $this->wikipage ?: $this->getContext()->getWikiPage();
 201         }
 202
 203         /**
 204          * @since 1.38
 205          * @param string $action
 206          */
 207         public function setActionName( string $action ): void {
 208                 $this->action = $action;
 209         }
 210
 211         /**
 212          * Get the action name for the current web request.
 213          *
 214          * @since 1.38
 215          * @return string Action
 216          */
 217         public function getActionName(): string {
 218                 if ( $this->action === false ) {
 219                         return $this->getContext()->getActionName();
 220                 }
 221
 222                 $this->action ??= MediaWikiServices::getInstance()
 223                         ->getActionFactory()
 224                         ->getActionName( $this );
 225
 226                 return $this->action;
 227         }
 228
 229         public function setOutput( OutputPage $output ) {
 230                 $this->output = $output;
 231         }
 232
 233         /**
 234          * @return OutputPage
 235          */
 236         public function getOutput() {
 237                 return $this->output ?: $this->getContext()->getOutput();
 238         }
 239
 240         public function setUser( User $user ) {
 241                 $this->authority = $user;
 242                 $this->user = $user;
 243         }
 244
 245         /**
 246          * @return User
 247          */
 248         public function getUser() {
 249                 if ( !$this->user && $this->authority ) {
 250                         // Keep user consistent by using a possible set authority
 251                         $this->user = MediaWikiServices::getInstance()
 252                                 ->getUserFactory()
 253                                 ->newFromAuthority( $this->authority );
 254                 }
 255                 return $this->user ?: $this->getContext()->getUser();
 256         }
 257
 258         public function setAuthority( Authority $authority ) {
 259                 $this->authority = $authority;
 260                 // If needed, a User object is constructed from this authority
 261                 $this->user = null;
 262         }
 263
 264         /**
 265          * @since 1.36
 266          * @return Authority
 267          */
 268         public function getAuthority(): Authority {
 269                 return $this->authority ?: $this->getContext()->getAuthority();
 270         }
 271
 272         /**
 273          * @param Language|string $language Language instance or language code
 274          * @since 1.19
 275          */
 276         public function setLanguage( $language ) {
 277                 Assert::parameterType( [ Language::class, 'string' ], $language, '$language' );
 278                 if ( $language instanceof Language ) {
 279                         $this->lang = $language;
 280                 } else {
 281                         $language = RequestContext::sanitizeLangCode( $language );
 282                         $obj = MediaWikiServices::getInstance()->getLanguageFactory()->getLanguage( $language );
 283                         $this->lang = $obj;
 284                 }
 285         }
 286
 287         /**
 288          * @return Language
 289          * @since 1.19
 290          */
 291         public function getLanguage() {
 292                 return $this->lang ?: $this->getContext()->getLanguage();
 293         }
 294
 295         public function setSkin( Skin $skin ) {
 296                 $this->skin = clone $skin;
 297                 $this->skin->setContext( $this );
 298         }
 299
 300         /**
 301          * @return Skin
 302          */
 303         public function getSkin() {
 304                 return $this->skin ?: $this->getContext()->getSkin();
 305         }
 306
 307         /**
 308          * Get a message using the current context.
 309          *
 310          * This can't just inherit from ContextSource, since then
 311          * it would set only the original context, and not take
 312          * into account any changes.
 313          *
 314          * @param string|string[]|MessageSpecifier $key Message key, or array of keys,
 315          *   or a MessageSpecifier.
 316          * @phpcs:ignore Generic.Files.LineLength
 317          * @param MessageParam|MessageSpecifier|string|int|float|list<MessageParam|MessageSpecifier|string|int|float> ...$params
 318          *   See Message::params()
 319          * @return Message
 320          */
 321         public function msg( $key, ...$params ) {
 322                 // phpcs:ignore MediaWiki.Usage.ExtendClassUsage.FunctionVarUsage
 323                 return wfMessage( $key, ...$params )->setContext( $this );
 324         }
 325 }
 326
 327 /** @deprecated class alias since 1.42 */
 328 class_alias( DerivativeContext::class, 'DerivativeContext' );