ArchivedFile::__construct() - Code Metrics - Inspection of "Daily Inspection: Merge "Add GENDER support to pro..." - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (939199)

unknown

created 2016-11-04 17:19 UTC

ArchivedFile::__construct() D

↳ Parent: ArchivedFile

Complexity

Conditions	9
Paths	32

Size

Total Lines	43
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	32
nc	32
nop	4
dl	0
loc	43
rs	4.909
c	0
b	0
f	0

<?php
/**
 * Deleted file in the 'filearchive' table.
 *
 * 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
 * @ingroup FileAbstraction
 */

/**
 * Class representing a row of the 'filearchive' table
 *
 * @ingroup FileAbstraction
 */
class ArchivedFile {
	/** @var int Filearchive row ID */
	private $id;

	/** @var string File name */
	private $name;

	/** @var string FileStore storage group */
	private $group;

	/** @var string FileStore SHA-1 key */
	private $key;

	/** @var int File size in bytes */
	private $size;

	/** @var int Size in bytes */
	private $bits;

	/** @var int Width */
	private $width;

	/** @var int Height */
	private $height;

	/** @var string Metadata string */
	private $metadata;

	/** @var string MIME type */
	private $mime;

	/** @var string Media type */
	private $media_type;

	/** @var string Upload description */
	private $description;

	/** @var int User ID of uploader */
	private $user;

	/** @var string User name of uploader */
	private $user_text;

	/** @var string Time of upload */
	private $timestamp;

	/** @var bool Whether or not all this has been loaded from the database (loadFromXxx) */
	private $dataLoaded;

	/** @var int Bitfield akin to rev_deleted */
	private $deleted;

	/** @var string SHA-1 hash of file content */
	private $sha1;

	/** @var string Number of pages of a multipage document, or false for
	 * documents which aren't multipage documents
	 */
	private $pageCount;

	/** @var string Original base filename */
	private $archive_name;

	/** @var MediaHandler */
	protected $handler;

	/** @var Title */
	protected $title; # image title

	/**
	 * @throws MWException
	 * @param Title $title
	 * @param int $id
	 * @param string $key
	 * @param string $sha1
	 */
	function __construct( $title, $id = 0, $key = '', $sha1 = '' ) {
		$this->id = -1;
		$this->title = false;

		$this->name = false;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
		$this->group = 'deleted'; // needed for direct use of constructor
		$this->key = '';
		$this->size = 0;
		$this->bits = 0;
		$this->width = 0;
		$this->height = 0;
		$this->metadata = '';
		$this->mime = "unknown/unknown";
		$this->media_type = '';
		$this->description = '';
		$this->user = 0;
		$this->user_text = '';
		$this->timestamp = null;
		$this->deleted = 0;
		$this->dataLoaded = false;
		$this->exists = false;
class MyClass { }

$x = new MyClass();
$x->foo = true;
		$this->sha1 = '';

		if ( $title instanceof Title ) {
			$this->title = File::normalizeTitle( $title, 'exception' );
			$this->name = $title->getDBkey();
		}

		if ( $id ) {
			$this->id = $id;
		}

		if ( $key ) {
			$this->key = $key;
		}

		if ( $sha1 ) {
			$this->sha1 = $sha1;
		}

		if ( !$id && !$key && !( $title instanceof Title ) && !$sha1 ) {
			throw new MWException( "No specifications provided to ArchivedFile constructor." );
		}
	}

	/**
	 * Loads a file object from the filearchive table
	 * @throws MWException
	 * @return bool|null True on success or null
	 */
	public function load() {
		if ( $this->dataLoaded ) {
			return true;
		}
		$conds = [];

		if ( $this->id > 0 ) {
			$conds['fa_id'] = $this->id;
		}
		if ( $this->key ) {
			$conds['fa_storage_group'] = $this->group;
			$conds['fa_storage_key'] = $this->key;
		}
		if ( $this->title ) {
			$conds['fa_name'] = $this->title->getDBkey();
		}
		if ( $this->sha1 ) {
			$conds['fa_sha1'] = $this->sha1;
		}

		if ( !count( $conds ) ) {
			throw new MWException( "No specific information for retrieving archived file" );
		}

		if ( !$this->title || $this->title->getNamespace() == NS_FILE ) {
			$this->dataLoaded = true; // set it here, to have also true on miss
			$dbr = wfGetDB( DB_REPLICA );
			$row = $dbr->selectRow(
				'filearchive',
				self::selectFields(),
				$conds,
				__METHOD__,
				[ 'ORDER BY' => 'fa_timestamp DESC' ]
			);
			if ( !$row ) {
				// this revision does not exist?
				return null;
			}

			// initialize fields for filestore image object
			$this->loadFromRow( $row );
		} else {
			throw new MWException( 'This title does not correspond to an image page.' );
		}
		$this->exists = true;

		return true;
	}

	/**
	 * Loads a file object from the filearchive table
	 *
	 * @param stdClass $row
	 * @return ArchivedFile
	 */
	public static function newFromRow( $row ) {
		$file = new ArchivedFile( Title::makeTitle( NS_FILE, $row->fa_name ) );
		$file->loadFromRow( $row );

		return $file;
	}

	/**
	 * Fields in the filearchive table
	 * @return array
	 */
	static function selectFields() {
		return [
			'fa_id',
			'fa_name',
			'fa_archive_name',
			'fa_storage_key',
			'fa_storage_group',
			'fa_size',
			'fa_bits',
			'fa_width',
			'fa_height',
			'fa_metadata',
			'fa_media_type',
			'fa_major_mime',
			'fa_minor_mime',
			'fa_description',
			'fa_user',
			'fa_user_text',
			'fa_timestamp',
			'fa_deleted',
			'fa_deleted_timestamp', /* Used by LocalFileRestoreBatch */
			'fa_sha1',
		];
	}

	/**
	 * Load ArchivedFile object fields from a DB row.
	 *
	 * @param stdClass $row Object database row
	 * @since 1.21
	 */
	public function loadFromRow( $row ) {
		$this->id = intval( $row->fa_id );
		$this->name = $row->fa_name;
		$this->archive_name = $row->fa_archive_name;
		$this->group = $row->fa_storage_group;
		$this->key = $row->fa_storage_key;
		$this->size = $row->fa_size;
		$this->bits = $row->fa_bits;
		$this->width = $row->fa_width;
		$this->height = $row->fa_height;
		$this->metadata = $row->fa_metadata;
		$this->mime = "$row->fa_major_mime/$row->fa_minor_mime";
		$this->media_type = $row->fa_media_type;
		$this->description = $row->fa_description;
		$this->user = $row->fa_user;
		$this->user_text = $row->fa_user_text;
		$this->timestamp = $row->fa_timestamp;
		$this->deleted = $row->fa_deleted;
		if ( isset( $row->fa_sha1 ) ) {
			$this->sha1 = $row->fa_sha1;
		} else {
			// old row, populate from key
			$this->sha1 = LocalRepo::getHashFromKey( $this->key );
		}
		if ( !$this->title ) {
			$this->title = Title::makeTitleSafe( NS_FILE, $row->fa_name );
		}
	}

	/**
	 * Return the associated title object
	 *
	 * @return Title
	 */
	public function getTitle() {
		if ( !$this->title ) {
			$this->load();
		}
		return $this->title;
	}

	/**
	 * Return the file name
	 *
	 * @return string
	 */
	public function getName() {
		if ( $this->name === false ) {
			$this->load();
		}

		return $this->name;
	}

	/**
	 * @return int
	 */
	public function getID() {
		$this->load();

		return $this->id;
	}

	/**
	 * @return bool
	 */
	public function exists() {
		$this->load();

		return $this->exists;
	}

	/**
	 * Return the FileStore key
	 * @return string
	 */
	public function getKey() {
		$this->load();

		return $this->key;
	}

	/**
	 * Return the FileStore key (overriding base File class)
	 * @return string
	 */
	public function getStorageKey() {
		return $this->getKey();
	}

	/**
	 * Return the FileStore storage group
	 * @return string
	 */
	public function getGroup() {
		return $this->group;
	}

	/**
	 * Return the width of the image
	 * @return int
	 */
	public function getWidth() {
		$this->load();

		return $this->width;
	}

	/**
	 * Return the height of the image
	 * @return int
	 */
	public function getHeight() {
		$this->load();

		return $this->height;
	}

	/**
	 * Get handler-specific metadata
	 * @return string
	 */
	public function getMetadata() {
		$this->load();

		return $this->metadata;
	}

	/**
	 * Return the size of the image file, in bytes
	 * @return int
	 */
	public function getSize() {
		$this->load();

		return $this->size;
	}

	/**
	 * Return the bits of the image file, in bytes
	 * @return int
	 */
	public function getBits() {
		$this->load();

		return $this->bits;
	}

	/**
	 * Returns the MIME type of the file.
	 * @return string
	 */
	public function getMimeType() {
		$this->load();

		return $this->mime;
	}

	/**
	 * Get a MediaHandler instance for this file
	 * @return MediaHandler
	 */
	function getHandler() {
		if ( !isset( $this->handler ) ) {
			$this->handler = MediaHandler::getHandler( $this->getMimeType() );
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
		}

		return $this->handler;
	}

	/**
	 * Returns the number of pages of a multipage document, or false for
	 * documents which aren't multipage documents
	 * @return bool|int
	 */
	function pageCount() {
		if ( !isset( $this->pageCount ) ) {
			// @FIXME: callers expect File objects
			if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
				$this->pageCount = $this->handler->pageCount( $this );
$answer = 42;

$correct = false;

$correct = (bool) $answer;
			} else {
				$this->pageCount = false;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
			}
		}

		return $this->pageCount;
	}

	/**
	 * Return the type of the media in the file.
	 * Use the value returned by this function with the MEDIATYPE_xxx constants.
	 * @return string
	 */
	public function getMediaType() {
		$this->load();

		return $this->media_type;
	}

	/**
	 * Return upload timestamp.
	 *
	 * @return string
	 */
	public function getTimestamp() {
		$this->load();

		return wfTimestamp( TS_MW, $this->timestamp );
	}

	/**
	 * Get the SHA-1 base 36 hash of the file
	 *
	 * @return string
	 * @since 1.21
	 */
	function getSha1() {
		$this->load();

		return $this->sha1;
	}

	/**
	 * Returns ID or name of user who uploaded the file
	 *
	 * @note Prior to MediaWiki 1.23, this method always
	 *   returned the user id, and was inconsistent with
	 *   the rest of the file classes.
	 * @param string $type 'text' or 'id'
	 * @return int|string
	 * @throws MWException
	 */
	public function getUser( $type = 'text' ) {
		$this->load();

		if ( $type == 'text' ) {
			return $this->user_text;
		} elseif ( $type == 'id' ) {
			return (int)$this->user;
		}

		throw new MWException( "Unknown type '$type'." );
	}

	/**
	 * Return the user name of the uploader.
	 *
	 * @deprecated since 1.23 Use getUser( 'text' ) instead.
	 * @return string
	 */
	public function getUserText() {
		wfDeprecated( __METHOD__, '1.23' );
		$this->load();
		if ( $this->isDeleted( File::DELETED_USER ) ) {
			return 0;
		} else {
			return $this->user_text;
		}
	}

	/**
	 * Return upload description.
	 *
	 * @return string
	 */
	public function getDescription() {
		$this->load();
		if ( $this->isDeleted( File::DELETED_COMMENT ) ) {
			return 0;
		} else {
			return $this->description;
		}
	}

	/**
	 * Return the user ID of the uploader.
	 *
	 * @return int
	 */
	public function getRawUser() {
		$this->load();

		return $this->user;
	}

	/**
	 * Return the user name of the uploader.
	 *
	 * @return string
	 */
	public function getRawUserText() {
		$this->load();

		return $this->user_text;
	}

	/**
	 * Return upload description.
	 *
	 * @return string
	 */
	public function getRawDescription() {
		$this->load();

		return $this->description;
	}

	/**
	 * Returns the deletion bitfield
	 * @return int
	 */
	public function getVisibility() {
		$this->load();

		return $this->deleted;
	}

	/**
	 * for file or revision rows
	 *
	 * @param int $field One of DELETED_* bitfield constants
	 * @return bool
	 */
	public function isDeleted( $field ) {
		$this->load();

		return ( $this->deleted & $field ) == $field;
	}

	/**
	 * Determine if the current user is allowed to view a particular
	 * field of this FileStore image file, if it's marked as deleted.
	 * @param int $field
	 * @param null|User $user User object to check, or null to use $wgUser
	 * @return bool
	 */
	public function userCan( $field, User $user = null ) {
		$this->load();

		$title = $this->getTitle();
		return Revision::userCanBitfield( $this->deleted, $field, $user, $title ?: null );
	}
}


1		<?php
2		/**
3		* Deleted file in the 'filearchive' table.
4		*
5		* This program is free software; you can redistribute it and/or modify
6		* it under the terms of the GNU General Public License as published by
7		* the Free Software Foundation; either version 2 of the License, or
8		* (at your option) any later version.
9		*
10		* This program is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU General Public License for more details.
14		*
15		* You should have received a copy of the GNU General Public License along
16		* with this program; if not, write to the Free Software Foundation, Inc.,
17		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18		* http://www.gnu.org/copyleft/gpl.html
19		*
20		* @file
21		* @ingroup FileAbstraction
22		*/
23
24		/**
25		* Class representing a row of the 'filearchive' table
26		*
27		* @ingroup FileAbstraction
28		*/
29		class ArchivedFile {
30		/** @var int Filearchive row ID */
31		private $id;
32
33		/** @var string File name */
34		private $name;
35
36		/** @var string FileStore storage group */
37		private $group;
38
39		/** @var string FileStore SHA-1 key */
40		private $key;
41
42		/** @var int File size in bytes */
43		private $size;
44
45		/** @var int Size in bytes */
46		private $bits;
47
48		/** @var int Width */
49		private $width;
50
51		/** @var int Height */
52		private $height;
53
54		/** @var string Metadata string */
55		private $metadata;
56
57		/** @var string MIME type */
58		private $mime;
59
60		/** @var string Media type */
61		private $media_type;
62
63		/** @var string Upload description */
64		private $description;
65
66		/** @var int User ID of uploader */
67		private $user;
68
69		/** @var string User name of uploader */
70		private $user_text;
71
72		/** @var string Time of upload */
73		private $timestamp;
74
75		/** @var bool Whether or not all this has been loaded from the database (loadFromXxx) */
76		private $dataLoaded;
77
78		/** @var int Bitfield akin to rev_deleted */
79		private $deleted;
80
81		/** @var string SHA-1 hash of file content */
82		private $sha1;
83
84		/** @var string Number of pages of a multipage document, or false for
85		* documents which aren't multipage documents
86		*/
87		private $pageCount;
88
89		/** @var string Original base filename */
90		private $archive_name;
91
92		/** @var MediaHandler */
93		protected $handler;
94
95		/** @var Title */
96		protected $title; # image title
97
98		/**
99		* @throws MWException
100		* @param Title $title
101		* @param int $id
102		* @param string $key
103		* @param string $sha1
104		*/
105		function __construct( $title, $id = 0, $key = '', $sha1 = '' ) {
106		$this->id = -1;
107		$this->title = false;
		0 ignored issues – show Documentation Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report It seems like `false` of type `false` is incompatible with the declared type `object<Title>` of property `$title`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
108		$this->name = false;
		0 ignored issues – show Documentation Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report The property `$name` was declared of type `string`, but `false` is of type `false`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
109		$this->group = 'deleted'; // needed for direct use of constructor
110		$this->key = '';
111		$this->size = 0;
112		$this->bits = 0;
113		$this->width = 0;
114		$this->height = 0;
115		$this->metadata = '';
116		$this->mime = "unknown/unknown";
117		$this->media_type = '';
118		$this->description = '';
119		$this->user = 0;
120		$this->user_text = '';
121		$this->timestamp = null;
122		$this->deleted = 0;
123		$this->dataLoaded = false;
124		$this->exists = false;
		0 ignored issues – show Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report The property `exists` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
125		$this->sha1 = '';
126
127		if ( $title instanceof Title ) {
128		$this->title = File::normalizeTitle( $title, 'exception' );
129		$this->name = $title->getDBkey();
130		}
131
132		if ( $id ) {
133		$this->id = $id;
134		}
135
136		if ( $key ) {
137		$this->key = $key;
138		}
139
140		if ( $sha1 ) {
141		$this->sha1 = $sha1;
142		}
143
144		if ( !$id && !$key && !( $title instanceof Title ) && !$sha1 ) {
145		throw new MWException( "No specifications provided to ArchivedFile constructor." );
146		}
147		}
148
149		/**
150		* Loads a file object from the filearchive table
151		* @throws MWException
152		* @return bool\|null True on success or null
153		*/
154		public function load() {
155		if ( $this->dataLoaded ) {
156		return true;
157		}
158		$conds = [];
159
160		if ( $this->id > 0 ) {
161		$conds['fa_id'] = $this->id;
162		}
163		if ( $this->key ) {
164		$conds['fa_storage_group'] = $this->group;
165		$conds['fa_storage_key'] = $this->key;
166		}
167		if ( $this->title ) {
168		$conds['fa_name'] = $this->title->getDBkey();
169		}
170		if ( $this->sha1 ) {
171		$conds['fa_sha1'] = $this->sha1;
172		}
173
174		if ( !count( $conds ) ) {
175		throw new MWException( "No specific information for retrieving archived file" );
176		}
177
178		if ( !$this->title \|\| $this->title->getNamespace() == NS_FILE ) {
179		$this->dataLoaded = true; // set it here, to have also true on miss
180		$dbr = wfGetDB( DB_REPLICA );
181		$row = $dbr->selectRow(
182		'filearchive',
183		self::selectFields(),
184		$conds,
185		__METHOD__,
186		[ 'ORDER BY' => 'fa_timestamp DESC' ]
187		);
188		if ( !$row ) {
189		// this revision does not exist?
190		return null;
191		}
192
193		// initialize fields for filestore image object
194		$this->loadFromRow( $row );
195		} else {
196		throw new MWException( 'This title does not correspond to an image page.' );
197		}
198		$this->exists = true;
199
200		return true;
201		}
202
203		/**
204		* Loads a file object from the filearchive table
205		*
206		* @param stdClass $row
207		* @return ArchivedFile
208		*/
209		public static function newFromRow( $row ) {
210		$file = new ArchivedFile( Title::makeTitle( NS_FILE, $row->fa_name ) );
211		$file->loadFromRow( $row );
212
213		return $file;
214		}
215
216		/**
217		* Fields in the filearchive table
218		* @return array
219		*/
220		static function selectFields() {
221		return [
222		'fa_id',
223		'fa_name',
224		'fa_archive_name',
225		'fa_storage_key',
226		'fa_storage_group',
227		'fa_size',
228		'fa_bits',
229		'fa_width',
230		'fa_height',
231		'fa_metadata',
232		'fa_media_type',
233		'fa_major_mime',
234		'fa_minor_mime',
235		'fa_description',
236		'fa_user',
237		'fa_user_text',
238		'fa_timestamp',
239		'fa_deleted',
240		'fa_deleted_timestamp', /* Used by LocalFileRestoreBatch */
241		'fa_sha1',
242		];
243		}
244
245		/**
246		* Load ArchivedFile object fields from a DB row.
247		*
248		* @param stdClass $row Object database row
249		* @since 1.21
250		*/
251		public function loadFromRow( $row ) {
252		$this->id = intval( $row->fa_id );
253		$this->name = $row->fa_name;
254		$this->archive_name = $row->fa_archive_name;
255		$this->group = $row->fa_storage_group;
256		$this->key = $row->fa_storage_key;
257		$this->size = $row->fa_size;
258		$this->bits = $row->fa_bits;
259		$this->width = $row->fa_width;
260		$this->height = $row->fa_height;
261		$this->metadata = $row->fa_metadata;
262		$this->mime = "$row->fa_major_mime/$row->fa_minor_mime";
263		$this->media_type = $row->fa_media_type;
264		$this->description = $row->fa_description;
265		$this->user = $row->fa_user;
266		$this->user_text = $row->fa_user_text;
267		$this->timestamp = $row->fa_timestamp;
268		$this->deleted = $row->fa_deleted;
269		if ( isset( $row->fa_sha1 ) ) {
270		$this->sha1 = $row->fa_sha1;
271		} else {
272		// old row, populate from key
273		$this->sha1 = LocalRepo::getHashFromKey( $this->key );
274		}
275		if ( !$this->title ) {
276		$this->title = Title::makeTitleSafe( NS_FILE, $row->fa_name );
277		}
278		}
279
280		/**
281		* Return the associated title object
282		*
283		* @return Title
284		*/
285		public function getTitle() {
286		if ( !$this->title ) {
287		$this->load();
288		}
289		return $this->title;
290		}
291
292		/**
293		* Return the file name
294		*
295		* @return string
296		*/
297		public function getName() {
298		if ( $this->name === false ) {
299		$this->load();
300		}
301
302		return $this->name;
303		}
304
305		/**
306		* @return int
307		*/
308		public function getID() {
309		$this->load();
310
311		return $this->id;
312		}
313
314		/**
315		* @return bool
316		*/
317		public function exists() {
318		$this->load();
319
320		return $this->exists;
321		}
322
323		/**
324		* Return the FileStore key
325		* @return string
326		*/
327		public function getKey() {
328		$this->load();
329
330		return $this->key;
331		}
332
333		/**
334		* Return the FileStore key (overriding base File class)
335		* @return string
336		*/
337		public function getStorageKey() {
338		return $this->getKey();
339		}
340
341		/**
342		* Return the FileStore storage group
343		* @return string
344		*/
345		public function getGroup() {
346		return $this->group;
347		}
348
349		/**
350		* Return the width of the image
351		* @return int
352		*/
353		public function getWidth() {
354		$this->load();
355
356		return $this->width;
357		}
358
359		/**
360		* Return the height of the image
361		* @return int
362		*/
363		public function getHeight() {
364		$this->load();
365
366		return $this->height;
367		}
368
369		/**
370		* Get handler-specific metadata
371		* @return string
372		*/
373		public function getMetadata() {
374		$this->load();
375
376		return $this->metadata;
377		}
378
379		/**
380		* Return the size of the image file, in bytes
381		* @return int
382		*/
383		public function getSize() {
384		$this->load();
385
386		return $this->size;
387		}
388
389		/**
390		* Return the bits of the image file, in bytes
391		* @return int
392		*/
393		public function getBits() {
394		$this->load();
395
396		return $this->bits;
397		}
398
399		/**
400		* Returns the MIME type of the file.
401		* @return string
402		*/
403		public function getMimeType() {
404		$this->load();
405
406		return $this->mime;
407		}
408
409		/**
410		* Get a MediaHandler instance for this file
411		* @return MediaHandler
412		*/
413		function getHandler() {
414		if ( !isset( $this->handler ) ) {
415		$this->handler = MediaHandler::getHandler( $this->getMimeType() );
		0 ignored issues – show Documentation Bug introduced 2016-07-26 17:49 UTC by Report Bug Copy Issue Report It seems like `\MediaHandler::getHandler($this->getMimeType())` can also be of type `false`. However, the property `$handler` is declared as type `object<MediaHandler>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
416		}
417
418		return $this->handler;
419		}
420
421		/**
422		* Returns the number of pages of a multipage document, or false for
423		* documents which aren't multipage documents
424		* @return bool\|int
425		*/
426	View Code Duplication	function pageCount() {
427		if ( !isset( $this->pageCount ) ) {
428		// @FIXME: callers expect File objects
429		if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
430		$this->pageCount = $this->handler->pageCount( $this );
		0 ignored issues – show Documentation Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report The property `$pageCount` was declared of type `string`, but `$this->handler->pageCount($this)` is of type `boolean`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
431		} else {
432		$this->pageCount = false;
		0 ignored issues – show Documentation Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report The property `$pageCount` was declared of type `string`, but `false` is of type `false`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
433		}
434		}
435
436		return $this->pageCount;
437		}
438
439		/**
440		* Return the type of the media in the file.
441		* Use the value returned by this function with the MEDIATYPE_xxx constants.
442		* @return string
443		*/
444		public function getMediaType() {
445		$this->load();
446
447		return $this->media_type;
448		}
449
450		/**
451		* Return upload timestamp.
452		*
453		* @return string
454		*/
455		public function getTimestamp() {
456		$this->load();
457
458		return wfTimestamp( TS_MW, $this->timestamp );
459		}
460
461		/**
462		* Get the SHA-1 base 36 hash of the file
463		*
464		* @return string
465		* @since 1.21
466		*/
467		function getSha1() {
468		$this->load();
469
470		return $this->sha1;
471		}
472
473		/**
474		* Returns ID or name of user who uploaded the file
475		*
476		* @note Prior to MediaWiki 1.23, this method always
477		* returned the user id, and was inconsistent with
478		* the rest of the file classes.
479		* @param string $type 'text' or 'id'
480		* @return int\|string
481		* @throws MWException
482		*/
483		public function getUser( $type = 'text' ) {
484		$this->load();
485
486		if ( $type == 'text' ) {
487		return $this->user_text;
488		} elseif ( $type == 'id' ) {
489		return (int)$this->user;
490		}
491
492		throw new MWException( "Unknown type '$type'." );
493		}
494
495		/**
496		* Return the user name of the uploader.
497		*
498		* @deprecated since 1.23 Use getUser( 'text' ) instead.
499		* @return string
500		*/
501		public function getUserText() {
502		wfDeprecated( __METHOD__, '1.23' );
503		$this->load();
504		if ( $this->isDeleted( File::DELETED_USER ) ) {
505		return 0;
506		} else {
507		return $this->user_text;
508		}
509		}
510
511		/**
512		* Return upload description.
513		*
514		* @return string
515		*/
516		public function getDescription() {
517		$this->load();
518		if ( $this->isDeleted( File::DELETED_COMMENT ) ) {
519		return 0;
520		} else {
521		return $this->description;
522		}
523		}
524
525		/**
526		* Return the user ID of the uploader.
527		*
528		* @return int
529		*/
530		public function getRawUser() {
531		$this->load();
532
533		return $this->user;
534		}
535
536		/**
537		* Return the user name of the uploader.
538		*
539		* @return string
540		*/
541		public function getRawUserText() {
542		$this->load();
543
544		return $this->user_text;
545		}
546
547		/**
548		* Return upload description.
549		*
550		* @return string
551		*/
552		public function getRawDescription() {
553		$this->load();
554
555		return $this->description;
556		}
557
558		/**
559		* Returns the deletion bitfield
560		* @return int
561		*/
562		public function getVisibility() {
563		$this->load();
564
565		return $this->deleted;
566		}
567
568		/**
569		* for file or revision rows
570		*
571		* @param int $field One of DELETED_* bitfield constants
572		* @return bool
573		*/
574		public function isDeleted( $field ) {
575		$this->load();
576
577		return ( $this->deleted & $field ) == $field;
578		}
579
580		/**
581		* Determine if the current user is allowed to view a particular
582		* field of this FileStore image file, if it's marked as deleted.
583		* @param int $field
584		* @param null\|User $user User object to check, or null to use $wgUser
585		* @return bool
586		*/
587		public function userCan( $field, User $user = null ) {
588		$this->load();
589
590		$title = $this->getTitle();
591		return Revision::userCanBitfield( $this->deleted, $field, $user, $title ?: null );
592		}
593		}
594

wikimedia / mediawiki

Branch — master (939199)

ArchivedFile::__construct() D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like