includes/Rest/Handler/Helper/PageRestHelperFactory.php

   1 <?php
   2
   3 namespace MediaWiki\Rest\Handler\Helper;
   4
   5 use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
   6 use MediaWiki\Config\ServiceOptions;
   7 use MediaWiki\Content\IContentHandlerFactory;
   8 use MediaWiki\Edit\ParsoidOutputStash;
   9 use MediaWiki\Languages\LanguageConverterFactory;
  10 use MediaWiki\Languages\LanguageFactory;
  11 use MediaWiki\Page\PageIdentity;
  12 use MediaWiki\Page\PageLookup;
  13 use MediaWiki\Page\ParserOutputAccess;
  14 use MediaWiki\Page\RedirectStore;
  15 use MediaWiki\Parser\Parsoid\Config\SiteConfig as ParsoidSiteConfig;
  16 use MediaWiki\Parser\Parsoid\HtmlTransformFactory;
  17 use MediaWiki\Permissions\Authority;
  18 use MediaWiki\Rest\RequestInterface;
  19 use MediaWiki\Rest\ResponseFactory;
  20 use MediaWiki\Rest\Router;
  21 use MediaWiki\Revision\RevisionLookup;
  22 use MediaWiki\Revision\RevisionRecord;
  23 use MediaWiki\Revision\RevisionRenderer;
  24 use MediaWiki\Title\TitleFormatter;
  25 use Wikimedia\Bcp47Code\Bcp47Code;
  26
  27 /**
  28  * @since 1.40 Factory for helper objects designed for sharing logic between REST handlers that deal with page content.
  29  * @unstable during Parsoid migration
  30  */
  31 class PageRestHelperFactory {
  32
  33         /**
  34          * @internal
  35          */
  36         public const CONSTRUCTOR_OPTIONS = PageContentHelper::CONSTRUCTOR_OPTIONS;
  37
  38         private ServiceOptions $options;
  39         private RevisionLookup $revisionLookup;
  40         private RevisionRenderer $revisionRenderer;
  41         private TitleFormatter $titleFormatter;
  42         private PageLookup $pageLookup;
  43         private ParsoidOutputStash $parsoidOutputStash;
  44         private StatsdDataFactoryInterface $stats;
  45         private ParserOutputAccess $parserOutputAccess;
  46         private ParsoidSiteConfig $parsoidSiteConfig;
  47         private HtmlTransformFactory $htmlTransformFactory;
  48         private IContentHandlerFactory $contentHandlerFactory;
  49         private LanguageFactory $languageFactory;
  50         private RedirectStore $redirectStore;
  51         private LanguageConverterFactory $languageConverterFactory;
  52
  53         /**
  54          * @param ServiceOptions $options
  55          * @param RevisionLookup $revisionLookup
  56          * @param RevisionRenderer $revisionRenderer
  57          * @param TitleFormatter $titleFormatter
  58          * @param PageLookup $pageLookup
  59          * @param ParsoidOutputStash $parsoidOutputStash
  60          * @param StatsdDataFactoryInterface $statsDataFactory
  61          * @param ParserOutputAccess $parserOutputAccess
  62          * @param ParsoidSiteConfig $parsoidSiteConfig
  63          * @param HtmlTransformFactory $htmlTransformFactory
  64          * @param IContentHandlerFactory $contentHandlerFactory
  65          * @param LanguageFactory $languageFactory
  66          * @param RedirectStore $redirectStore
  67          * @param LanguageConverterFactory $languageConverterFactory
  68          */
  69         public function __construct(
  70                 ServiceOptions $options,
  71                 RevisionLookup $revisionLookup,
  72                 RevisionRenderer $revisionRenderer,
  73                 TitleFormatter $titleFormatter,
  74                 PageLookup $pageLookup,
  75                 ParsoidOutputStash $parsoidOutputStash,
  76                 StatsdDataFactoryInterface $statsDataFactory,
  77                 ParserOutputAccess $parserOutputAccess,
  78                 ParsoidSiteConfig $parsoidSiteConfig,
  79                 HtmlTransformFactory $htmlTransformFactory,
  80                 IContentHandlerFactory $contentHandlerFactory,
  81                 LanguageFactory $languageFactory,
  82                 RedirectStore $redirectStore,
  83                 LanguageConverterFactory $languageConverterFactory
  84         ) {
  85                 $this->options = $options;
  86                 $this->revisionLookup = $revisionLookup;
  87                 $this->revisionRenderer = $revisionRenderer;
  88                 $this->titleFormatter = $titleFormatter;
  89                 $this->pageLookup = $pageLookup;
  90                 $this->parsoidOutputStash = $parsoidOutputStash;
  91                 $this->stats = $statsDataFactory;
  92                 $this->parserOutputAccess = $parserOutputAccess;
  93                 $this->parsoidSiteConfig = $parsoidSiteConfig;
  94                 $this->htmlTransformFactory = $htmlTransformFactory;
  95                 $this->contentHandlerFactory = $contentHandlerFactory;
  96                 $this->languageFactory = $languageFactory;
  97                 $this->redirectStore = $redirectStore;
  98                 $this->languageConverterFactory = $languageConverterFactory;
  99         }
 100
 101         public function newRevisionContentHelper(): RevisionContentHelper {
 102                 return new RevisionContentHelper(
 103                         $this->options,
 104                         $this->revisionLookup,
 105                         $this->titleFormatter,
 106                         $this->pageLookup
 107                 );
 108         }
 109
 110         public function newPageContentHelper(): PageContentHelper {
 111                 return new PageContentHelper(
 112                         $this->options,
 113                         $this->revisionLookup,
 114                         $this->titleFormatter,
 115                         $this->pageLookup
 116                 );
 117         }
 118
 119         /**
 120          * Should we ignore page id mismatches between page and revision objects
 121          * in HTML/pagebundle requests? Mismatches arise because of page moves.
 122          * This is recommended only for handling calls to internal APIs.
 123          * @note Since 1.43, passing 'null' for $page has been deprecated.
 124          * @note Since 1.43, passing 'null' for $authority has been deprecated.
 125          * @note Since 1.43, passing $lenientRevHandling as the first parameter
 126          *  has been deprecated.
 127          * @param bool|PageIdentity|null $page
 128          *  If `false`, this argument is used as the value for $lenientRevHandling,
 129          *  for backward-compatibility.
 130          * @param array $parameters
 131          * @param ?Authority $authority
 132          * @param int|RevisionRecord|null $revision
 133          * @param bool $lenientRevHandling
 134          */
 135         public function newHtmlOutputRendererHelper(
 136                 $page = null,
 137                 array $parameters = [],
 138                 ?Authority $authority = null,
 139                 $revision = null,
 140                 bool $lenientRevHandling = false
 141         ): HtmlOutputRendererHelper {
 142                 if ( is_bool( $page ) ) {
 143                         // Backward compatibility w/ pre-1.43 (deprecated)
 144                         $lenientRevHandling = $page;
 145                         $page = null;
 146                         wfDeprecated( __METHOD__ . ' with boolean first parameter', '1.43' );
 147                 }
 148                 if ( $page === null ) {
 149                         wfDeprecated( __METHOD__ . ' with null $page', '1.43' );
 150                 }
 151                 if ( $authority === null ) {
 152                         wfDeprecated( __METHOD__ . ' with null $authority', '1.43' );
 153                 }
 154                 return new HtmlOutputRendererHelper(
 155                         $this->parsoidOutputStash,
 156                         $this->stats,
 157                         $this->parserOutputAccess,
 158                         $this->pageLookup,
 159                         $this->revisionLookup,
 160                         $this->revisionRenderer,
 161                         $this->parsoidSiteConfig,
 162                         $this->htmlTransformFactory,
 163                         $this->contentHandlerFactory,
 164                         $this->languageFactory,
 165                         $page,
 166                         $parameters,
 167                         $authority,
 168                         $revision,
 169                         $lenientRevHandling
 170                 );
 171         }
 172
 173         /**
 174          * @note Since 1.43, passing a null $page is deprecated.
 175          */
 176         public function newHtmlMessageOutputHelper( ?PageIdentity $page = null ): HtmlMessageOutputHelper {
 177                 if ( $page === null ) {
 178                         wfDeprecated( __METHOD__ . ' with null $page', '1.43' );
 179                 }
 180                 return new HtmlMessageOutputHelper( $page );
 181         }
 182
 183         public function newHtmlInputTransformHelper(
 184                 $envOptions = [],
 185                 ?PageIdentity $page = null,
 186                 $body = null,
 187                 array $parameters = [],
 188                 ?RevisionRecord $originalRevision = null,
 189                 ?Bcp47Code $pageLanguage = null
 190         ): HtmlInputTransformHelper {
 191                 if ( $page === null || $body === null ) {
 192                         wfDeprecated( __METHOD__ . ' without $page or $body' );
 193                 }
 194                 return new HtmlInputTransformHelper(
 195                         $this->stats,
 196                         $this->htmlTransformFactory,
 197                         $this->parsoidOutputStash,
 198                         $this->parserOutputAccess,
 199                         $this->pageLookup,
 200                         $this->revisionLookup,
 201                         $envOptions,
 202                         $page,
 203                         $body ?? '',
 204                         $parameters,
 205                         $originalRevision,
 206                         $pageLanguage
 207                 );
 208         }
 209
 210         /**
 211          * @since 1.41
 212          */
 213         public function newPageRedirectHelper(
 214                 ResponseFactory $responseFactory,
 215                 Router $router,
 216                 string $route,
 217                 RequestInterface $request
 218         ): PageRedirectHelper {
 219                 return new PageRedirectHelper(
 220                         $this->redirectStore,
 221                         $this->titleFormatter,
 222                         $responseFactory,
 223                         $router,
 224                         $route,
 225                         $request,
 226                         $this->languageConverterFactory
 227                 );
 228         }
 229
 230 }