Image - Code Metrics - Inspection of "bump up version" - samayo/bulletproof - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (69506e)

by samayo

created 2017-10-22 12:39 UTC

Image B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	470
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

Metric	Value
wmc	53
lcom	1
cbo	0
dl	0
loc	470
rs	7.4757
c	0
b	0
f	0

23 Methods

Rating	Name	Size	Complexity
A	__construct()	10	2
A	offsetSet()	3	1
A	offsetExists()	3	1
A	offsetUnset()	3	1
A	offsetGet()	21	4
A	commonUploadErrors()	4	1
A	setDimension()	5	1
A	getFullPath()	5	1
A	getSize()	4	1
A	setSize()	5	1
A	getJson()	4	1
A	getMime()	7	2
A	setMime()	5	1
A	getImageMime()	10	2
A	getError()	4	2
C	upload()	77	14
A	getName()	8	2
A	setName()	8	2
A	getWidth()	9	2
A	getHeight()	9	2
A	getLocation()	8	2
B	setLocation()	20	6
A	moveUploadedFile()	4	1

How to fix Complexity

<?php
/**
 * BULLETPROOF
 *
 * Bulletproof is a single-class PHP library to upload images securely.
 *
 * PHP support 5.3+
 *
 * @package     bulletproof
 * @version     3.2.0
 * @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', 'jpg');

    /**
     * @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 error messages strings
     */
    protected $common_upload_errors = 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'
    );
    /**
     * @var array storage for the $_FILES global array
     */
    private $_files = array();
    /**
     * @var string storage for any errors
     */
    private $error = '';

    /**
     * @param array $_files represents the $_FILES array passed as dependency
     */
    public function __construct(array $_files = array())
    {
        /* check if php_exif is enabled */
        if (!function_exists('exif_imagetype')) {
            $this->error = 'Function \'exif_imagetype\' Not found. Please enable \'php_exif\' in your PHP.ini';
            return null;
        }

        $this->_files = $_files;
    }

    /**
     * @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

     */
    public function offsetGet($offset)
    {   
        /* return error if requested */
        if ($offset == 'error') {
            return $this->error;
        }
        
        /* return false if $image['key'] isn't found */
        if (!isset($this->_files[$offset])) {
            return false;
        }

        $this->_files = $this->_files[$offset];

        /* check for common upload errors */
        if (isset($this->_files['error'])) {
            $this->error = $this->commonUploadErrors($this->_files['error']);
        }

        return true;
    }

    /**
     * Checks for the common upload errors
     *
     * @param $errors int error constant
     *
     * @return string
     */
    protected function commonUploadErrors($errors)
    {
        return $this->common_upload_errors[$errors];
    }

    /**
     * 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;
    }

    /**
     * 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'];
    }

    /**
     * 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;
    }

    /**
     * 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;
    }

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

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

        if (!$mime) {
            return null;
        }

        return $mime;
    }

    /**
     * Returns error string or false if no errors occurred
     *
     * @return string|bool

     */
    public function getError()
    {
        return $this->error != '' ? $this->error : false;
    }

    /**
     * This methods validates and uploads the image
     * @return false|Image

     */
    public function upload()
    {
        /* modify variable names for convenience */
        $image = $this;
        $files = $this->_files;

        if ($this->error) {
            return false;
        }

        if (!isset($files['tmp_name'])) {
            return false;
        }

        /* check image for valid mime types and return mime */
        $image->mime = $image->getImageMime($files['tmp_name']);
        /* validate image mime type */
        if (!in_array($image->mime, $image->mimeTypes)) {
            $ext = implode(', ', $image->mimeTypes);
            $image->error = sprintf('Invalid File! Only (%s) image types are allowed', $ext);
            return false;
        }

        /* 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 image size based on the settings */
        if ($files['size'] < $minSize || $files['size'] > $maxSize) {
            $min = intval($minSize / 1000) ?: 1;
            $max = intval($maxSize / 1000) ?: 1;
            $image->error = "Image size should be at least " . $min . " KB, and no more than " . $max . " KB";
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            return null;
        }

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

        if ($image->height > $allowedHeight || $image->width > $allowedWidth) {
            $image->error = 'Image height/width should be less than ' . $allowedHeight . '/' . $allowedWidth . ' pixels';
            return false;
        }

        if ($image->height < 2 || $image->width < 2) {
            $image->error = 'Image height/width too small or corrupted.';
            return false;
        }

        /* 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 = 'Upload failed, Unknown error occured';
        return false;
    }

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

        return $this->name;
    }

    /**
     * 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;
    }

    /**
     * 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 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 storage / folder name
     *
     * @return string
     */
    public function getLocation()
    {
        if (!$this->location) {
            $this->setLocation();
        }

        return $this->location;
    }

    /**
     * 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 = 'Error! Folder ' . $dir . ' could not be created';
                return false;
            }
        }

        /* check if we can create a file in the directory */
        if (!is_writable($dir)) {
            $this->error = "The images directory \"" . $dir . "\" is not writable!";
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            return false;
        }

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

    /**
     * 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 PHP library to upload images securely.
6			*
7			* PHP support 5.3+
8			*
9			* @package bulletproof
10			* @version 3.2.0
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', 'jpg');
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			* @var array error messages strings
79			*/
80			protected $common_upload_errors = array(
81			UPLOAD_ERR_OK => '',
82			UPLOAD_ERR_INI_SIZE => 'Image is larger than the specified amount set by the server',
83			UPLOAD_ERR_FORM_SIZE => 'Image is larger than the specified amount specified by browser',
84			UPLOAD_ERR_PARTIAL => 'Image could not be fully uploaded. Please try again later',
85			UPLOAD_ERR_NO_FILE => 'Image is not found',
86			UPLOAD_ERR_NO_TMP_DIR => 'Can\'t write to disk, due to server configuration ( No tmp dir found )',
87			UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk. Please check you file permissions',
88			UPLOAD_ERR_EXTENSION => 'A PHP extension has halted this file upload process'
89			);
90			/**
91			* @var array storage for the $_FILES global array
92			*/
93			private $_files = array();
94			/**
95			* @var string storage for any errors
96			*/
97			private $error = '';
98
99			/**
100			* @param array $_files represents the $_FILES array passed as dependency
101			*/
102			public function __construct(array $_files = array())
103			{
104			/* check if php_exif is enabled */
105			if (!function_exists('exif_imagetype')) {
106			$this->error = 'Function \'exif_imagetype\' Not found. Please enable \'php_exif\' in your PHP.ini';
107			return null;
108			}
109
110			$this->_files = $_files;
111			}
112
113			/**
114			* @param mixed $offset
115			* @param mixed $value
116			*/
117			public function offsetSet($offset, $value)
118			{
119			}
120
121			/**
122			* @param mixed $offset
123			* @return null
124			*/
125			public function offsetExists($offset)
126			{
127			}
128
129			/**
130			* @param mixed $offset
131			*/
132			public function offsetUnset($offset)
133			{
134			}
135
136			/**
137			* Gets array value \ArrayAccess
138			*
139			* @param mixed $offset
140			*
141			* @return bool
			0 ignored issues – show Documentation introduced 2017-07-29 01:56 UTC by Report Bug Copy Issue Report Should the return type not be `string\|boolean`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
142			*/
143			public function offsetGet($offset)
144			{
145			/* return error if requested */
146			if ($offset == 'error') {
147			return $this->error;
148			}
149
150			/* return false if $image['key'] isn't found */
151			if (!isset($this->_files[$offset])) {
152			return false;
153			}
154
155			$this->_files = $this->_files[$offset];
156
157			/* check for common upload errors */
158			if (isset($this->_files['error'])) {
159			$this->error = $this->commonUploadErrors($this->_files['error']);
160			}
161
162			return true;
163			}
164
165			/**
166			* Checks for the common upload errors
167			*
168			* @param $errors int error constant
169			*
170			* @return string
171			*/
172			protected function commonUploadErrors($errors)
173			{
174			return $this->common_upload_errors[$errors];
175			}
176
177			/**
178			* Sets acceptable max image height and width
179			*
180			* @param $maxWidth int max width value
181			* @param $maxHeight int max height value
182			*
183			* @return $this
184			*/
185			public function setDimension($maxWidth, $maxHeight)
186			{
187			$this->dimensions = array($maxWidth, $maxHeight);
188			return $this;
189			}
190
191			/**
192			* Returns the full path of the image ex 'location/image.mime'
193			*
194			* @return string
195			*/
196			public function getFullPath()
197			{
198			$this->fullPath = $this->location . '/' . $this->name . '.' . $this->mime;
199			return $this->fullPath;
200			}
201
202			/**
203			* Returns the image size in bytes
204			*
205			* @return int
206			*/
207			public function getSize()
208			{
209			return (int)$this->_files['size'];
210			}
211
212			/**
213			* Define a min and max image size for uploading
214			*
215			* @param $min int minimum value in bytes
216			* @param $max int maximum value in bytes
217			*
218			* @return $this
219			*/
220			public function setSize($min, $max)
221			{
222			$this->size = array($min, $max);
223			return $this;
224			}
225
226			/**
227			* Returns a JSON format of the image width, height, name, mime ...
228			*
229			* @return string
230			*/
231			public function getJson()
232			{
233			return json_encode($this->serialize);
234			}
235
236			/**
237			* Returns the image mime type
238			*
239			* @return string
			0 ignored issues – show Documentation introduced 2017-07-29 00:32 UTC by Report Bug Copy Issue Report Should the return type not be `null\|string`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
240			*/
241			public function getMime()
242			{
243			if (!$this->mime) {
244			return $this->getImageMime($this->_files['tmp_name']);
245			}
246			return $this->mime;
247			}
248
249			/**
250			* Define a mime type for uploading
251			*
252			* @param array $fileTypes
253			*
254			* @return $this
255			*/
256			public function setMime(array $fileTypes)
257			{
258			$this->mimeTypes = $fileTypes;
259			return $this;
260			}
261
262			/**
263			* Gets the real image mime type
264			*
265			* @param $tmp_name string The upload tmp directory
266			*
267			* @return null\|string
268			*/
269			protected function getImageMime($tmp_name)
270			{
271			$mime = @$this->imageMimes[exif_imagetype($tmp_name)];
272
273			if (!$mime) {
274			return null;
275			}
276
277			return $mime;
278			}
279
280			/**
281			* Returns error string or false if no errors occurred
282			*
283			* @return string\|bool
			0 ignored issues – show Documentation introduced 2017-07-29 00:04 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `string\|false`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
284			*/
285			public function getError()
286			{
287			return $this->error != '' ? $this->error : false;
288			}
289
290			/**
291			* This methods validates and uploads the image
292			* @return false\|Image
			0 ignored issues – show Documentation introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report Should the return type not be `false\|null\|Image`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
293			*/
294			public function upload()
295			{
296			/* modify variable names for convenience */
297			$image = $this;
298			$files = $this->_files;
299
300			if ($this->error) {
301			return false;
302			}
303
304			if (!isset($files['tmp_name'])) {
305			return false;
306			}
307
308			/* check image for valid mime types and return mime */
309			$image->mime = $image->getImageMime($files['tmp_name']);
310			/* validate image mime type */
311			if (!in_array($image->mime, $image->mimeTypes)) {
312			$ext = implode(', ', $image->mimeTypes);
313			$image->error = sprintf('Invalid File! Only (%s) image types are allowed', $ext);
314			return false;
315			}
316
317			/* initialize image properties */
318			$image->name = $image->getName();
319			$image->width = $image->getWidth();
320			$image->height = $image->getHeight();
321			$image->location = $image->getLocation();
322
323			/* get image sizes */
324			list($minSize, $maxSize) = $image->size;
325
326			/* check image size based on the settings */
327			if ($files['size'] < $minSize \|\| $files['size'] > $maxSize) {
328			$min = intval($minSize / 1000) ?: 1;
329			$max = intval($maxSize / 1000) ?: 1;
330			$image->error = "Image size should be at least " . $min . " KB, and no more than " . $max . " KB";
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report The string literal `Image size should be at least` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history... Coding Style Comprehensibility introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report The string literal `KB, and no more than` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history... Coding Style Comprehensibility introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report The string literal `KB` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
331			return null;
332			}
333
334			/* check image dimension */
335			list($allowedWidth, $allowedHeight) = $image->dimensions;
336
337			if ($image->height > $allowedHeight \|\| $image->width > $allowedWidth) {
338			$image->error = 'Image height/width should be less than ' . $allowedHeight . '/' . $allowedWidth . ' pixels';
339			return false;
340			}
341
342			if ($image->height < 2 \|\| $image->width < 2) {
343			$image->error = 'Image height/width too small or corrupted.';
344			return false;
345			}
346
347			/* set and get folder name */
348			$image->fullPath = $image->location . '/' . $image->name . '.' . $image->mime;
349
350			/* gather image info for json storage */
351			$image->serialize = array(
352			'name' => $image->name,
353			'mime' => $image->mime,
354			'height' => $image->height,
355			'width' => $image->width,
356			'size' => $files['size'],
357			'location' => $image->location,
358			'fullpath' => $image->fullPath
359			);
360
361			if ($image->error === '') {
362			$moveUpload = $image->moveUploadedFile($files['tmp_name'], $image->fullPath);
363			if (false !== $moveUpload) {
364			return $image;
365			}
366			}
367
368			$image->error = 'Upload failed, Unknown error occured';
369			return false;
370			}
371
372			/**
373			* Returns the image name
374			*
375			* @return string
376			*/
377			public function getName()
378			{
379			if (!$this->name) {
380			return uniqid('', true) . '_' . str_shuffle(implode(range('e', 'q')));
381			}
382
383			return $this->name;
384			}
385
386			/**
387			* Provide image name if not provided
388			*
389			* @param null $isNameProvided
390			* @return $this
391			*/
392			public function setName($isNameProvided = null)
393			{
394			if ($isNameProvided) {
395			$this->name = filter_var($isNameProvided, FILTER_SANITIZE_STRING);
396			}
397
398			return $this;
399			}
400
401			/**
402			* Returns the image width
403			*
404			* @return int
405			*/
406			public function getWidth()
407			{
408			if ($this->width != null) {
409			return $this->width;
410			}
411
412			list($width) = getImageSize($this->_files['tmp_name']);
413			return $width;
414			}
415
416			/**
417			* Returns the image height in pixels
418			*
419			* @return int
420			*/
421			public function getHeight()
422			{
423			if ($this->height != null) {
424			return $this->height;
425			}
426
427			list(, $height) = getImageSize($this->_files['tmp_name']);
428			return $height;
429			}
430
431			/**
432			* Returns the storage / folder name
433			*
434			* @return string
435			*/
436			public function getLocation()
437			{
438			if (!$this->location) {
439			$this->setLocation();
440			}
441
442			return $this->location;
443			}
444
445			/**
446			* Creates a location for upload storage
447			*
448			* @param $dir string the folder name to create
449			* @param int $permission chmod permission
450			*
451			* @return $this
452			*/
453			public function setLocation($dir = 'bulletproof', $permission = 0666)
454			{
455
456			if (!file_exists($dir) && !is_dir($dir) && !$this->location) {
457			$createFolder = @mkdir('' . $dir, (int)$permission, true);
458			if (!$createFolder) {
459			$this->error = 'Error! Folder ' . $dir . ' could not be created';
460			return false;
461			}
462			}
463
464			/* check if we can create a file in the directory */
465			if (!is_writable($dir)) {
466			$this->error = "The images directory \"" . $dir . "\" is not writable!";
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report The string literal `The images directory \"` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history... Coding Style Comprehensibility introduced 2017-09-14 21:58 UTC by Report Bug Copy Issue Report The string literal `\" is not writable!` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
467			return false;
468			}
469
470			$this->location = $dir;
471			return $this;
472			}
473
474			/**
475			* Final upload method to be called, isolated for testing purposes
476			*
477			* @param $tmp_name int the temporary location of the image file
478			* @param $destination int upload destination
479			*
480			* @return bool
481			*/
482			public function moveUploadedFile($tmp_name, $destination)
483			{
484			return move_uploaded_file($tmp_name, $destination);
485			}
486			}
			0 ignored issues – show Coding Style introduced 2017-07-29 00:04 UTC by Report Bug Copy Issue Report As per coding style, files should not end with a newline character. This check marks files that end in a newline character, i.e. an empy line. Loading history...
487

samayo / bulletproof

Branch — master (69506e)

Image B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

23 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like