Image_Core - Code Metrics - vijinho/kohana2-legacy - Measure and Improve Code Quality continuously with Scrutinizer

Image_Core C
last analyzed 2016-08-25 15:53 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	418
Duplicated Lines	5.74 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	3
Bugs	2	Features	0

Metric	Value
c	3
b	2
f	0
dl	24
loc	418
rs	5.7894
wmc	65
lcom	1
cbo	2

12 Methods

Rating	Name	Duplication	Size	Complexity
A	factory()	0	4	1
C	__construct()	6	64	9
A	__get()	0	8	2
C	resize()	0	29	7
C	crop()	0	31	7
B	rotate()	0	22	5
A	flip()	0	10	3
A	quality()	0	6	1
A	sharpen()	0	6	1
B	save()	0	30	6
A	render()	0	21	2
C	valid_size()	18	52	21

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Image_Core often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Image_Core, and based on these observations, apply Extract Interface, too.

<?php defined('SYSPATH') or die('No direct access allowed.');
/**
 * Manipulate images using standard methods such as resize, crop, rotate, etc.
 * This class must be re-initialized for every image you wish to manipulate.
 *
 * $Id: Image.php 4072 2009-03-13 17:20:38Z jheathco $
 *
 * @package    Image
 * @author     Kohana Team
 * @copyright  (c) 2007-2008 Kohana Team
 * @license    http://kohanaphp.com/license.html
 */
class Image_Core
{

    // Master Dimension
    const NONE = 1;
    const AUTO = 2;
    const HEIGHT = 3;
    const WIDTH = 4;
    // Flip Directions
    const HORIZONTAL = 5;
    const VERTICAL = 6;

    // Allowed image types
    public static $allowed_types = array(
        IMAGETYPE_GIF => 'gif',
        IMAGETYPE_JPEG => 'jpg',
        IMAGETYPE_PNG => 'png',
        IMAGETYPE_TIFF_II => 'tiff',
        IMAGETYPE_TIFF_MM => 'tiff',
    );

    // Driver instance
    protected $driver;

    // Driver actions
    protected $actions = array();

    // Reference to the current image filename
    protected $image = '';

    /**
     * Creates a new Image instance and returns it.
     *
     * @param   string   filename of image
     * @param   array    non-default configurations
     * @return  object

     */
    public static function factory($image, $config = null)
    {
        return new Image($image, $config);
    }

    /**
     * Creates a new image editor instance.
     *
     * @throws  Kohana_Exception
     * @param   string   filename of image
     * @param   array    non-default configurations
     * @return  void

     */
    public function __construct($image, $config = null)
    {
        static $check;

        // Make the check exactly once
        ($check === null) and $check = function_exists('getimagesize');

        if ($check === false) {
            throw new Kohana_Exception('image.getimagesize_missing');
        }

        // Check to make sure the image exists
        if (! is_file($image)) {
            throw new Kohana_Exception('image.file_not_found', $image);
        }

        // Disable error reporting, to prevent PHP warnings
        $ER = error_reporting(0);


        // Fetch the image size and mime type
        $image_info = getimagesize($image);

        // Turn on error reporting again
        error_reporting($ER);

        // Make sure that the image is readable and valid
        if (! is_array($image_info) or count($image_info) < 3) {
            throw new Kohana_Exception('image.file_unreadable', $image);
        }

        // Check to make sure the image type is allowed
        if (! isset(Image::$allowed_types[$image_info[2]])) {
            throw new Kohana_Exception('image.type_not_allowed', $image);
        }

        // Image has been validated, load it
        $this->image = array(

            'file' => str_replace('\\', '/', realpath($image)),
            'width' => $image_info[0],
            'height' => $image_info[1],
            'type' => $image_info[2],
            'ext' => Image::$allowed_types[$image_info[2]],
            'mime' => $image_info['mime']
        );

        // Load configuration
        $this->config = (array) $config + Kohana::config('image');
class MyClass { }

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

        // Set driver class name
        $driver = 'Image_'.ucfirst($this->config['driver']).'_Driver';

        // Load the driver
        if (! Kohana::auto_load($driver)) {

            throw new Kohana_Exception('core.driver_not_found', $this->config['driver'], get_class($this));
        }

        // Initialize the driver
        $this->driver = new $driver($this->config['params']);

        // Validate the driver
        if (! ($this->driver instanceof Image_Driver)) {

            throw new Kohana_Exception('core.driver_implements', $this->config['driver'], get_class($this), 'Image_Driver');
        }
    }

    /**
     * Handles retrieval of pre-save image properties
     *
     * @param   string  property name
     * @return  string
     */
    public function __get($property)
    {
        if (isset($this->image[$property])) {
            return $this->image[$property];
        } else {
            throw new Kohana_Exception('core.invalid_property', $property, get_class($this));
        }
    }

    /**
     * Resize an image to a specific width and height. By default, Kohana will
     * maintain the aspect ratio using the width as the master dimension. If you
     * wish to use height as master dim, set $image->master_dim = Image::HEIGHT
     * This method is chainable.
     *
     * @throws  Kohana_Exception
     * @param   integer  width
     * @param   integer  height
     * @param   integer  one of: Image::NONE, Image::AUTO, Image::WIDTH, Image::HEIGHT
     * @return  Image_Core
     */
    public function resize($width, $height, $master = null)
    {
        if (! $this->valid_size('width', $width)) {
            throw new Kohana_Exception('image.invalid_width', $width);
        }

        if (! $this->valid_size('height', $height)) {
            throw new Kohana_Exception('image.invalid_height', $height);
        }

        if (empty($width) and empty($height)) {
            throw new Kohana_Exception('image.invalid_dimensions', __FUNCTION__);
        }

        if ($master === null) {
            // Maintain the aspect ratio by default
            $master = Image::AUTO;
        } elseif (! $this->valid_size('master', $master)) {
            throw new Kohana_Exception('image.invalid_master');
        }

        $this->actions['resize'] = array(
            'width'  => $width,
            'height' => $height,
            'master' => $master,
        );

        return $this;
    }

    /**
     * Crop an image to a specific width and height. You may also set the top
     * and left offset.
     * This method is chainable.
     *
     * @throws  Kohana_Exception
     * @param   integer  width
     * @param   integer  height
     * @param   integer  top offset, pixel value or one of: top, center, bottom
     * @param   integer  left offset, pixel value or one of: left, center, right
     * @return  Image_Core
     */
    public function crop($width, $height, $top = 'center', $left = 'center')
    {
        if (! $this->valid_size('width', $width)) {
            throw new Kohana_Exception('image.invalid_width', $width);
        }

        if (! $this->valid_size('height', $height)) {
            throw new Kohana_Exception('image.invalid_height', $height);
        }

        if (! $this->valid_size('top', $top)) {
            throw new Kohana_Exception('image.invalid_top', $top);
        }

        if (! $this->valid_size('left', $left)) {
            throw new Kohana_Exception('image.invalid_left', $left);
        }

        if (empty($width) and empty($height)) {
            throw new Kohana_Exception('image.invalid_dimensions', __FUNCTION__);
        }

        $this->actions['crop'] = array(
            'width'  => $width,
            'height' => $height,
            'top'    => $top,
            'left'   => $left,
        );

        return $this;
    }

    /**
     * Allows rotation of an image by 180 degrees clockwise or counter clockwise.
     *
     * @param   integer  degrees
     * @return  Image_Core
     */
    public function rotate($degrees)
    {
        $degrees = (int) $degrees;

        if ($degrees > 180) {
            do {
                // Keep subtracting full circles until the degrees have normalized
                $degrees -= 360;
            } while ($degrees > 180);
        }

        if ($degrees < -180) {
            do {
                // Keep adding full circles until the degrees have normalized
                $degrees += 360;
            } while ($degrees < -180);
        }

        $this->actions['rotate'] = $degrees;

        return $this;
    }

    /**
     * Flip an image horizontally or vertically.
     *
     * @throws  Kohana_Exception
     * @param   integer  direction
     * @return  Image_Core
     */
    public function flip($direction)
    {
        if ($direction !== Image::HORIZONTAL and $direction !== Image::VERTICAL) {
            throw new Kohana_Exception('image.invalid_flip');
        }

        $this->actions['flip'] = $direction;

        return $this;
    }

    /**
     * Change the quality of an image.
     *
     * @param   integer  quality as a percentage
     * @return  Image_Core
     */
    public function quality($amount)
    {
        $this->actions['quality'] = max(1, min($amount, 100));

        return $this;
    }

    /**
     * Sharpen an image.
     *
     * @param   integer  amount to sharpen, usually ~20 is ideal
     * @return  Image_Core
     */
    public function sharpen($amount)
    {
        $this->actions['sharpen'] = max(1, min($amount, 100));

        return $this;
    }

    /**
     * Save the image to a new image or overwrite this image.
     *
     * @throws  Kohana_Exception
     * @param   string   new image filename
     * @param   integer  permissions for new image
     * @param   boolean  keep or discard image process actions
     * @return  object
     */
    public function save($new_image = false, $chmod = 0644, $keep_actions = false)
    {
        // If no new image is defined, use the current image
        empty($new_image) and $new_image = $this->image['file'];

        // Separate the directory and filename
        $dir  = pathinfo($new_image, PATHINFO_DIRNAME);
        $file = pathinfo($new_image, PATHINFO_BASENAME);

        // Normalize the path
        $dir = str_replace('\\', '/', realpath($dir)).'/';

        if (! is_writable($dir)) {
            throw new Kohana_Exception('image.directory_unwritable', $dir);
        }

        if ($status = $this->driver->process($this->image, $this->actions, $dir, $file)) {
            if ($chmod !== false) {
                // Set permissions
                chmod($new_image, $chmod);
            }
        }

        // Reset actions. Subsequent save() or render() will not apply previous actions.
        if ($keep_actions === false) {
            $this->actions = array();
        }

        return $status;
    }

    /**
     * Output the image to the browser.
     *
     * @param   boolean  keep or discard image process actions
     * @return	object
     */
    public function render($keep_actions = false)
    {
        $new_image = $this->image['file'];

        // Separate the directory and filename
        $dir  = pathinfo($new_image, PATHINFO_DIRNAME);
        $file = pathinfo($new_image, PATHINFO_BASENAME);

        // Normalize the path
        $dir = str_replace('\\', '/', realpath($dir)).'/';

        // Process the image with the driver
        $status = $this->driver->process($this->image, $this->actions, $dir, $file, $render = true);

        // Reset actions. Subsequent save() or render() will not apply previous actions.
        if ($keep_actions === false) {
            $this->actions = array();
        }

        return $status;
    }

    /**
     * Sanitize a given value type.
     *
     * @param   string   type of property
     * @param   mixed    property value
     * @param string $type
     * @return  boolean
     */
    protected function valid_size($type, & $value)
    {
        if (is_null($value)) {
            return true;
        }

        if (! is_scalar($value)) {
            return false;
        }

        switch ($type) {
            case 'width':
            case 'height':
                if (is_string($value) and ! ctype_digit($value)) {
                    // Only numbers and percent signs
                    if (! preg_match('/^[0-9]++%$/D', $value)) {
                        return false;
                    }
                } else {
                    $value = (int) $value;
                }
            break;
            case 'top':

                if (is_string($value) and ! ctype_digit($value)) {
                    if (! in_array($value, array('top', 'bottom', 'center'))) {
                        return false;
                    }
                } else {
                    $value = (int) $value;
                }
            break;
            case 'left':

                if (is_string($value) and ! ctype_digit($value)) {
                    if (! in_array($value, array('left', 'right', 'center'))) {
                        return false;
                    }
                } else {
                    $value = (int) $value;
                }
            break;
            case 'master':
                if ($value !== Image::NONE and
                    $value !== Image::AUTO and
                    $value !== Image::WIDTH and
                    $value !== Image::HEIGHT) {
                    return false;
                }
            break;
        }

        return true;
    }
} // End Image


1		<?php defined('SYSPATH') or die('No direct access allowed.');
2		/**
3		* Manipulate images using standard methods such as resize, crop, rotate, etc.
4		* This class must be re-initialized for every image you wish to manipulate.
5		*
6		* $Id: Image.php 4072 2009-03-13 17:20:38Z jheathco $
7		*
8		* @package Image
9		* @author Kohana Team
10		* @copyright (c) 2007-2008 Kohana Team
11		* @license http://kohanaphp.com/license.html
12		*/
13		class Image_Core
14		{
15
16		// Master Dimension
17		const NONE = 1;
18		const AUTO = 2;
19		const HEIGHT = 3;
20		const WIDTH = 4;
21		// Flip Directions
22		const HORIZONTAL = 5;
23		const VERTICAL = 6;
24
25		// Allowed image types
26		public static $allowed_types = array(
27		IMAGETYPE_GIF => 'gif',
28		IMAGETYPE_JPEG => 'jpg',
29		IMAGETYPE_PNG => 'png',
30		IMAGETYPE_TIFF_II => 'tiff',
31		IMAGETYPE_TIFF_MM => 'tiff',
32		);
33
34		// Driver instance
35		protected $driver;
36
37		// Driver actions
38		protected $actions = array();
39
40		// Reference to the current image filename
41		protected $image = '';
42
43		/**
44		* Creates a new Image instance and returns it.
45		*
46		* @param string filename of image
47		* @param array non-default configurations
48		* @return object
		0 ignored issues – show Documentation introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `Image`. 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...
49		*/
50		public static function factory($image, $config = null)
51		{
52		return new Image($image, $config);
53		}
54
55		/**
56		* Creates a new image editor instance.
57		*
58		* @throws Kohana_Exception
59		* @param string filename of image
60		* @param array non-default configurations
61		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
62		*/
63		public function __construct($image, $config = null)
64		{
65		static $check;
66
67		// Make the check exactly once
68		($check === null) and $check = function_exists('getimagesize');
69
70		if ($check === false) {
71		throw new Kohana_Exception('image.getimagesize_missing');
72		}
73
74		// Check to make sure the image exists
75		if (! is_file($image)) {
76		throw new Kohana_Exception('image.file_not_found', $image);
77		}
78
79		// Disable error reporting, to prevent PHP warnings
80		$ER = error_reporting(0);
		0 ignored issues – show Comprehensibility introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report Avoid variables with short names like $ER. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
81
82		// Fetch the image size and mime type
83		$image_info = getimagesize($image);
84
85		// Turn on error reporting again
86		error_reporting($ER);
87
88		// Make sure that the image is readable and valid
89		if (! is_array($image_info) or count($image_info) < 3) {
90		throw new Kohana_Exception('image.file_unreadable', $image);
91		}
92
93		// Check to make sure the image type is allowed
94		if (! isset(Image::$allowed_types[$image_info[2]])) {
95		throw new Kohana_Exception('image.type_not_allowed', $image);
96		}
97
98		// Image has been validated, load it
99		$this->image = array(
		0 ignored issues – show Documentation Bug introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report It seems like `array('file' => str_repl...=> $image_info['mime'])` of type `array<string,?,{"file":"...,"ext":"?","mime":"?"}>` is incompatible with the declared type `string` of property `$image`. 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...
100		'file' => str_replace('\\', '/', realpath($image)),
101		'width' => $image_info[0],
102		'height' => $image_info[1],
103		'type' => $image_info[2],
104		'ext' => Image::$allowed_types[$image_info[2]],
105		'mime' => $image_info['mime']
106		);
107
108		// Load configuration
109		$this->config = (array) $config + Kohana::config('image');
		0 ignored issues – show Bug introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report The property `config` 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...
110
111		// Set driver class name
112		$driver = 'Image_'.ucfirst($this->config['driver']).'_Driver';
113
114		// Load the driver
115	View Code Duplication	if (! Kohana::auto_load($driver)) {
		0 ignored issues – show Duplication introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
116		throw new Kohana_Exception('core.driver_not_found', $this->config['driver'], get_class($this));
117		}
118
119		// Initialize the driver
120		$this->driver = new $driver($this->config['params']);
121
122		// Validate the driver
123	View Code Duplication	if (! ($this->driver instanceof Image_Driver)) {
		0 ignored issues – show Duplication introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
124		throw new Kohana_Exception('core.driver_implements', $this->config['driver'], get_class($this), 'Image_Driver');
125		}
126		}
127
128		/**
129		* Handles retrieval of pre-save image properties
130		*
131		* @param string property name
132		* @return string
133		*/
134		public function __get($property)
135		{
136		if (isset($this->image[$property])) {
137		return $this->image[$property];
138		} else {
139		throw new Kohana_Exception('core.invalid_property', $property, get_class($this));
140		}
141		}
142
143		/**
144		* Resize an image to a specific width and height. By default, Kohana will
145		* maintain the aspect ratio using the width as the master dimension. If you
146		* wish to use height as master dim, set $image->master_dim = Image::HEIGHT
147		* This method is chainable.
148		*
149		* @throws Kohana_Exception
150		* @param integer width
151		* @param integer height
152		* @param integer one of: Image::NONE, Image::AUTO, Image::WIDTH, Image::HEIGHT
153		* @return Image_Core
154		*/
155		public function resize($width, $height, $master = null)
156		{
157		if (! $this->valid_size('width', $width)) {
158		throw new Kohana_Exception('image.invalid_width', $width);
159		}
160
161		if (! $this->valid_size('height', $height)) {
162		throw new Kohana_Exception('image.invalid_height', $height);
163		}
164
165		if (empty($width) and empty($height)) {
166		throw new Kohana_Exception('image.invalid_dimensions', __FUNCTION__);
167		}
168
169		if ($master === null) {
170		// Maintain the aspect ratio by default
171		$master = Image::AUTO;
172		} elseif (! $this->valid_size('master', $master)) {
173		throw new Kohana_Exception('image.invalid_master');
174		}
175
176		$this->actions['resize'] = array(
177		'width' => $width,
178		'height' => $height,
179		'master' => $master,
180		);
181
182		return $this;
183		}
184
185		/**
186		* Crop an image to a specific width and height. You may also set the top
187		* and left offset.
188		* This method is chainable.
189		*
190		* @throws Kohana_Exception
191		* @param integer width
192		* @param integer height
193		* @param integer top offset, pixel value or one of: top, center, bottom
194		* @param integer left offset, pixel value or one of: left, center, right
195		* @return Image_Core
196		*/
197		public function crop($width, $height, $top = 'center', $left = 'center')
198		{
199		if (! $this->valid_size('width', $width)) {
200		throw new Kohana_Exception('image.invalid_width', $width);
201		}
202
203		if (! $this->valid_size('height', $height)) {
204		throw new Kohana_Exception('image.invalid_height', $height);
205		}
206
207		if (! $this->valid_size('top', $top)) {
208		throw new Kohana_Exception('image.invalid_top', $top);
209		}
210
211		if (! $this->valid_size('left', $left)) {
212		throw new Kohana_Exception('image.invalid_left', $left);
213		}
214
215		if (empty($width) and empty($height)) {
216		throw new Kohana_Exception('image.invalid_dimensions', __FUNCTION__);
217		}
218
219		$this->actions['crop'] = array(
220		'width' => $width,
221		'height' => $height,
222		'top' => $top,
223		'left' => $left,
224		);
225
226		return $this;
227		}
228
229		/**
230		* Allows rotation of an image by 180 degrees clockwise or counter clockwise.
231		*
232		* @param integer degrees
233		* @return Image_Core
234		*/
235		public function rotate($degrees)
236		{
237		$degrees = (int) $degrees;
238
239		if ($degrees > 180) {
240		do {
241		// Keep subtracting full circles until the degrees have normalized
242		$degrees -= 360;
243		} while ($degrees > 180);
244		}
245
246		if ($degrees < -180) {
247		do {
248		// Keep adding full circles until the degrees have normalized
249		$degrees += 360;
250		} while ($degrees < -180);
251		}
252
253		$this->actions['rotate'] = $degrees;
254
255		return $this;
256		}
257
258		/**
259		* Flip an image horizontally or vertically.
260		*
261		* @throws Kohana_Exception
262		* @param integer direction
263		* @return Image_Core
264		*/
265		public function flip($direction)
266		{
267		if ($direction !== Image::HORIZONTAL and $direction !== Image::VERTICAL) {
268		throw new Kohana_Exception('image.invalid_flip');
269		}
270
271		$this->actions['flip'] = $direction;
272
273		return $this;
274		}
275
276		/**
277		* Change the quality of an image.
278		*
279		* @param integer quality as a percentage
280		* @return Image_Core
281		*/
282		public function quality($amount)
283		{
284		$this->actions['quality'] = max(1, min($amount, 100));
285
286		return $this;
287		}
288
289		/**
290		* Sharpen an image.
291		*
292		* @param integer amount to sharpen, usually ~20 is ideal
293		* @return Image_Core
294		*/
295		public function sharpen($amount)
296		{
297		$this->actions['sharpen'] = max(1, min($amount, 100));
298
299		return $this;
300		}
301
302		/**
303		* Save the image to a new image or overwrite this image.
304		*
305		* @throws Kohana_Exception
306		* @param string new image filename
307		* @param integer permissions for new image
308		* @param boolean keep or discard image process actions
309		* @return object
310		*/
311		public function save($new_image = false, $chmod = 0644, $keep_actions = false)
312		{
313		// If no new image is defined, use the current image
314		empty($new_image) and $new_image = $this->image['file'];
315
316		// Separate the directory and filename
317		$dir = pathinfo($new_image, PATHINFO_DIRNAME);
318		$file = pathinfo($new_image, PATHINFO_BASENAME);
319
320		// Normalize the path
321		$dir = str_replace('\\', '/', realpath($dir)).'/';
322
323		if (! is_writable($dir)) {
324		throw new Kohana_Exception('image.directory_unwritable', $dir);
325		}
326
327		if ($status = $this->driver->process($this->image, $this->actions, $dir, $file)) {
328		if ($chmod !== false) {
329		// Set permissions
330		chmod($new_image, $chmod);
331		}
332		}
333
334		// Reset actions. Subsequent save() or render() will not apply previous actions.
335		if ($keep_actions === false) {
336		$this->actions = array();
337		}
338
339		return $status;
340		}
341
342		/**
343		* Output the image to the browser.
344		*
345		* @param boolean keep or discard image process actions
346		* @return object
347		*/
348		public function render($keep_actions = false)
349		{
350		$new_image = $this->image['file'];
351
352		// Separate the directory and filename
353		$dir = pathinfo($new_image, PATHINFO_DIRNAME);
354		$file = pathinfo($new_image, PATHINFO_BASENAME);
355
356		// Normalize the path
357		$dir = str_replace('\\', '/', realpath($dir)).'/';
358
359		// Process the image with the driver
360		$status = $this->driver->process($this->image, $this->actions, $dir, $file, $render = true);
361
362		// Reset actions. Subsequent save() or render() will not apply previous actions.
363		if ($keep_actions === false) {
364		$this->actions = array();
365		}
366
367		return $status;
368		}
369
370		/**
371		* Sanitize a given value type.
372		*
373		* @param string type of property
374		* @param mixed property value
375		* @param string $type
376		* @return boolean
377		*/
378		protected function valid_size($type, & $value)
379		{
380		if (is_null($value)) {
381		return true;
382		}
383
384		if (! is_scalar($value)) {
385		return false;
386		}
387
388		switch ($type) {
389		case 'width':
390		case 'height':
391		if (is_string($value) and ! ctype_digit($value)) {
392		// Only numbers and percent signs
393		if (! preg_match('/^[0-9]++%$/D', $value)) {
394		return false;
395		}
396		} else {
397		$value = (int) $value;
398		}
399		break;
400	View Code Duplication	case 'top':
		0 ignored issues – show Duplication introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
401		if (is_string($value) and ! ctype_digit($value)) {
402		if (! in_array($value, array('top', 'bottom', 'center'))) {
403		return false;
404		}
405		} else {
406		$value = (int) $value;
407		}
408		break;
409	View Code Duplication	case 'left':
		0 ignored issues – show Duplication introduced 2016-08-25 15:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
410		if (is_string($value) and ! ctype_digit($value)) {
411		if (! in_array($value, array('left', 'right', 'center'))) {
412		return false;
413		}
414		} else {
415		$value = (int) $value;
416		}
417		break;
418		case 'master':
419		if ($value !== Image::NONE and
420		$value !== Image::AUTO and
421		$value !== Image::WIDTH and
422		$value !== Image::HEIGHT) {
423		return false;
424		}
425		break;
426		}
427
428		return true;
429		}
430		} // End Image
431

vijinho / kohana2-legacy

Image_Core C last analyzed 2016-08-25 15:53 UTC