wikimedia /
mediawiki
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like File often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use File, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 50 | abstract class File implements IDBAccessObject { |
||
| 51 | // Bitfield values akin to the Revision deletion constants |
||
| 52 | const DELETED_FILE = 1; |
||
| 53 | const DELETED_COMMENT = 2; |
||
| 54 | const DELETED_USER = 4; |
||
| 55 | const DELETED_RESTRICTED = 8; |
||
| 56 | |||
| 57 | /** Force rendering in the current process */ |
||
| 58 | const RENDER_NOW = 1; |
||
| 59 | /** |
||
| 60 | * Force rendering even if thumbnail already exist and using RENDER_NOW |
||
| 61 | * I.e. you have to pass both flags: File::RENDER_NOW | File::RENDER_FORCE |
||
| 62 | */ |
||
| 63 | const RENDER_FORCE = 2; |
||
| 64 | |||
| 65 | const DELETE_SOURCE = 1; |
||
| 66 | |||
| 67 | // Audience options for File::getDescription() |
||
| 68 | const FOR_PUBLIC = 1; |
||
| 69 | const FOR_THIS_USER = 2; |
||
| 70 | const RAW = 3; |
||
| 71 | |||
| 72 | // Options for File::thumbName() |
||
| 73 | const THUMB_FULL_NAME = 1; |
||
| 74 | |||
| 75 | /** |
||
| 76 | * Some member variables can be lazy-initialised using __get(). The |
||
| 77 | * initialisation function for these variables is always a function named |
||
| 78 | * like getVar(), where Var is the variable name with upper-case first |
||
| 79 | * letter. |
||
| 80 | * |
||
| 81 | * The following variables are initialised in this way in this base class: |
||
| 82 | * name, extension, handler, path, canRender, isSafeFile, |
||
| 83 | * transformScript, hashPath, pageCount, url |
||
| 84 | * |
||
| 85 | * Code within this class should generally use the accessor function |
||
| 86 | * directly, since __get() isn't re-entrant and therefore causes bugs that |
||
| 87 | * depend on initialisation order. |
||
| 88 | */ |
||
| 89 | |||
| 90 | /** |
||
| 91 | * The following member variables are not lazy-initialised |
||
| 92 | */ |
||
| 93 | |||
| 94 | /** @var FileRepo|LocalRepo|ForeignAPIRepo|bool */ |
||
| 95 | public $repo; |
||
| 96 | |||
| 97 | /** @var Title|string|bool */ |
||
| 98 | protected $title; |
||
| 99 | |||
| 100 | /** @var string Text of last error */ |
||
| 101 | protected $lastError; |
||
| 102 | |||
| 103 | /** @var string Main part of the title, with underscores (Title::getDBkey) */ |
||
| 104 | protected $redirected; |
||
| 105 | |||
| 106 | /** @var Title */ |
||
| 107 | protected $redirectedTitle; |
||
| 108 | |||
| 109 | /** @var FSFile|bool False if undefined */ |
||
| 110 | protected $fsFile; |
||
| 111 | |||
| 112 | /** @var MediaHandler */ |
||
| 113 | protected $handler; |
||
| 114 | |||
| 115 | /** @var string The URL corresponding to one of the four basic zones */ |
||
| 116 | protected $url; |
||
| 117 | |||
| 118 | /** @var string File extension */ |
||
| 119 | protected $extension; |
||
| 120 | |||
| 121 | /** @var string The name of a file from its title object */ |
||
| 122 | protected $name; |
||
| 123 | |||
| 124 | /** @var string The storage path corresponding to one of the zones */ |
||
| 125 | protected $path; |
||
| 126 | |||
| 127 | /** @var string Relative path including trailing slash */ |
||
| 128 | protected $hashPath; |
||
| 129 | |||
| 130 | /** @var string Number of pages of a multipage document, or false for |
||
| 131 | * documents which aren't multipage documents |
||
| 132 | */ |
||
| 133 | protected $pageCount; |
||
| 134 | |||
| 135 | /** @var string URL of transformscript (for example thumb.php) */ |
||
| 136 | protected $transformScript; |
||
| 137 | |||
| 138 | /** @var Title */ |
||
| 139 | protected $redirectTitle; |
||
| 140 | |||
| 141 | /** @var bool Whether the output of transform() for this file is likely to be valid. */ |
||
| 142 | protected $canRender; |
||
| 143 | |||
| 144 | /** @var bool Whether this media file is in a format that is unlikely to |
||
| 145 | * contain viruses or malicious content |
||
| 146 | */ |
||
| 147 | protected $isSafeFile; |
||
| 148 | |||
| 149 | /** @var string Required Repository class type */ |
||
| 150 | protected $repoClass = 'FileRepo'; |
||
| 151 | |||
| 152 | /** @var array Cache of tmp filepaths pointing to generated bucket thumbnails, keyed by width */ |
||
| 153 | protected $tmpBucketedThumbCache = []; |
||
| 154 | |||
| 155 | /** |
||
| 156 | * Call this constructor from child classes. |
||
| 157 | * |
||
| 158 | * Both $title and $repo are optional, though some functions |
||
| 159 | * may return false or throw exceptions if they are not set. |
||
| 160 | * Most subclasses will want to call assertRepoDefined() here. |
||
| 161 | * |
||
| 162 | * @param Title|string|bool $title |
||
| 163 | * @param FileRepo|bool $repo |
||
| 164 | */ |
||
| 165 | function __construct( $title, $repo ) { |
||
| 173 | |||
| 174 | /** |
||
| 175 | * Given a string or Title object return either a |
||
| 176 | * valid Title object with namespace NS_FILE or null |
||
| 177 | * |
||
| 178 | * @param Title|string $title |
||
| 179 | * @param string|bool $exception Use 'exception' to throw an error on bad titles |
||
| 180 | * @throws MWException |
||
| 181 | * @return Title|null |
||
| 182 | */ |
||
| 183 | static function normalizeTitle( $title, $exception = false ) { |
||
| 203 | |||
| 204 | function __get( $name ) { |
||
| 205 | $function = [ $this, 'get' . ucfirst( $name ) ]; |
||
| 206 | if ( !is_callable( $function ) ) { |
||
| 207 | return null; |
||
| 208 | } else { |
||
| 209 | $this->$name = call_user_func( $function ); |
||
| 210 | |||
| 211 | return $this->$name; |
||
| 212 | } |
||
| 213 | } |
||
| 214 | |||
| 215 | /** |
||
| 216 | * Normalize a file extension to the common form, making it lowercase and checking some synonyms, |
||
| 217 | * and ensure it's clean. Extensions with non-alphanumeric characters will be discarded. |
||
| 218 | * Keep in sync with mw.Title.normalizeExtension() in JS. |
||
| 219 | * |
||
| 220 | * @param string $extension File extension (without the leading dot) |
||
| 221 | * @return string File extension in canonical form |
||
| 222 | */ |
||
| 223 | static function normalizeExtension( $extension ) { |
||
| 239 | |||
| 240 | /** |
||
| 241 | * Checks if file extensions are compatible |
||
| 242 | * |
||
| 243 | * @param File $old Old file |
||
| 244 | * @param string $new New name |
||
| 245 | * |
||
| 246 | * @return bool|null |
||
| 247 | */ |
||
| 248 | static function checkExtensionCompatibility( File $old, $new ) { |
||
| 256 | |||
| 257 | /** |
||
| 258 | * Upgrade the database row if there is one |
||
| 259 | * Called by ImagePage |
||
| 260 | * STUB |
||
| 261 | */ |
||
| 262 | function upgradeRow() { |
||
| 264 | |||
| 265 | /** |
||
| 266 | * Split an internet media type into its two components; if not |
||
| 267 | * a two-part name, set the minor type to 'unknown'. |
||
| 268 | * |
||
| 269 | * @param string $mime "text/html" etc |
||
| 270 | * @return array ("text", "html") etc |
||
| 271 | */ |
||
| 272 | public static function splitMime( $mime ) { |
||
| 279 | |||
| 280 | /** |
||
| 281 | * Callback for usort() to do file sorts by name |
||
| 282 | * |
||
| 283 | * @param File $a |
||
| 284 | * @param File $b |
||
| 285 | * @return int Result of name comparison |
||
| 286 | */ |
||
| 287 | public static function compare( File $a, File $b ) { |
||
| 290 | |||
| 291 | /** |
||
| 292 | * Return the name of this file |
||
| 293 | * |
||
| 294 | * @return string |
||
| 295 | */ |
||
| 296 | public function getName() { |
||
| 304 | |||
| 305 | /** |
||
| 306 | * Get the file extension, e.g. "svg" |
||
| 307 | * |
||
| 308 | * @return string |
||
| 309 | */ |
||
| 310 | function getExtension() { |
||
| 319 | |||
| 320 | /** |
||
| 321 | * Return the associated title object |
||
| 322 | * |
||
| 323 | * @return Title |
||
| 324 | */ |
||
| 325 | public function getTitle() { |
||
| 328 | |||
| 329 | /** |
||
| 330 | * Return the title used to find this file |
||
| 331 | * |
||
| 332 | * @return Title |
||
| 333 | */ |
||
| 334 | public function getOriginalTitle() { |
||
| 341 | |||
| 342 | /** |
||
| 343 | * Return the URL of the file |
||
| 344 | * |
||
| 345 | * @return string |
||
| 346 | */ |
||
| 347 | public function getUrl() { |
||
| 356 | |||
| 357 | /* |
||
| 358 | * Get short description URL for a files based on the page ID |
||
| 359 | * |
||
| 360 | * @return string|null |
||
| 361 | * @since 1.27 |
||
| 362 | */ |
||
| 363 | public function getDescriptionShortUrl() { |
||
| 366 | |||
| 367 | /** |
||
| 368 | * Return a fully-qualified URL to the file. |
||
| 369 | * Upload URL paths _may or may not_ be fully qualified, so |
||
| 370 | * we check. Local paths are assumed to belong on $wgServer. |
||
| 371 | * |
||
| 372 | * @return string |
||
| 373 | */ |
||
| 374 | public function getFullUrl() { |
||
| 377 | |||
| 378 | /** |
||
| 379 | * @return string |
||
| 380 | */ |
||
| 381 | public function getCanonicalUrl() { |
||
| 384 | |||
| 385 | /** |
||
| 386 | * @return string |
||
| 387 | */ |
||
| 388 | function getViewURL() { |
||
| 402 | |||
| 403 | /** |
||
| 404 | * Return the storage path to the file. Note that this does |
||
| 405 | * not mean that a file actually exists under that location. |
||
| 406 | * |
||
| 407 | * This path depends on whether directory hashing is active or not, |
||
| 408 | * i.e. whether the files are all found in the same directory, |
||
| 409 | * or in hashed paths like /images/3/3c. |
||
| 410 | * |
||
| 411 | * Most callers don't check the return value, but ForeignAPIFile::getPath |
||
| 412 | * returns false. |
||
| 413 | * |
||
| 414 | * @return string|bool ForeignAPIFile::getPath can return false |
||
| 415 | */ |
||
| 416 | public function getPath() { |
||
| 424 | |||
| 425 | /** |
||
| 426 | * Get an FS copy or original of this file and return the path. |
||
| 427 | * Returns false on failure. Callers must not alter the file. |
||
| 428 | * Temporary files are cleared automatically. |
||
| 429 | * |
||
| 430 | * @return string|bool False on failure |
||
| 431 | */ |
||
| 432 | public function getLocalRefPath() { |
||
| 451 | |||
| 452 | /** |
||
| 453 | * Return the width of the image. Returns false if the width is unknown |
||
| 454 | * or undefined. |
||
| 455 | * |
||
| 456 | * STUB |
||
| 457 | * Overridden by LocalFile, UnregisteredLocalFile |
||
| 458 | * |
||
| 459 | * @param int $page |
||
| 460 | * @return int|bool |
||
| 461 | */ |
||
| 462 | public function getWidth( $page = 1 ) { |
||
| 465 | |||
| 466 | /** |
||
| 467 | * Return the height of the image. Returns false if the height is unknown |
||
| 468 | * or undefined |
||
| 469 | * |
||
| 470 | * STUB |
||
| 471 | * Overridden by LocalFile, UnregisteredLocalFile |
||
| 472 | * |
||
| 473 | * @param int $page |
||
| 474 | * @return bool|int False on failure |
||
| 475 | */ |
||
| 476 | public function getHeight( $page = 1 ) { |
||
| 479 | |||
| 480 | /** |
||
| 481 | * Return the smallest bucket from $wgThumbnailBuckets which is at least |
||
| 482 | * $wgThumbnailMinimumBucketDistance larger than $desiredWidth. The returned bucket, if any, |
||
| 483 | * will always be bigger than $desiredWidth. |
||
| 484 | * |
||
| 485 | * @param int $desiredWidth |
||
| 486 | * @param int $page |
||
| 487 | * @return bool|int |
||
| 488 | */ |
||
| 489 | public function getThumbnailBucket( $desiredWidth, $page = 1 ) { |
||
| 523 | |||
| 524 | /** |
||
| 525 | * Returns ID or name of user who uploaded the file |
||
| 526 | * STUB |
||
| 527 | * |
||
| 528 | * @param string $type 'text' or 'id' |
||
| 529 | * @return string|int |
||
| 530 | */ |
||
| 531 | public function getUser( $type = 'text' ) { |
||
| 534 | |||
| 535 | /** |
||
| 536 | * Get the duration of a media file in seconds |
||
| 537 | * |
||
| 538 | * @return int |
||
| 539 | */ |
||
| 540 | public function getLength() { |
||
| 548 | |||
| 549 | /** |
||
| 550 | * Return true if the file is vectorized |
||
| 551 | * |
||
| 552 | * @return bool |
||
| 553 | */ |
||
| 554 | public function isVectorized() { |
||
| 562 | |||
| 563 | /** |
||
| 564 | * Gives a (possibly empty) list of languages to render |
||
| 565 | * the file in. |
||
| 566 | * |
||
| 567 | * If the file doesn't have translations, or if the file |
||
| 568 | * format does not support that sort of thing, returns |
||
| 569 | * an empty array. |
||
| 570 | * |
||
| 571 | * @return array |
||
| 572 | * @since 1.23 |
||
| 573 | */ |
||
| 574 | public function getAvailableLanguages() { |
||
| 582 | |||
| 583 | /** |
||
| 584 | * In files that support multiple language, what is the default language |
||
| 585 | * to use if none specified. |
||
| 586 | * |
||
| 587 | * @return string|null Lang code, or null if filetype doesn't support multiple languages. |
||
| 588 | * @since 1.23 |
||
| 589 | */ |
||
| 590 | public function getDefaultRenderLanguage() { |
||
| 598 | |||
| 599 | /** |
||
| 600 | * Will the thumbnail be animated if one would expect it to be. |
||
| 601 | * |
||
| 602 | * Currently used to add a warning to the image description page |
||
| 603 | * |
||
| 604 | * @return bool False if the main image is both animated |
||
| 605 | * and the thumbnail is not. In all other cases must return |
||
| 606 | * true. If image is not renderable whatsoever, should |
||
| 607 | * return true. |
||
| 608 | */ |
||
| 609 | public function canAnimateThumbIfAppropriate() { |
||
| 631 | |||
| 632 | /** |
||
| 633 | * Get handler-specific metadata |
||
| 634 | * Overridden by LocalFile, UnregisteredLocalFile |
||
| 635 | * STUB |
||
| 636 | * @return bool|array |
||
| 637 | */ |
||
| 638 | public function getMetadata() { |
||
| 641 | |||
| 642 | /** |
||
| 643 | * Like getMetadata but returns a handler independent array of common values. |
||
| 644 | * @see MediaHandler::getCommonMetaArray() |
||
| 645 | * @return array|bool Array or false if not supported |
||
| 646 | * @since 1.23 |
||
| 647 | */ |
||
| 648 | public function getCommonMetaArray() { |
||
| 657 | |||
| 658 | /** |
||
| 659 | * get versioned metadata |
||
| 660 | * |
||
| 661 | * @param array|string $metadata Array or string of (serialized) metadata |
||
| 662 | * @param int $version Version number. |
||
| 663 | * @return array Array containing metadata, or what was passed to it on fail |
||
| 664 | * (unserializing if not array) |
||
| 665 | */ |
||
| 666 | public function convertMetadataVersion( $metadata, $version ) { |
||
| 678 | |||
| 679 | /** |
||
| 680 | * Return the bit depth of the file |
||
| 681 | * Overridden by LocalFile |
||
| 682 | * STUB |
||
| 683 | * @return int |
||
| 684 | */ |
||
| 685 | public function getBitDepth() { |
||
| 688 | |||
| 689 | /** |
||
| 690 | * Return the size of the image file, in bytes |
||
| 691 | * Overridden by LocalFile, UnregisteredLocalFile |
||
| 692 | * STUB |
||
| 693 | * @return bool |
||
| 694 | */ |
||
| 695 | public function getSize() { |
||
| 698 | |||
| 699 | /** |
||
| 700 | * Returns the MIME type of the file. |
||
| 701 | * Overridden by LocalFile, UnregisteredLocalFile |
||
| 702 | * STUB |
||
| 703 | * |
||
| 704 | * @return string |
||
| 705 | */ |
||
| 706 | function getMimeType() { |
||
| 709 | |||
| 710 | /** |
||
| 711 | * Return the type of the media in the file. |
||
| 712 | * Use the value returned by this function with the MEDIATYPE_xxx constants. |
||
| 713 | * Overridden by LocalFile, |
||
| 714 | * STUB |
||
| 715 | * @return string |
||
| 716 | */ |
||
| 717 | function getMediaType() { |
||
| 720 | |||
| 721 | /** |
||
| 722 | * Checks if the output of transform() for this file is likely |
||
| 723 | * to be valid. If this is false, various user elements will |
||
| 724 | * display a placeholder instead. |
||
| 725 | * |
||
| 726 | * Currently, this checks if the file is an image format |
||
| 727 | * that can be converted to a format |
||
| 728 | * supported by all browsers (namely GIF, PNG and JPEG), |
||
| 729 | * or if it is an SVG image and SVG conversion is enabled. |
||
| 730 | * |
||
| 731 | * @return bool |
||
| 732 | */ |
||
| 733 | function canRender() { |
||
| 740 | |||
| 741 | /** |
||
| 742 | * Accessor for __get() |
||
| 743 | * @return bool |
||
| 744 | */ |
||
| 745 | protected function getCanRender() { |
||
| 748 | |||
| 749 | /** |
||
| 750 | * Return true if the file is of a type that can't be directly |
||
| 751 | * rendered by typical browsers and needs to be re-rasterized. |
||
| 752 | * |
||
| 753 | * This returns true for everything but the bitmap types |
||
| 754 | * supported by all browsers, i.e. JPEG; GIF and PNG. It will |
||
| 755 | * also return true for any non-image formats. |
||
| 756 | * |
||
| 757 | * @return bool |
||
| 758 | */ |
||
| 759 | function mustRender() { |
||
| 762 | |||
| 763 | /** |
||
| 764 | * Alias for canRender() |
||
| 765 | * |
||
| 766 | * @return bool |
||
| 767 | */ |
||
| 768 | function allowInlineDisplay() { |
||
| 771 | |||
| 772 | /** |
||
| 773 | * Determines if this media file is in a format that is unlikely to |
||
| 774 | * contain viruses or malicious content. It uses the global |
||
| 775 | * $wgTrustedMediaFormats list to determine if the file is safe. |
||
| 776 | * |
||
| 777 | * This is used to show a warning on the description page of non-safe files. |
||
| 778 | * It may also be used to disallow direct [[media:...]] links to such files. |
||
| 779 | * |
||
| 780 | * Note that this function will always return true if allowInlineDisplay() |
||
| 781 | * or isTrustedFile() is true for this file. |
||
| 782 | * |
||
| 783 | * @return bool |
||
| 784 | */ |
||
| 785 | function isSafeFile() { |
||
| 792 | |||
| 793 | /** |
||
| 794 | * Accessor for __get() |
||
| 795 | * |
||
| 796 | * @return bool |
||
| 797 | */ |
||
| 798 | protected function getIsSafeFile() { |
||
| 801 | |||
| 802 | /** |
||
| 803 | * Uncached accessor |
||
| 804 | * |
||
| 805 | * @return bool |
||
| 806 | */ |
||
| 807 | protected function getIsSafeFileUncached() { |
||
| 837 | |||
| 838 | /** |
||
| 839 | * Returns true if the file is flagged as trusted. Files flagged that way |
||
| 840 | * can be linked to directly, even if that is not allowed for this type of |
||
| 841 | * file normally. |
||
| 842 | * |
||
| 843 | * This is a dummy function right now and always returns false. It could be |
||
| 844 | * implemented to extract a flag from the database. The trusted flag could be |
||
| 845 | * set on upload, if the user has sufficient privileges, to bypass script- |
||
| 846 | * and html-filters. It may even be coupled with cryptographics signatures |
||
| 847 | * or such. |
||
| 848 | * |
||
| 849 | * @return bool |
||
| 850 | */ |
||
| 851 | function isTrustedFile() { |
||
| 856 | |||
| 857 | /** |
||
| 858 | * Load any lazy-loaded file object fields from source |
||
| 859 | * |
||
| 860 | * This is only useful when setting $flags |
||
| 861 | * |
||
| 862 | * Overridden by LocalFile to actually query the DB |
||
| 863 | * |
||
| 864 | * @param integer $flags Bitfield of File::READ_* constants |
||
| 865 | */ |
||
| 866 | public function load( $flags = 0 ) { |
||
| 868 | |||
| 869 | /** |
||
| 870 | * Returns true if file exists in the repository. |
||
| 871 | * |
||
| 872 | * Overridden by LocalFile to avoid unnecessary stat calls. |
||
| 873 | * |
||
| 874 | * @return bool Whether file exists in the repository. |
||
| 875 | */ |
||
| 876 | public function exists() { |
||
| 879 | |||
| 880 | /** |
||
| 881 | * Returns true if file exists in the repository and can be included in a page. |
||
| 882 | * It would be unsafe to include private images, making public thumbnails inadvertently |
||
| 883 | * |
||
| 884 | * @return bool Whether file exists in the repository and is includable. |
||
| 885 | */ |
||
| 886 | public function isVisible() { |
||
| 889 | |||
| 890 | /** |
||
| 891 | * @return string |
||
| 892 | */ |
||
| 893 | function getTransformScript() { |
||
| 906 | |||
| 907 | /** |
||
| 908 | * Get a ThumbnailImage which is the same size as the source |
||
| 909 | * |
||
| 910 | * @param array $handlerParams |
||
| 911 | * |
||
| 912 | * @return string |
||
| 913 | */ |
||
| 914 | function getUnscaledThumb( $handlerParams = [] ) { |
||
| 927 | |||
| 928 | /** |
||
| 929 | * Return the file name of a thumbnail with the specified parameters. |
||
| 930 | * Use File::THUMB_FULL_NAME to always get a name like "<params>-<source>". |
||
| 931 | * Otherwise, the format may be "<params>-<source>" or "<params>-thumbnail.<ext>". |
||
| 932 | * |
||
| 933 | * @param array $params Handler-specific parameters |
||
| 934 | * @param int $flags Bitfield that supports THUMB_* constants |
||
| 935 | * @return string|null |
||
| 936 | */ |
||
| 937 | public function thumbName( $params, $flags = 0 ) { |
||
| 944 | |||
| 945 | /** |
||
| 946 | * Generate a thumbnail file name from a name and specified parameters |
||
| 947 | * |
||
| 948 | * @param string $name |
||
| 949 | * @param array $params Parameters which will be passed to MediaHandler::makeParamString |
||
| 950 | * @return string|null |
||
| 951 | */ |
||
| 952 | public function generateThumbName( $name, $params ) { |
||
| 973 | |||
| 974 | /** |
||
| 975 | * Create a thumbnail of the image having the specified width/height. |
||
| 976 | * The thumbnail will not be created if the width is larger than the |
||
| 977 | * image's width. Let the browser do the scaling in this case. |
||
| 978 | * The thumbnail is stored on disk and is only computed if the thumbnail |
||
| 979 | * file does not exist OR if it is older than the image. |
||
| 980 | * Returns the URL. |
||
| 981 | * |
||
| 982 | * Keeps aspect ratio of original image. If both width and height are |
||
| 983 | * specified, the generated image will be no bigger than width x height, |
||
| 984 | * and will also have correct aspect ratio. |
||
| 985 | * |
||
| 986 | * @param int $width Maximum width of the generated thumbnail |
||
| 987 | * @param int $height Maximum height of the image (optional) |
||
| 988 | * |
||
| 989 | * @return string |
||
| 990 | */ |
||
| 991 | public function createThumb( $width, $height = -1 ) { |
||
| 1003 | |||
| 1004 | /** |
||
| 1005 | * Return either a MediaTransformError or placeholder thumbnail (if $wgIgnoreImageErrors) |
||
| 1006 | * |
||
| 1007 | * @param string $thumbPath Thumbnail storage path |
||
| 1008 | * @param string $thumbUrl Thumbnail URL |
||
| 1009 | * @param array $params |
||
| 1010 | * @param int $flags |
||
| 1011 | * @return MediaTransformOutput |
||
| 1012 | */ |
||
| 1013 | protected function transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags ) { |
||
| 1024 | |||
| 1025 | /** |
||
| 1026 | * Transform a media file |
||
| 1027 | * |
||
| 1028 | * @param array $params An associative array of handler-specific parameters. |
||
| 1029 | * Typical keys are width, height and page. |
||
| 1030 | * @param int $flags A bitfield, may contain self::RENDER_NOW to force rendering |
||
| 1031 | * @return ThumbnailImage|MediaTransformOutput|bool False on failure |
||
| 1032 | */ |
||
| 1033 | function transform( $params, $flags = 0 ) { |
||
| 1109 | |||
| 1110 | /** |
||
| 1111 | * Generates a thumbnail according to the given parameters and saves it to storage |
||
| 1112 | * @param TempFSFile $tmpFile Temporary file where the rendered thumbnail will be saved |
||
| 1113 | * @param array $transformParams |
||
| 1114 | * @param int $flags |
||
| 1115 | * @return bool|MediaTransformOutput |
||
| 1116 | */ |
||
| 1117 | public function generateAndSaveThumb( $tmpFile, $transformParams, $flags ) { |
||
| 1177 | |||
| 1178 | /** |
||
| 1179 | * Generates chained bucketed thumbnails if needed |
||
| 1180 | * @param array $params |
||
| 1181 | * @param int $flags |
||
| 1182 | * @return bool Whether at least one bucket was generated |
||
| 1183 | */ |
||
| 1184 | protected function generateBucketsIfNeeded( $params, $flags = 0 ) { |
||
| 1235 | |||
| 1236 | /** |
||
| 1237 | * Returns the most appropriate source image for the thumbnail, given a target thumbnail size |
||
| 1238 | * @param array $params |
||
| 1239 | * @return array Source path and width/height of the source |
||
| 1240 | */ |
||
| 1241 | public function getThumbnailSource( $params ) { |
||
| 1304 | |||
| 1305 | /** |
||
| 1306 | * Returns the repo path of the thumb for a given bucket |
||
| 1307 | * @param int $bucket |
||
| 1308 | * @return string |
||
| 1309 | */ |
||
| 1310 | protected function getBucketThumbPath( $bucket ) { |
||
| 1314 | |||
| 1315 | /** |
||
| 1316 | * Returns the name of the thumb for a given bucket |
||
| 1317 | * @param int $bucket |
||
| 1318 | * @return string |
||
| 1319 | */ |
||
| 1320 | protected function getBucketThumbName( $bucket ) { |
||
| 1323 | |||
| 1324 | /** |
||
| 1325 | * Creates a temp FS file with the same extension and the thumbnail |
||
| 1326 | * @param string $thumbPath Thumbnail path |
||
| 1327 | * @return TempFSFile|null |
||
| 1328 | */ |
||
| 1329 | protected function makeTransformTmpFile( $thumbPath ) { |
||
| 1333 | |||
| 1334 | /** |
||
| 1335 | * @param string $thumbName Thumbnail name |
||
| 1336 | * @param string $dispositionType Type of disposition (either "attachment" or "inline") |
||
| 1337 | * @return string Content-Disposition header value |
||
| 1338 | */ |
||
| 1339 | function getThumbDisposition( $thumbName, $dispositionType = 'inline' ) { |
||
| 1348 | |||
| 1349 | /** |
||
| 1350 | * Hook into transform() to allow migration of thumbnail files |
||
| 1351 | * STUB |
||
| 1352 | * Overridden by LocalFile |
||
| 1353 | * @param string $thumbName |
||
| 1354 | */ |
||
| 1355 | function migrateThumbFile( $thumbName ) { |
||
| 1357 | |||
| 1358 | /** |
||
| 1359 | * Get a MediaHandler instance for this file |
||
| 1360 | * |
||
| 1361 | * @return MediaHandler|bool Registered MediaHandler for file's MIME type |
||
| 1362 | * or false if none found |
||
| 1363 | */ |
||
| 1364 | function getHandler() { |
||
| 1371 | |||
| 1372 | /** |
||
| 1373 | * Get a ThumbnailImage representing a file type icon |
||
| 1374 | * |
||
| 1375 | * @return ThumbnailImage |
||
| 1376 | */ |
||
| 1377 | function iconThumb() { |
||
| 1393 | |||
| 1394 | /** |
||
| 1395 | * Get last thumbnailing error. |
||
| 1396 | * Largely obsolete. |
||
| 1397 | * @return string |
||
| 1398 | */ |
||
| 1399 | function getLastError() { |
||
| 1402 | |||
| 1403 | /** |
||
| 1404 | * Get all thumbnail names previously generated for this file |
||
| 1405 | * STUB |
||
| 1406 | * Overridden by LocalFile |
||
| 1407 | * @return array |
||
| 1408 | */ |
||
| 1409 | function getThumbnails() { |
||
| 1412 | |||
| 1413 | /** |
||
| 1414 | * Purge shared caches such as thumbnails and DB data caching |
||
| 1415 | * STUB |
||
| 1416 | * Overridden by LocalFile |
||
| 1417 | * @param array $options Options, which include: |
||
| 1418 | * 'forThumbRefresh' : The purging is only to refresh thumbnails |
||
| 1419 | */ |
||
| 1420 | function purgeCache( $options = [] ) { |
||
| 1422 | |||
| 1423 | /** |
||
| 1424 | * Purge the file description page, but don't go after |
||
| 1425 | * pages using the file. Use when modifying file history |
||
| 1426 | * but not the current data. |
||
| 1427 | */ |
||
| 1428 | function purgeDescription() { |
||
| 1435 | |||
| 1436 | /** |
||
| 1437 | * Purge metadata and all affected pages when the file is created, |
||
| 1438 | * deleted, or majorly updated. |
||
| 1439 | */ |
||
| 1440 | function purgeEverything() { |
||
| 1451 | |||
| 1452 | /** |
||
| 1453 | * Return a fragment of the history of file. |
||
| 1454 | * |
||
| 1455 | * STUB |
||
| 1456 | * @param int $limit Limit of rows to return |
||
| 1457 | * @param string $start Only revisions older than $start will be returned |
||
| 1458 | * @param string $end Only revisions newer than $end will be returned |
||
| 1459 | * @param bool $inc Include the endpoints of the time range |
||
| 1460 | * |
||
| 1461 | * @return File[] |
||
| 1462 | */ |
||
| 1463 | function getHistory( $limit = null, $start = null, $end = null, $inc = true ) { |
||
| 1466 | |||
| 1467 | /** |
||
| 1468 | * Return the history of this file, line by line. Starts with current version, |
||
| 1469 | * then old versions. Should return an object similar to an image/oldimage |
||
| 1470 | * database row. |
||
| 1471 | * |
||
| 1472 | * STUB |
||
| 1473 | * Overridden in LocalFile |
||
| 1474 | * @return bool |
||
| 1475 | */ |
||
| 1476 | public function nextHistoryLine() { |
||
| 1479 | |||
| 1480 | /** |
||
| 1481 | * Reset the history pointer to the first element of the history. |
||
| 1482 | * Always call this function after using nextHistoryLine() to free db resources |
||
| 1483 | * STUB |
||
| 1484 | * Overridden in LocalFile. |
||
| 1485 | */ |
||
| 1486 | public function resetHistory() { |
||
| 1488 | |||
| 1489 | /** |
||
| 1490 | * Get the filename hash component of the directory including trailing slash, |
||
| 1491 | * e.g. f/fa/ |
||
| 1492 | * If the repository is not hashed, returns an empty string. |
||
| 1493 | * |
||
| 1494 | * @return string |
||
| 1495 | */ |
||
| 1496 | function getHashPath() { |
||
| 1504 | |||
| 1505 | /** |
||
| 1506 | * Get the path of the file relative to the public zone root. |
||
| 1507 | * This function is overridden in OldLocalFile to be like getArchiveRel(). |
||
| 1508 | * |
||
| 1509 | * @return string |
||
| 1510 | */ |
||
| 1511 | function getRel() { |
||
| 1514 | |||
| 1515 | /** |
||
| 1516 | * Get the path of an archived file relative to the public zone root |
||
| 1517 | * |
||
| 1518 | * @param bool|string $suffix If not false, the name of an archived thumbnail file |
||
| 1519 | * |
||
| 1520 | * @return string |
||
| 1521 | */ |
||
| 1522 | View Code Duplication | function getArchiveRel( $suffix = false ) { |
|
| 1532 | |||
| 1533 | /** |
||
| 1534 | * Get the path, relative to the thumbnail zone root, of the |
||
| 1535 | * thumbnail directory or a particular file if $suffix is specified |
||
| 1536 | * |
||
| 1537 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1538 | * @return string |
||
| 1539 | */ |
||
| 1540 | function getThumbRel( $suffix = false ) { |
||
| 1548 | |||
| 1549 | /** |
||
| 1550 | * Get urlencoded path of the file relative to the public zone root. |
||
| 1551 | * This function is overridden in OldLocalFile to be like getArchiveUrl(). |
||
| 1552 | * |
||
| 1553 | * @return string |
||
| 1554 | */ |
||
| 1555 | function getUrlRel() { |
||
| 1558 | |||
| 1559 | /** |
||
| 1560 | * Get the path, relative to the thumbnail zone root, for an archived file's thumbs directory |
||
| 1561 | * or a specific thumb if the $suffix is given. |
||
| 1562 | * |
||
| 1563 | * @param string $archiveName The timestamped name of an archived image |
||
| 1564 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1565 | * @return string |
||
| 1566 | */ |
||
| 1567 | View Code Duplication | function getArchiveThumbRel( $archiveName, $suffix = false ) { |
|
| 1577 | |||
| 1578 | /** |
||
| 1579 | * Get the path of the archived file. |
||
| 1580 | * |
||
| 1581 | * @param bool|string $suffix If not false, the name of an archived file. |
||
| 1582 | * @return string |
||
| 1583 | */ |
||
| 1584 | function getArchivePath( $suffix = false ) { |
||
| 1589 | |||
| 1590 | /** |
||
| 1591 | * Get the path of an archived file's thumbs, or a particular thumb if $suffix is specified |
||
| 1592 | * |
||
| 1593 | * @param string $archiveName The timestamped name of an archived image |
||
| 1594 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1595 | * @return string |
||
| 1596 | */ |
||
| 1597 | function getArchiveThumbPath( $archiveName, $suffix = false ) { |
||
| 1603 | |||
| 1604 | /** |
||
| 1605 | * Get the path of the thumbnail directory, or a particular file if $suffix is specified |
||
| 1606 | * |
||
| 1607 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1608 | * @return string |
||
| 1609 | */ |
||
| 1610 | function getThumbPath( $suffix = false ) { |
||
| 1615 | |||
| 1616 | /** |
||
| 1617 | * Get the path of the transcoded directory, or a particular file if $suffix is specified |
||
| 1618 | * |
||
| 1619 | * @param bool|string $suffix If not false, the name of a media file |
||
| 1620 | * @return string |
||
| 1621 | */ |
||
| 1622 | function getTranscodedPath( $suffix = false ) { |
||
| 1627 | |||
| 1628 | /** |
||
| 1629 | * Get the URL of the archive directory, or a particular file if $suffix is specified |
||
| 1630 | * |
||
| 1631 | * @param bool|string $suffix If not false, the name of an archived file |
||
| 1632 | * @return string |
||
| 1633 | */ |
||
| 1634 | View Code Duplication | function getArchiveUrl( $suffix = false ) { |
|
| 1646 | |||
| 1647 | /** |
||
| 1648 | * Get the URL of the archived file's thumbs, or a particular thumb if $suffix is specified |
||
| 1649 | * |
||
| 1650 | * @param string $archiveName The timestamped name of an archived image |
||
| 1651 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1652 | * @return string |
||
| 1653 | */ |
||
| 1654 | View Code Duplication | function getArchiveThumbUrl( $archiveName, $suffix = false ) { |
|
| 1667 | |||
| 1668 | /** |
||
| 1669 | * Get the URL of the zone directory, or a particular file if $suffix is specified |
||
| 1670 | * |
||
| 1671 | * @param string $zone Name of requested zone |
||
| 1672 | * @param bool|string $suffix If not false, the name of a file in zone |
||
| 1673 | * @return string Path |
||
| 1674 | */ |
||
| 1675 | function getZoneUrl( $zone, $suffix = false ) { |
||
| 1685 | |||
| 1686 | /** |
||
| 1687 | * Get the URL of the thumbnail directory, or a particular file if $suffix is specified |
||
| 1688 | * |
||
| 1689 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1690 | * @return string Path |
||
| 1691 | */ |
||
| 1692 | function getThumbUrl( $suffix = false ) { |
||
| 1695 | |||
| 1696 | /** |
||
| 1697 | * Get the URL of the transcoded directory, or a particular file if $suffix is specified |
||
| 1698 | * |
||
| 1699 | * @param bool|string $suffix If not false, the name of a media file |
||
| 1700 | * @return string Path |
||
| 1701 | */ |
||
| 1702 | function getTranscodedUrl( $suffix = false ) { |
||
| 1705 | |||
| 1706 | /** |
||
| 1707 | * Get the public zone virtual URL for a current version source file |
||
| 1708 | * |
||
| 1709 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1710 | * @return string |
||
| 1711 | */ |
||
| 1712 | View Code Duplication | function getVirtualUrl( $suffix = false ) { |
|
| 1721 | |||
| 1722 | /** |
||
| 1723 | * Get the public zone virtual URL for an archived version source file |
||
| 1724 | * |
||
| 1725 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1726 | * @return string |
||
| 1727 | */ |
||
| 1728 | View Code Duplication | function getArchiveVirtualUrl( $suffix = false ) { |
|
| 1739 | |||
| 1740 | /** |
||
| 1741 | * Get the virtual URL for a thumbnail file or directory |
||
| 1742 | * |
||
| 1743 | * @param bool|string $suffix If not false, the name of a thumbnail file |
||
| 1744 | * @return string |
||
| 1745 | */ |
||
| 1746 | View Code Duplication | function getThumbVirtualUrl( $suffix = false ) { |
|
| 1755 | |||
| 1756 | /** |
||
| 1757 | * @return bool |
||
| 1758 | */ |
||
| 1759 | function isHashed() { |
||
| 1764 | |||
| 1765 | /** |
||
| 1766 | * @throws MWException |
||
| 1767 | */ |
||
| 1768 | function readOnlyError() { |
||
| 1771 | |||
| 1772 | /** |
||
| 1773 | * Record a file upload in the upload log and the image table |
||
| 1774 | * STUB |
||
| 1775 | * Overridden by LocalFile |
||
| 1776 | * @param string $oldver |
||
| 1777 | * @param string $desc |
||
| 1778 | * @param string $license |
||
| 1779 | * @param string $copyStatus |
||
| 1780 | * @param string $source |
||
| 1781 | * @param bool $watch |
||
| 1782 | * @param string|bool $timestamp |
||
| 1783 | * @param null|User $user User object or null to use $wgUser |
||
| 1784 | * @return bool |
||
| 1785 | * @throws MWException |
||
| 1786 | */ |
||
| 1787 | function recordUpload( $oldver, $desc, $license = '', $copyStatus = '', $source = '', |
||
| 1792 | |||
| 1793 | /** |
||
| 1794 | * Move or copy a file to its public location. If a file exists at the |
||
| 1795 | * destination, move it to an archive. Returns a FileRepoStatus object with |
||
| 1796 | * the archive name in the "value" member on success. |
||
| 1797 | * |
||
| 1798 | * The archive name should be passed through to recordUpload for database |
||
| 1799 | * registration. |
||
| 1800 | * |
||
| 1801 | * Options to $options include: |
||
| 1802 | * - headers : name/value map of HTTP headers to use in response to GET/HEAD requests |
||
| 1803 | * |
||
| 1804 | * @param string|FSFile $src Local filesystem path to the source image |
||
| 1805 | * @param int $flags A bitwise combination of: |
||
| 1806 | * File::DELETE_SOURCE Delete the source file, i.e. move rather than copy |
||
| 1807 | * @param array $options Optional additional parameters |
||
| 1808 | * @return Status On success, the value member contains the |
||
| 1809 | * archive name, or an empty string if it was a new file. |
||
| 1810 | * |
||
| 1811 | * STUB |
||
| 1812 | * Overridden by LocalFile |
||
| 1813 | */ |
||
| 1814 | function publish( $src, $flags = 0, array $options = [] ) { |
||
| 1817 | |||
| 1818 | /** |
||
| 1819 | * @param bool|IContextSource $context Context to use (optional) |
||
| 1820 | * @return bool |
||
| 1821 | */ |
||
| 1822 | function formatMetadata( $context = false ) { |
||
| 1829 | |||
| 1830 | /** |
||
| 1831 | * Returns true if the file comes from the local file repository. |
||
| 1832 | * |
||
| 1833 | * @return bool |
||
| 1834 | */ |
||
| 1835 | function isLocal() { |
||
| 1838 | |||
| 1839 | /** |
||
| 1840 | * Returns the name of the repository. |
||
| 1841 | * |
||
| 1842 | * @return string |
||
| 1843 | */ |
||
| 1844 | function getRepoName() { |
||
| 1847 | |||
| 1848 | /** |
||
| 1849 | * Returns the repository |
||
| 1850 | * |
||
| 1851 | * @return FileRepo|LocalRepo|bool |
||
| 1852 | */ |
||
| 1853 | function getRepo() { |
||
| 1856 | |||
| 1857 | /** |
||
| 1858 | * Returns true if the image is an old version |
||
| 1859 | * STUB |
||
| 1860 | * |
||
| 1861 | * @return bool |
||
| 1862 | */ |
||
| 1863 | function isOld() { |
||
| 1866 | |||
| 1867 | /** |
||
| 1868 | * Is this file a "deleted" file in a private archive? |
||
| 1869 | * STUB |
||
| 1870 | * |
||
| 1871 | * @param int $field One of DELETED_* bitfield constants |
||
| 1872 | * @return bool |
||
| 1873 | */ |
||
| 1874 | function isDeleted( $field ) { |
||
| 1877 | |||
| 1878 | /** |
||
| 1879 | * Return the deletion bitfield |
||
| 1880 | * STUB |
||
| 1881 | * @return int |
||
| 1882 | */ |
||
| 1883 | function getVisibility() { |
||
| 1886 | |||
| 1887 | /** |
||
| 1888 | * Was this file ever deleted from the wiki? |
||
| 1889 | * |
||
| 1890 | * @return bool |
||
| 1891 | */ |
||
| 1892 | function wasDeleted() { |
||
| 1897 | |||
| 1898 | /** |
||
| 1899 | * Move file to the new title |
||
| 1900 | * |
||
| 1901 | * Move current, old version and all thumbnails |
||
| 1902 | * to the new filename. Old file is deleted. |
||
| 1903 | * |
||
| 1904 | * Cache purging is done; checks for validity |
||
| 1905 | * and logging are caller's responsibility |
||
| 1906 | * |
||
| 1907 | * @param Title $target New file name |
||
| 1908 | * @return Status |
||
| 1909 | */ |
||
| 1910 | function move( $target ) { |
||
| 1913 | |||
| 1914 | /** |
||
| 1915 | * Delete all versions of the file. |
||
| 1916 | * |
||
| 1917 | * Moves the files into an archive directory (or deletes them) |
||
| 1918 | * and removes the database rows. |
||
| 1919 | * |
||
| 1920 | * Cache purging is done; logging is caller's responsibility. |
||
| 1921 | * |
||
| 1922 | * @param string $reason |
||
| 1923 | * @param bool $suppress Hide content from sysops? |
||
| 1924 | * @param User|null $user |
||
| 1925 | * @return Status |
||
| 1926 | * STUB |
||
| 1927 | * Overridden by LocalFile |
||
| 1928 | */ |
||
| 1929 | function delete( $reason, $suppress = false, $user = null ) { |
||
| 1932 | |||
| 1933 | /** |
||
| 1934 | * Restore all or specified deleted revisions to the given file. |
||
| 1935 | * Permissions and logging are left to the caller. |
||
| 1936 | * |
||
| 1937 | * May throw database exceptions on error. |
||
| 1938 | * |
||
| 1939 | * @param array $versions Set of record ids of deleted items to restore, |
||
| 1940 | * or empty to restore all revisions. |
||
| 1941 | * @param bool $unsuppress Remove restrictions on content upon restoration? |
||
| 1942 | * @return int|bool The number of file revisions restored if successful, |
||
| 1943 | * or false on failure |
||
| 1944 | * STUB |
||
| 1945 | * Overridden by LocalFile |
||
| 1946 | */ |
||
| 1947 | function restore( $versions = [], $unsuppress = false ) { |
||
| 1950 | |||
| 1951 | /** |
||
| 1952 | * Returns 'true' if this file is a type which supports multiple pages, |
||
| 1953 | * e.g. DJVU or PDF. Note that this may be true even if the file in |
||
| 1954 | * question only has a single page. |
||
| 1955 | * |
||
| 1956 | * @return bool |
||
| 1957 | */ |
||
| 1958 | function isMultipage() { |
||
| 1961 | |||
| 1962 | /** |
||
| 1963 | * Returns the number of pages of a multipage document, or false for |
||
| 1964 | * documents which aren't multipage documents |
||
| 1965 | * |
||
| 1966 | * @return bool|int |
||
| 1967 | */ |
||
| 1968 | View Code Duplication | function pageCount() { |
|
| 1979 | |||
| 1980 | /** |
||
| 1981 | * Calculate the height of a thumbnail using the source and destination width |
||
| 1982 | * |
||
| 1983 | * @param int $srcWidth |
||
| 1984 | * @param int $srcHeight |
||
| 1985 | * @param int $dstWidth |
||
| 1986 | * |
||
| 1987 | * @return int |
||
| 1988 | */ |
||
| 1989 | static function scaleHeight( $srcWidth, $srcHeight, $dstWidth ) { |
||
| 1997 | |||
| 1998 | /** |
||
| 1999 | * Get an image size array like that returned by getImageSize(), or false if it |
||
| 2000 | * can't be determined. Loads the image size directly from the file ignoring caches. |
||
| 2001 | * |
||
| 2002 | * @note Use getWidth()/getHeight() instead of this method unless you have a |
||
| 2003 | * a good reason. This method skips all caches. |
||
| 2004 | * |
||
| 2005 | * @param string $filePath The path to the file (e.g. From getLocalPathRef() ) |
||
| 2006 | * @return array The width, followed by height, with optionally more things after |
||
| 2007 | */ |
||
| 2008 | function getImageSize( $filePath ) { |
||
| 2015 | |||
| 2016 | /** |
||
| 2017 | * Get the URL of the image description page. May return false if it is |
||
| 2018 | * unknown or not applicable. |
||
| 2019 | * |
||
| 2020 | * @return string |
||
| 2021 | */ |
||
| 2022 | function getDescriptionUrl() { |
||
| 2029 | |||
| 2030 | /** |
||
| 2031 | * Get the HTML text of the description page, if available |
||
| 2032 | * |
||
| 2033 | * @param bool|Language $lang Optional language to fetch description in |
||
| 2034 | * @return string |
||
| 2035 | */ |
||
| 2036 | function getDescriptionText( $lang = false ) { |
||
| 2072 | |||
| 2073 | /** |
||
| 2074 | * Get description of file revision |
||
| 2075 | * STUB |
||
| 2076 | * |
||
| 2077 | * @param int $audience One of: |
||
| 2078 | * File::FOR_PUBLIC to be displayed to all users |
||
| 2079 | * File::FOR_THIS_USER to be displayed to the given user |
||
| 2080 | * File::RAW get the description regardless of permissions |
||
| 2081 | * @param User $user User object to check for, only if FOR_THIS_USER is |
||
| 2082 | * passed to the $audience parameter |
||
| 2083 | * @return string |
||
| 2084 | */ |
||
| 2085 | function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) { |
||
| 2088 | |||
| 2089 | /** |
||
| 2090 | * Get the 14-character timestamp of the file upload |
||
| 2091 | * |
||
| 2092 | * @return string|bool TS_MW timestamp or false on failure |
||
| 2093 | */ |
||
| 2094 | function getTimestamp() { |
||
| 2099 | |||
| 2100 | /** |
||
| 2101 | * Returns the timestamp (in TS_MW format) of the last change of the description page. |
||
| 2102 | * Returns false if the file does not have a description page, or retrieving the timestamp |
||
| 2103 | * would be expensive. |
||
| 2104 | * @since 1.25 |
||
| 2105 | * @return string|bool |
||
| 2106 | */ |
||
| 2107 | public function getDescriptionTouched() { |
||
| 2110 | |||
| 2111 | /** |
||
| 2112 | * Get the SHA-1 base 36 hash of the file |
||
| 2113 | * |
||
| 2114 | * @return string |
||
| 2115 | */ |
||
| 2116 | function getSha1() { |
||
| 2121 | |||
| 2122 | /** |
||
| 2123 | * Get the deletion archive key, "<sha1>.<ext>" |
||
| 2124 | * |
||
| 2125 | * @return string |
||
| 2126 | */ |
||
| 2127 | function getStorageKey() { |
||
| 2137 | |||
| 2138 | /** |
||
| 2139 | * Determine if the current user is allowed to view a particular |
||
| 2140 | * field of this file, if it's marked as deleted. |
||
| 2141 | * STUB |
||
| 2142 | * @param int $field |
||
| 2143 | * @param User $user User object to check, or null to use $wgUser |
||
| 2144 | * @return bool |
||
| 2145 | */ |
||
| 2146 | function userCan( $field, User $user = null ) { |
||
| 2149 | |||
| 2150 | /** |
||
| 2151 | * @return array HTTP header name/value map to use for HEAD/GET request responses |
||
| 2152 | */ |
||
| 2153 | function getStreamHeaders() { |
||
| 2161 | |||
| 2162 | /** |
||
| 2163 | * @return string |
||
| 2164 | */ |
||
| 2165 | function getLongDesc() { |
||
| 2173 | |||
| 2174 | /** |
||
| 2175 | * @return string |
||
| 2176 | */ |
||
| 2177 | function getShortDesc() { |
||
| 2185 | |||
| 2186 | /** |
||
| 2187 | * @return string |
||
| 2188 | */ |
||
| 2189 | function getDimensionsString() { |
||
| 2197 | |||
| 2198 | /** |
||
| 2199 | * @return string |
||
| 2200 | */ |
||
| 2201 | function getRedirected() { |
||
| 2204 | |||
| 2205 | /** |
||
| 2206 | * @return Title|null |
||
| 2207 | */ |
||
| 2208 | function getRedirectedTitle() { |
||
| 2219 | |||
| 2220 | /** |
||
| 2221 | * @param string $from |
||
| 2222 | * @return void |
||
| 2223 | */ |
||
| 2224 | function redirectedFrom( $from ) { |
||
| 2227 | |||
| 2228 | /** |
||
| 2229 | * @return bool |
||
| 2230 | */ |
||
| 2231 | function isMissing() { |
||
| 2234 | |||
| 2235 | /** |
||
| 2236 | * Check if this file object is small and can be cached |
||
| 2237 | * @return bool |
||
| 2238 | */ |
||
| 2239 | public function isCacheable() { |
||
| 2242 | |||
| 2243 | /** |
||
| 2244 | * Assert that $this->repo is set to a valid FileRepo instance |
||
| 2245 | * @throws MWException |
||
| 2246 | */ |
||
| 2247 | protected function assertRepoDefined() { |
||
| 2252 | |||
| 2253 | /** |
||
| 2254 | * Assert that $this->title is set to a Title |
||
| 2255 | * @throws MWException |
||
| 2256 | */ |
||
| 2257 | protected function assertTitleDefined() { |
||
| 2262 | |||
| 2263 | /** |
||
| 2264 | * True if creating thumbnails from the file is large or otherwise resource-intensive. |
||
| 2265 | * @return bool |
||
| 2266 | */ |
||
| 2267 | public function isExpensiveToThumbnail() { |
||
| 2271 | |||
| 2272 | /** |
||
| 2273 | * Whether the thumbnails created on the same server as this code is running. |
||
| 2274 | * @since 1.25 |
||
| 2275 | * @return bool |
||
| 2276 | */ |
||
| 2277 | public function isTransformedLocally() { |
||
| 2280 | } |
||
| 2281 |
Loading history...
This check looks at variables that are passed out again to other methods.
If the outgoing method call has stricter type requirements than the method itself, an issue is raised.
An additional type check may prevent trouble.