Manager::getOriginalFilename() - Code Metrics - Inspection of "Update documentation" - onigoetz/imagecache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a5c5e5...2d8f65 )

by Stéphane

created 2016-01-18 21:21 UTC

Manager::getOriginalFilename() A

↳ Parent: Manager

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	9.4285
cc	2
eloc	3
nc	2
nop	1
crap	2

<?php

/**
 * Image Manager
 */
namespace Onigoetz\Imagecache;

/**
 * Image manager
 *
 * Prepares the images for the cache
 *
 *
 * @author Stéphane Goetz
 */
class Manager
{
    /**
     * @var array Contains configurations and presets
     */
    protected $options;

    /**
     * @var MethodCaller
     */
    protected $methodCaller;

    /**
     * @var string
     */
    protected $retinaRegex = '/(.*)@2x\\.(jpe?g|png|webp|gif)/';

    public function __construct($options)
    {
        $this->options = $options + ['path_images' => 'images', 'path_cache' => 'cache'];
    }

    /**
     * @return MethodCaller
     */
    public function getMethodCaller()
    {
        if (!$this->methodCaller) {
            $this->methodCaller = new MethodCaller();
        }

        return $this->methodCaller;
    }

    /**
     * @param MethodCaller $methodCaller
     */
    public function setMethodCaller(MethodCaller $methodCaller)
    {
        $this->methodCaller = $methodCaller;
    }

    public function url($preset, $file)
    {
        return "{$this->options['path_images']}/{$this->options['path_cache']}/$preset/$file";
    }

    public function imageUrl($file)
    {
        return "{$this->options['path_images']}/$file";
    }

    public function isRetina($file)
    {
        return !!preg_match($this->retinaRegex, $file);
    }

    public function getOriginalFilename($file) {
        $matched = preg_match($this->retinaRegex, $file, $matches);

        return ($matched)? $matches[1] . '.' . $matches[2] : $file;
    }

    protected function getPresetActions($preset_key, $file)
    {
        // Is it a valid preset
        if (!array_key_exists($preset_key, $this->options['presets'])) {
            throw new Exceptions\InvalidPresetException('invalid preset');
        }

        $preset = $this->options['presets'][$preset_key];

        if (!$this->isRetina($file)) {
            return $preset;
        }

        // Handle retina images

        $preset_key = "$preset_key@2x";

        if (array_key_exists($preset_key, $this->options['presets'])) {
            return $this->options['presets'][$preset_key];
        }

        foreach ($preset as &$action) {
            $action = $this->generateRetinaAction($action);
        }

        return $preset;
    }

    protected function generateRetinaAction($action)
    {
        foreach (['width', 'height', 'xoffset', 'yoffset'] as $option) {
            if (array_key_exists($option, $action) && is_numeric($action[$option])) {
                $action[$option] *= 2;
            }
        }

        return $action;
    }

    /**
     * Take a preset and a file and return a transformed image
     *
     * @param $preset_key string
     * @param $file string
     * @throws Exceptions\InvalidPresetException
     * @throws Exceptions\NotFoundException
     * @throws \RuntimeException
     * @return string
     */
    public function handleRequest($preset_key, $file)
    {
        //do it at the beginning for early validation
        $preset = $this->getPresetActions($preset_key, $file);

        $source_file =  $this->getOriginalFilename($file);

        $original_file = $this->options['path_images_root'] . '/' . $this->imageUrl($source_file);
        if (!is_file($original_file)) {
            throw new Exceptions\NotFoundException('File not found');
        }

        $final_file = $this->url($preset_key, $file);

        $this->verifyDirectoryExistence($this->options['path_images_root'], dirname($final_file));

        $final_file = $this->options['path_images_root'] . '/' . $final_file;

        if (file_exists($final_file)) {
            return $final_file;
        }

        $image = $this->loadImage($original_file);

        return $this->buildImage($preset, $image, $final_file)->source;
    }

    /**
     * Create the folder containing the cached images if it doesn't exist
     *
     * @param $base
     * @param $cacheDir
     */
    protected function verifyDirectoryExistence($base, $cacheDir)
    {
        if (is_dir("$base/$cacheDir")) {
            return;
        }

        $folder_path = explode('/', $cacheDir);
        foreach ($folder_path as $element) {
            $base .= '/' . $element;
            if (!is_dir($base)) {
                mkdir($base, 0755, true);
                chmod($base, 0755);
            }
        }
    }

    protected function loadImage($src)
    {
        return new Image($src);
    }

    /**
     * Create a new image based on an image preset.
     *
     * @param array $actions An image preset array.
     * @param Image $image Path of the source file.
     * @param string $dst Path of the destination file.
     * @throws \RuntimeException
     * @return Image
     */
    protected function buildImage($actions, Image $image, $dst)
    {
        foreach ($actions as $action) {
            // Make sure the width and height are computed first so they can be used
            // in relative x/yoffsets like 'center' or 'bottom'.
            if (isset($action['width'])) {
                $action['width'] = $this->percent($action['width'], $image->getWidth());
            }

            if (isset($action['height'])) {
                $action['height'] = $this->percent($action['height'], $image->getHeight());
            }

            if (isset($action['xoffset'])) {
                $action['xoffset'] = $this->keywords($action['xoffset'], $image->getWidth(), $action['width']);
            }

            if (isset($action['yoffset'])) {
                $action['yoffset'] = $this->keywords($action['yoffset'], $image->getHeight(), $action['height']);
            }

            $this->getMethodCaller()->call($image, $action['action'], $action);
        }

        return $image->save($dst);
    }

    /**
     * Accept a percentage and return it in pixels.
     *
     * @param  string $value
     * @param  int $current_pixels
     * @return mixed
     */
    public function percent($value, $current_pixels)
    {
        if (strpos($value, '%') !== false) {
            $value = str_replace('%', '', $value) * 0.01 * $current_pixels;
        }

        return $value;
    }

    /**
     * Accept a keyword (center, top, left, etc) and return it as an offset in pixels.
     *
     * @param $value
     * @param $current_pixels
     * @param $new_pixels
     * @return float|int
     */
    public function keywords($value, $current_pixels, $new_pixels)
    {
        switch ($value) {
            case 'top':
            case 'left':
                $value = 0;
                break;
            case 'bottom':
            case 'right':
                $value = $current_pixels - $new_pixels;
                break;
            case 'center':
                $value = $current_pixels / 2 - $new_pixels / 2;
                break;
        }

        return $value;
    }
}


1		<?php
2
3		/**
4		* Image Manager
5		*/
6		namespace Onigoetz\Imagecache;
7
8		/**
9		* Image manager
10		*
11		* Prepares the images for the cache
12		*
13		*
14		* @author Stéphane Goetz
15		*/
16		class Manager
17		{
18		/**
19		* @var array Contains configurations and presets
20		*/
21		protected $options;
22
23		/**
24		* @var MethodCaller
25		*/
26		protected $methodCaller;
27
28		/**
29		* @var string
30		*/
31		protected $retinaRegex = '/(.*)@2x\\.(jpe?g\|png\|webp\|gif)/';
32
33	153	public function __construct($options)
34		{
35	153	$this->options = $options + ['path_images' => 'images', 'path_cache' => 'cache'];
36	153	}
37
38		/**
39		* @return MethodCaller
40		*/
41	54	public function getMethodCaller()
42		{
43	54	if (!$this->methodCaller) {
44	51	$this->methodCaller = new MethodCaller();
45	34	}
46
47	54	return $this->methodCaller;
48		}
49
50		/**
51		* @param MethodCaller $methodCaller
52		*/
53	3	public function setMethodCaller(MethodCaller $methodCaller)
54		{
55	3	$this->methodCaller = $methodCaller;
56	3	}
57
58	15	public function url($preset, $file)
59		{
60	15	return "{$this->options['path_images']}/{$this->options['path_cache']}/$preset/$file";
61		}
62
63	21	public function imageUrl($file)
64		{
65	21	return "{$this->options['path_images']}/$file";
66		}
67
68	36	public function isRetina($file)
69		{
70	36	return !!preg_match($this->retinaRegex, $file);
71		}
72
73	39	public function getOriginalFilename($file) {
74	39	$matched = preg_match($this->retinaRegex, $file, $matches);
75
76	39	return ($matched)? $matches[1] . '.' . $matches[2] : $file;
77		}
78
79	36	protected function getPresetActions($preset_key, $file)
80		{
81		// Is it a valid preset
82	36	if (!array_key_exists($preset_key, $this->options['presets'])) {
83	9	throw new Exceptions\InvalidPresetException('invalid preset');
84		}
85
86	27	$preset = $this->options['presets'][$preset_key];
87
88	27	if (!$this->isRetina($file)) {
89	21	return $preset;
90		}
91
92		// Handle retina images
93
94	6	$preset_key = "$preset_key@2x";
95
96	6	if (array_key_exists($preset_key, $this->options['presets'])) {
97	3	return $this->options['presets'][$preset_key];
98		}
99
100	3	foreach ($preset as &$action) {
101	3	$action = $this->generateRetinaAction($action);
102	2	}
103
104	3	return $preset;
105		}
106
107	27	protected function generateRetinaAction($action)
108		{
109	27	foreach (['width', 'height', 'xoffset', 'yoffset'] as $option) {
110	27	if (array_key_exists($option, $action) && is_numeric($action[$option])) {
111	25	$action[$option] *= 2;
112	16	}
113	18	}
114
115	27	return $action;
116		}
117
118		/**
119		* Take a preset and a file and return a transformed image
120		*
121		* @param $preset_key string
122		* @param $file string
123		* @throws Exceptions\InvalidPresetException
124		* @throws Exceptions\NotFoundException
125		* @throws \RuntimeException
126		* @return string
127		*/
128	42	public function handleRequest($preset_key, $file)
129		{
130		//do it at the beginning for early validation
131	42	$preset = $this->getPresetActions($preset_key, $file);
132
133	36	$source_file = $this->getOriginalFilename($file);
134
135	36	$original_file = $this->options['path_images_root'] . '/' . $this->imageUrl($source_file);
136	36	if (!is_file($original_file)) {
137	9	throw new Exceptions\NotFoundException('File not found');
138		}
139
140	27	$final_file = $this->url($preset_key, $file);
141
142	27	$this->verifyDirectoryExistence($this->options['path_images_root'], dirname($final_file));
143
144	27	$final_file = $this->options['path_images_root'] . '/' . $final_file;
145
146	27	if (file_exists($final_file)) {
147	6	return $final_file;
148		}
149
150	24	$image = $this->loadImage($original_file);
151
152	15	return $this->buildImage($preset, $image, $final_file)->source;
153		}
154
155		/**
156		* Create the folder containing the cached images if it doesn't exist
157		*
158		* @param $base
159		* @param $cacheDir
160		*/
161	15	protected function verifyDirectoryExistence($base, $cacheDir)
162		{
163	15	if (is_dir("$base/$cacheDir")) {
164	3	return;
165		}
166
167	15	$folder_path = explode('/', $cacheDir);
168	15	foreach ($folder_path as $element) {
169	15	$base .= '/' . $element;
170	15	if (!is_dir($base)) {
171	15	mkdir($base, 0755, true);
172	15	chmod($base, 0755);
173	10	}
174	10	}
175	15	}
176
177	15	protected function loadImage($src)
178		{
179	15	return new Image($src);
180		}
181
182		/**
183		* Create a new image based on an image preset.
184		*
185		* @param array $actions An image preset array.
186		* @param Image $image Path of the source file.
187		* @param string $dst Path of the destination file.
188		* @throws \RuntimeException
189		* @return Image
190		*/
191	78	protected function buildImage($actions, Image $image, $dst)
192		{
193	78	foreach ($actions as $action) {
194		// Make sure the width and height are computed first so they can be used
195		// in relative x/yoffsets like 'center' or 'bottom'.
196	78	if (isset($action['width'])) {
197	60	$action['width'] = $this->percent($action['width'], $image->getWidth());
198	40	}
199
200	78	if (isset($action['height'])) {
201	51	$action['height'] = $this->percent($action['height'], $image->getHeight());
202	34	}
203
204	78	if (isset($action['xoffset'])) {
205	15	$action['xoffset'] = $this->keywords($action['xoffset'], $image->getWidth(), $action['width']);
206	10	}
207
208	78	if (isset($action['yoffset'])) {
209	15	$action['yoffset'] = $this->keywords($action['yoffset'], $image->getHeight(), $action['height']);
210	10	}
211
212	78	$this->getMethodCaller()->call($image, $action['action'], $action);
213	48	}
214
215	72	return $image->save($dst);
216		}
217
218		/**
219		* Accept a percentage and return it in pixels.
220		*
221		* @param string $value
222		* @param int $current_pixels
223		* @return mixed
224		*/
225	51	public function percent($value, $current_pixels)
226		{
227	51	if (strpos($value, '%') !== false) {
228	9	$value = str_replace('%', '', $value) * 0.01 * $current_pixels;
229	6	}
230
231	51	return $value;
232		}
233
234		/**
235		* Accept a keyword (center, top, left, etc) and return it as an offset in pixels.
236		*
237		* @param $value
238		* @param $current_pixels
239		* @param $new_pixels
240		* @return float\|int
241		*/
242	27	public function keywords($value, $current_pixels, $new_pixels)
243		{
244		switch ($value) {
245	27	case 'top':
246	22	case 'left':
247	6	$value = 0;
248	6	break;
249	18	case 'bottom':
250	18	case 'right':
251	6	$value = $current_pixels - $new_pixels;
252	6	break;
253	14	case 'center':
254	3	$value = $current_pixels / 2 - $new_pixels / 2;
255	3	break;
256		}
257
258	27	return $value;
259		}
260		}
261

onigoetz / imagecache

Push — master ( a5c5e5...2d8f65 )

Manager::getOriginalFilename() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like