Image - Code Metrics - Inspection of "getimagesize() failure" - samayo/bulletproof - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#64)

unknown

created 2017-05-13 18:21 UTC

Image C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	490
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

Metric	Value
wmc	55
lcom	1
cbo	0
dl	0
loc	490
rs	6.8
c	0
b	0
f	0

25 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	getImageMime()	7	2
A	offsetSet()	1	1
A	offsetExists()	1	1
A	offsetUnset()	1	1
A	offsetGet()	13	4
A	setName()	8	2
A	setMime()	5	1
A	setSize()	5	1
B	setLocation()	13	5
A	setDimension()	5	1
A	setErrorMessages()	7	2
A	getName()	8	2
A	getFullPath()	5	1
A	getSize()	4	1
A	getHeight()	9	2
A	getWidth()	9	2
A	getLocation()	8	2
A	getJson()	4	1
A	getMime()	7	2
A	getError()	3	2
A	uploadErrors()	5	1
A	validateImageSize()	7	2
D	upload()	88	14
A	moveUploadedFile()	4	1

How to fix Complexity

<?php
/**
 * BulletProof
 *
 * Bulletproof is a single-class secure Image uploader in php, with a nice API.
 *
 * PHP support 5.3+
 *
 * @package     bulletproof
 * @version     2.0.5
 * @author      https://twitter.com/_samayo
 * @link        https://github.com/samayo/bulletproof
 * @license     MIT
 */
namespace BulletProof;

class Image implements \ArrayAccess
{
    /**
     * @var string The new image name, to be provided or will be generated.
     */
    protected $name;

    /**
     * @var int The image width in pixels
     */
    protected $width;

    /**
     * @var int The image height in pixels
     */
    protected $height;

    /**
     * @var string The image mime type (extension)
     */
    protected $mime;

    /**
     * @var string The full image path (dir + image + mime)
     */
    protected $fullPath;

    /**
     * @var string The folder or image storage location
     */
    protected $location;

    /**
     * @var array A json format of all information about an image
     */
    protected $serialize = array();

    /**
     * @var array The min and max image size allowed for upload (in bytes)
     */
    protected $size = array(100, 500000);

    /**
     * @var array The max height and width image allowed
     */
    protected $dimensions = array(5000, 5000);

    /**
     * @var array The mime types allowed for upload
     */
    protected $mimeTypes = array("jpeg", "png", "gif");

    /**
     * @var array list of known image types
     */
    protected $imageMimes = array(
        1 => "gif", "jpeg", "png", "swf", "psd",
        "bmp", "tiff", "tiff", "jpc", "jp2", "jpx",
        "jb2", "swc", "iff", "wbmp", "xbm", "ico"
    );

    /**
     * @var array storage for the $_FILES global array
     */
    private $_files = array();

    /**
     * @var string storage for any errors
     */
    private $error = "";

	/**
     * @var array error messages strings
     */
    private $error_messages = array(
		'upload' => array(
            UPLOAD_ERR_OK           => "",
            UPLOAD_ERR_INI_SIZE     => "Image is larger than the specified amount set by the server",
            UPLOAD_ERR_FORM_SIZE    => "Image is larger than the specified amount specified by browser",
            UPLOAD_ERR_PARTIAL      => "Image could not be fully uploaded. Please try again later",
            UPLOAD_ERR_NO_FILE      => "Image is not found",
            UPLOAD_ERR_NO_TMP_DIR   => "Can't write to disk, due to server configuration ( No tmp dir found )",
            UPLOAD_ERR_CANT_WRITE   => "Failed to write file to disk. Please check you file permissions",
            UPLOAD_ERR_EXTENSION    => "A PHP extension has halted this file upload process"
        ),
		'location'                  => "Folder %s could not be created",
		'mime_type'                 => "Invalid File! Only (%s) image types are allowed",
		'file_size'                 => "Image size should be atleast more than min: %s and less than max: %s kb",
		'dimensions'                => "Image height/width should be less than ' %s \ %s ' pixels",
		'too_small'                 => "Invalid! Image height/width is too small or maybe corrupted",
		'unknown'                   => "Upload failed, Unknown error occured"
	);

    /**
     * @param array $_files represents the $_FILES array passed as dependency
     */
    public function __construct(array $_files = array())
    {
        $this->_files = $_files;
    }

    /**
     * Gets the real image mime type
     *
     * @param $tmp_name string The upload tmp directory
     *
     * @return bool|string
     */
    protected function getImageMime($tmp_name)
    {
        if (isset($this->imageMimes[exif_imagetype($tmp_name)])) {
            return $this->imageMimes [exif_imagetype($tmp_name)];
        }
        return ;
    }

    /**
     * @param mixed $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value){}

    /**
     * @param mixed $offset
     * @return null
     */
    public function offsetExists($offset){}

    /**
     * @param mixed $offset
     */
    public function offsetUnset($offset){}

    /**
     * Gets array value \ArrayAccess
     *
     * @param mixed $offset
     *
     * @return bool|mixed
     */
    public function offsetGet($offset)
    {
        if ($offset == "error") {
            return $this->error;
        }

        if (isset($this->_files[$offset]) && file_exists($this->_files[$offset]["tmp_name"])) {
            $this->_files = $this->_files[$offset];
            return true;
        }
        
        return false;
    }


    /**
     * Provide image name if not provided
     *
     * @param null $isNameProvided
     * @return $this
     */
    public function setName($isNameProvided = null)
    {
        if ($isNameProvided) {
            $this->name = filter_var($isNameProvided, FILTER_SANITIZE_STRING);
        }
        
        return $this;
    }

    /**
     * Define a mime type for uploading
     *
     * @param array $fileTypes
     *
     * @return $this
     */
    public function setMime(array $fileTypes)
    {
        $this->mimeTypes = $fileTypes;
        return $this;
    }

    /**
     * Define a min and max image size for uploading
     *
     * @param $min int minimum value in bytes
     * @param $max int maximum value in bytes
     *
     * @return $this
     */
    public function setSize($min, $max)
    {
        $this->size = array($min, $max);
        return $this;
    }

    /**
     * Creates a location for upload storage
     *
     * @param $dir string the folder name to create
     * @param int $permission chmod permission
     *
     * @return $this
     */
    public function setLocation($dir = "bulletproof", $permission = 0666)
    {
        if (!file_exists($dir) && !is_dir($dir) && !$this->location) {
            $createFolder = @mkdir("" . $dir, (int) $permission, true);
            if (!$createFolder) {
                $this->error = sprintf($this->error_messages['location'], $dir);
                return;
            }
        }

        $this->location = $dir;
        return $this;
    }

    /**
     * Sets acceptable max image height and width
     *
     * @param $maxWidth int max width value
     * @param $maxHeight int max height value
     *
     * @return $this
     */
    public function setDimension($maxWidth, $maxHeight)
    {
        $this->dimensions = array($maxWidth, $maxHeight);
        return $this;
    }

	/**
	 * Replace error_messages array values with values of given array
	 *
	 * @param $new_error_messages array Array containing new error messages
	 *
	 * @return $this
	 */
	public function setErrorMessages($new_error_messages)
	{
		if($new_array = array_replace_recursive($this->error_messages, $new_error_messages)) {
			$this->error_messages = $new_array;
		};
		return $this;
	}

    /**
     * Returns the image name
     *
     * @return string
     */
    public function getName()
    {
        if (!$this->name) {
           return  uniqid(true) . "_" . str_shuffle(implode(range("e", "q")));
        }

        return $this->name;
    }

    /**
     * Returns the full path of the image ex "location/image.mime"
     *
     * @return string
     */
    public function getFullPath()
    {
        $this->fullPath = $this->location . "/" . $this->name . "." . $this->mime;
        return $this->fullPath;
    }

    /**
     * Returns the image size in bytes
     *
     * @return int
     */
    public function getSize()
    {
        return (int) $this->_files["size"];
    }

    /**
     * Returns the image height in pixels
     *
     * @return int
     */
    public function getHeight()
    {
        if ($this->height != null) {
            return $this->height;
        }

        list(, $height) = getImageSize($this->_files["tmp_name"]); 
        return $height;
    }

    /**
     * Returns the image width
     *
     * @return int
     */
    public function getWidth()
    {
        if ($this->width != null) {
            return $this->width;
        }

        list($width) = getImageSize($this->_files["tmp_name"]); 
        return $width;
    }

    /**
     * Returns the storage / folder name
     *
     * @return string
     */
    public function getLocation()
    {
        if(!$this->location){
            $this->setLocation(); 
        }

        return $this->location; 
    }

    /**
     * Returns a JSON format of the image width, height, name, mime ...
     *
     * @return string
     */
    public function getJson()
    {
        return json_encode($this->serialize);
    }

    /**
     * Returns the image mime type
     *
     * @return string
     */
    public function getMime()
    {
        if(!$this->mime){
            return $this->getImageMime($this->_files["tmp_name"]);
        }
        return $this->mime;
    }

    /**
     * Returns error string or false if no errors occurred
     *
     * @return string|bool
     */
    public function getError(){
        return $this->error != "" ? $this->error : false;
    }

    /**
     * Checks for the common upload errors
     *
     * @param $e int error constant
     */
    protected function uploadErrors($e)
    {
        $errors = $this->error_messages['upload'];
        return $errors[$e];
    }

    /**
     * Checks if the image size, of the uploaded file is available
     * If it returns false, the file is mostly certainly, not an image.
     * @return bool
     */
    protected function validateImageSize(){
        if ($data = @getimagesize($this->_files["tmp_name"])) {
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            return true;
        } else {
            return false;
        }
    }

    /**
     * This methods validates and uploads the image
     * @return bool|Image|null
     * @throws ImageUploaderException
     */
    public function upload()
    {
        /* modify variable names for convenience */
        $image = $this;
        $files = $this->_files;

        /* check if php_exif is enabled */
        if(!function_exists('exif_imagetype')){
            $image->error = "Function 'exif_imagetype' Not found. Please enable \"php_exif\" in your PHP.ini";
            return null;
        }

        /* Check if the image size is ascertainable */
        if ($this->validateImageSize() === false){
            $ext = implode(", ", $image->mimeTypes);
            $image->error = sprintf($this->error_messages['mime_type'], $ext);
            return null;
        }
        
        /* initialize image properties */
        $image->name     = $image->getName();
        $image->width    = $image->getWidth();
        $image->height   = $image->getHeight(); 
        $image->location = $image->getLocation();

        /* get image sizes */
        list($minSize, $maxSize) = $image->size;

        /* check for common upload errors */
        if($image->error = $image->uploadErrors($files["error"])){
            return null;
        }

        /* check image for valid mime types and return mime */
        $image->mime = $image->getImageMime($files["tmp_name"]);
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;
}

        /* validate image mime type */
        if (!in_array($image->mime, $image->mimeTypes)) {
            $ext = implode(", ", $image->mimeTypes);
            $image->error = sprintf($this->error_messages['mime_type'], $ext);
            return null;
        }

        /* check image size based on the settings */
        if ($files["size"] < $minSize || $files["size"] > $maxSize) {
            $min = intval($minSize / 1000) ?: 1; $max = intval($maxSize / 1000);

            $image->error = sprintf($this->error_messages['file_size'], $min, $max);
            return null;
        }

        /* check image dimension */
        list($allowedWidth, $allowedHeight) = $image->dimensions;

        if ($image->height > $allowedHeight || $image->width > $allowedWidth) {
            $image->error = sprintf($this->error_messages['dimensions'], $allowedHeight, $allowedWidth);
            return null;
        }

        if($image->height < 4 || $image->width < 4){
            $image->error = $this->error_messages['too_small'];
            return null;
        }
 
        /* set and get folder name */
        $image->fullPath = $image->location. "/" . $image->name . "." . $image->mime;

        /* gather image info for json storage */ 
        $image->serialize = array(
            "name"     => $image->name,
            "mime"     => $image->mime,
            "height"   => $image->height,
            "width"    => $image->width,
            "size"     => $files["size"],
            "location" => $image->location,
            "fullpath" => $image->fullPath
        );

        if ($image->error === "") {
            $moveUpload = $image->moveUploadedFile($files["tmp_name"], $image->fullPath);
            if (false !== $moveUpload) {
                return $image;
            }
        }

        $image->error =  $this->error_messages['unknown'];
        return false;
    }

    /**
     * Final upload method to be called, isolated for testing purposes
     *
     * @param $tmp_name int the temporary location of the image file
     * @param $destination int upload destination
     *
     * @return bool
     */
    public function moveUploadedFile($tmp_name, $destination)
    {
        return move_uploaded_file($tmp_name, $destination);
    }
}


1			<?php
2			/**
3			* BulletProof
4			*
5			* Bulletproof is a single-class secure Image uploader in php, with a nice API.
6			*
7			* PHP support 5.3+
8			*
9			* @package bulletproof
10			* @version 2.0.5
11			* @author https://twitter.com/_samayo
12			* @link https://github.com/samayo/bulletproof
13			* @license MIT
14			*/
15			namespace BulletProof;
16
17			class Image implements \ArrayAccess
18			{
19			/**
20			* @var string The new image name, to be provided or will be generated.
21			*/
22			protected $name;
23
24			/**
25			* @var int The image width in pixels
26			*/
27			protected $width;
28
29			/**
30			* @var int The image height in pixels
31			*/
32			protected $height;
33
34			/**
35			* @var string The image mime type (extension)
36			*/
37			protected $mime;
38
39			/**
40			* @var string The full image path (dir + image + mime)
41			*/
42			protected $fullPath;
43
44			/**
45			* @var string The folder or image storage location
46			*/
47			protected $location;
48
49			/**
50			* @var array A json format of all information about an image
51			*/
52			protected $serialize = array();
53
54			/**
55			* @var array The min and max image size allowed for upload (in bytes)
56			*/
57			protected $size = array(100, 500000);
58
59			/**
60			* @var array The max height and width image allowed
61			*/
62			protected $dimensions = array(5000, 5000);
63
64			/**
65			* @var array The mime types allowed for upload
66			*/
67			protected $mimeTypes = array("jpeg", "png", "gif");
68
69			/**
70			* @var array list of known image types
71			*/
72			protected $imageMimes = array(
73			1 => "gif", "jpeg", "png", "swf", "psd",
74			"bmp", "tiff", "tiff", "jpc", "jp2", "jpx",
75			"jb2", "swc", "iff", "wbmp", "xbm", "ico"
76			);
77
78			/**
79			* @var array storage for the $_FILES global array
80			*/
81			private $_files = array();
82
83			/**
84			* @var string storage for any errors
85			*/
86			private $error = "";
87
88			/**
89			* @var array error messages strings
90			*/
91			private $error_messages = array(
92			'upload' => array(
93			UPLOAD_ERR_OK => "",
94			UPLOAD_ERR_INI_SIZE => "Image is larger than the specified amount set by the server",
95			UPLOAD_ERR_FORM_SIZE => "Image is larger than the specified amount specified by browser",
96			UPLOAD_ERR_PARTIAL => "Image could not be fully uploaded. Please try again later",
97			UPLOAD_ERR_NO_FILE => "Image is not found",
98			UPLOAD_ERR_NO_TMP_DIR => "Can't write to disk, due to server configuration ( No tmp dir found )",
99			UPLOAD_ERR_CANT_WRITE => "Failed to write file to disk. Please check you file permissions",
100			UPLOAD_ERR_EXTENSION => "A PHP extension has halted this file upload process"
101			),
102			'location' => "Folder %s could not be created",
103			'mime_type' => "Invalid File! Only (%s) image types are allowed",
104			'file_size' => "Image size should be atleast more than min: %s and less than max: %s kb",
105			'dimensions' => "Image height/width should be less than ' %s \ %s ' pixels",
106			'too_small' => "Invalid! Image height/width is too small or maybe corrupted",
107			'unknown' => "Upload failed, Unknown error occured"
108			);
109
110			/**
111			* @param array $_files represents the $_FILES array passed as dependency
112			*/
113			public function __construct(array $_files = array())
114			{
115			$this->_files = $_files;
116			}
117
118			/**
119			* Gets the real image mime type
120			*
121			* @param $tmp_name string The upload tmp directory
122			*
123			* @return bool\|string
124			*/
125			protected function getImageMime($tmp_name)
126			{
127			if (isset($this->imageMimes[exif_imagetype($tmp_name)])) {
128			return $this->imageMimes [exif_imagetype($tmp_name)];
129			}
130			return ;
131			}
132
133			/**
134			* @param mixed $offset
135			* @param mixed $value
136			*/
137			public function offsetSet($offset, $value){}
138
139			/**
140			* @param mixed $offset
141			* @return null
142			*/
143			public function offsetExists($offset){}
144
145			/**
146			* @param mixed $offset
147			*/
148			public function offsetUnset($offset){}
149
150			/**
151			* Gets array value \ArrayAccess
152			*
153			* @param mixed $offset
154			*
155			* @return bool\|mixed
156			*/
157			public function offsetGet($offset)
158			{
159			if ($offset == "error") {
160			return $this->error;
161			}
162
163			if (isset($this->_files[$offset]) && file_exists($this->_files[$offset]["tmp_name"])) {
164			$this->_files = $this->_files[$offset];
165			return true;
166			}
167
168			return false;
169			}
170
171
172			/**
173			* Provide image name if not provided
174			*
175			* @param null $isNameProvided
176			* @return $this
177			*/
178			public function setName($isNameProvided = null)
179			{
180			if ($isNameProvided) {
181			$this->name = filter_var($isNameProvided, FILTER_SANITIZE_STRING);
182			}
183
184			return $this;
185			}
186
187			/**
188			* Define a mime type for uploading
189			*
190			* @param array $fileTypes
191			*
192			* @return $this
193			*/
194			public function setMime(array $fileTypes)
195			{
196			$this->mimeTypes = $fileTypes;
197			return $this;
198			}
199
200			/**
201			* Define a min and max image size for uploading
202			*
203			* @param $min int minimum value in bytes
204			* @param $max int maximum value in bytes
205			*
206			* @return $this
207			*/
208			public function setSize($min, $max)
209			{
210			$this->size = array($min, $max);
211			return $this;
212			}
213
214			/**
215			* Creates a location for upload storage
216			*
217			* @param $dir string the folder name to create
218			* @param int $permission chmod permission
219			*
220			* @return $this
221			*/
222			public function setLocation($dir = "bulletproof", $permission = 0666)
223			{
224			if (!file_exists($dir) && !is_dir($dir) && !$this->location) {
225			$createFolder = @mkdir("" . $dir, (int) $permission, true);
226			if (!$createFolder) {
227			$this->error = sprintf($this->error_messages['location'], $dir);
228			return;
229			}
230			}
231
232			$this->location = $dir;
233			return $this;
234			}
235
236			/**
237			* Sets acceptable max image height and width
238			*
239			* @param $maxWidth int max width value
240			* @param $maxHeight int max height value
241			*
242			* @return $this
243			*/
244			public function setDimension($maxWidth, $maxHeight)
245			{
246			$this->dimensions = array($maxWidth, $maxHeight);
247			return $this;
248			}
249
250			/**
251			* Replace error_messages array values with values of given array
252			*
253			* @param $new_error_messages array Array containing new error messages
254			*
255			* @return $this
256			*/
257			public function setErrorMessages($new_error_messages)
258			{
259			if($new_array = array_replace_recursive($this->error_messages, $new_error_messages)) {
260			$this->error_messages = $new_array;
261			};
262			return $this;
263			}
264
265			/**
266			* Returns the image name
267			*
268			* @return string
269			*/
270			public function getName()
271			{
272			if (!$this->name) {
273			return uniqid(true) . "_" . str_shuffle(implode(range("e", "q")));
274			}
275
276			return $this->name;
277			}
278
279			/**
280			* Returns the full path of the image ex "location/image.mime"
281			*
282			* @return string
283			*/
284			public function getFullPath()
285			{
286			$this->fullPath = $this->location . "/" . $this->name . "." . $this->mime;
287			return $this->fullPath;
288			}
289
290			/**
291			* Returns the image size in bytes
292			*
293			* @return int
294			*/
295			public function getSize()
296			{
297			return (int) $this->_files["size"];
298			}
299
300			/**
301			* Returns the image height in pixels
302			*
303			* @return int
304			*/
305			public function getHeight()
306			{
307			if ($this->height != null) {
308			return $this->height;
309			}
310
311			list(, $height) = getImageSize($this->_files["tmp_name"]);
312			return $height;
313			}
314
315			/**
316			* Returns the image width
317			*
318			* @return int
319			*/
320			public function getWidth()
321			{
322			if ($this->width != null) {
323			return $this->width;
324			}
325
326			list($width) = getImageSize($this->_files["tmp_name"]);
327			return $width;
328			}
329
330			/**
331			* Returns the storage / folder name
332			*
333			* @return string
334			*/
335			public function getLocation()
336			{
337			if(!$this->location){
338			$this->setLocation();
339			}
340
341			return $this->location;
342			}
343
344			/**
345			* Returns a JSON format of the image width, height, name, mime ...
346			*
347			* @return string
348			*/
349			public function getJson()
350			{
351			return json_encode($this->serialize);
352			}
353
354			/**
355			* Returns the image mime type
356			*
357			* @return string
358			*/
359			public function getMime()
360			{
361			if(!$this->mime){
362			return $this->getImageMime($this->_files["tmp_name"]);
363			}
364			return $this->mime;
365			}
366
367			/**
368			* Returns error string or false if no errors occurred
369			*
370			* @return string\|bool
371			*/
372			public function getError(){
373			return $this->error != "" ? $this->error : false;
374			}
375
376			/**
377			* Checks for the common upload errors
378			*
379			* @param $e int error constant
380			*/
381			protected function uploadErrors($e)
382			{
383			$errors = $this->error_messages['upload'];
384			return $errors[$e];
385			}
386
387			/**
388			* Checks if the image size, of the uploaded file is available
389			* If it returns false, the file is mostly certainly, not an image.
390			* @return bool
391			*/
392			protected function validateImageSize(){
393			if ($data = @getimagesize($this->_files["tmp_name"])) {
			0 ignored issues – show Unused Code introduced 2017-05-13 18:24 UTC by Report Bug Copy Issue Report `$data` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
394			return true;
395			} else {
396			return false;
397			}
398			}
399
400			/**
401			* This methods validates and uploads the image
402			* @return bool\|Image\|null
403			* @throws ImageUploaderException
404			*/
405			public function upload()
406			{
407			/* modify variable names for convenience */
408			$image = $this;
409			$files = $this->_files;
410
411			/* check if php_exif is enabled */
412			if(!function_exists('exif_imagetype')){
413			$image->error = "Function 'exif_imagetype' Not found. Please enable \"php_exif\" in your PHP.ini";
414			return null;
415			}
416
417			/* Check if the image size is ascertainable */
418			if ($this->validateImageSize() === false){
419			$ext = implode(", ", $image->mimeTypes);
420			$image->error = sprintf($this->error_messages['mime_type'], $ext);
421			return null;
422			}
423
424			/* initialize image properties */
425			$image->name = $image->getName();
426			$image->width = $image->getWidth();
427			$image->height = $image->getHeight();
428			$image->location = $image->getLocation();
429
430			/* get image sizes */
431			list($minSize, $maxSize) = $image->size;
432
433			/* check for common upload errors */
434			if($image->error = $image->uploadErrors($files["error"])){
435			return null;
436			}
437
438			/* check image for valid mime types and return mime */
439			$image->mime = $image->getImageMime($files["tmp_name"]);
			0 ignored issues – show Documentation Bug introduced 2015-11-21 00:26 UTC by Report Bug Copy Issue Report It seems like `$image->getImageMime($files['tmp_name'])` can also be of type `boolean`. However, the property `$mime` is declared as type `string`. 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...
440
441			/* validate image mime type */
442			if (!in_array($image->mime, $image->mimeTypes)) {
443			$ext = implode(", ", $image->mimeTypes);
444			$image->error = sprintf($this->error_messages['mime_type'], $ext);
445			return null;
446			}
447
448			/* check image size based on the settings */
449			if ($files["size"] < $minSize \|\| $files["size"] > $maxSize) {
450			$min = intval($minSize / 1000) ?: 1; $max = intval($maxSize / 1000);
451
452			$image->error = sprintf($this->error_messages['file_size'], $min, $max);
453			return null;
454			}
455
456			/* check image dimension */
457			list($allowedWidth, $allowedHeight) = $image->dimensions;
458
459			if ($image->height > $allowedHeight \|\| $image->width > $allowedWidth) {
460			$image->error = sprintf($this->error_messages['dimensions'], $allowedHeight, $allowedWidth);
461			return null;
462			}
463
464			if($image->height < 4 \|\| $image->width < 4){
465			$image->error = $this->error_messages['too_small'];
466			return null;
467			}
468
469			/* set and get folder name */
470			$image->fullPath = $image->location. "/" . $image->name . "." . $image->mime;
471
472			/* gather image info for json storage */
473			$image->serialize = array(
474			"name" => $image->name,
475			"mime" => $image->mime,
476			"height" => $image->height,
477			"width" => $image->width,
478			"size" => $files["size"],
479			"location" => $image->location,
480			"fullpath" => $image->fullPath
481			);
482
483			if ($image->error === "") {
484			$moveUpload = $image->moveUploadedFile($files["tmp_name"], $image->fullPath);
485			if (false !== $moveUpload) {
486			return $image;
487			}
488			}
489
490			$image->error = $this->error_messages['unknown'];
491			return false;
492			}
493
494			/**
495			* Final upload method to be called, isolated for testing purposes
496			*
497			* @param $tmp_name int the temporary location of the image file
498			* @param $destination int upload destination
499			*
500			* @return bool
501			*/
502			public function moveUploadedFile($tmp_name, $destination)
503			{
504			return move_uploaded_file($tmp_name, $destination);
505			}
506			}
507

samayo / bulletproof

Pull Request — master (#64)

Image C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

25 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like