ImageController::guessMimeType() - Code Metrics - svycka/sv-images - Measure and Improve Code Quality continuously with Scrutinizer

ImageController::guessMimeType() A
last analyzed 2016-04-07 06:56 UTC

↳ Parent: ImageController

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
c	2
b	1
f	0
dl	0
loc	18
ccs	0
cts	16
cp	0
rs	9.4285
cc	2
eloc	12
nc	2
nop	1
crap	6

<?php
namespace SvImages\Controller;

use SvImages\Exception\SvImagesException;
use SvImages\Options\ModuleOptions;
use SvImages\Parser\Result;
use SvImages\Router\RouteMatch;
use SvImages\Service\CacheManager;
use SvImages\Service\ImageService;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\Http\Response;

/**
 * @author Vytautas Stankus <[email protected]>
 * @license MIT
 */
class ImageController extends AbstractActionController
{
    /**
     * @var ImageService
     */
    protected $imageService;

    /**
     * @var CacheManager
     */
    protected $cacheManager;

    /**
     * @var ModuleOptions
     */
    private $options;

    /**
     * @param ImageService  $imageService
     * @param CacheManager  $cacheManager
     * @param ModuleOptions $options
     */
    public function __construct(
        ImageService $imageService,
        CacheManager $cacheManager,
        ModuleOptions $options
    ) {
        $this->imageService = $imageService;
        $this->cacheManager = $cacheManager;
        $this->options = $options;
    }

    public function imageAction()
    {
        $routeMatch = $this->getEvent()->getRouteMatch();

        if (!$routeMatch instanceof RouteMatch) {
            $this->notFoundAction(); // todo
        }

        $result = $routeMatch->getParserResult();
        $uriPath = $result->getUriPath();

        if ($this->options->isCacheEnabled() && $contents = $this->cacheManager->get($uriPath)) {
            return $this->prepareResponse($contents, $result);
        }

        // fixme: this makes debugging very difficult by hiding all exceptions
        try {
            $contents = $this->imageService->generateImage($result);
        } catch (SvImagesException $exception) {
            // TODO: maybe implement some kind of failure handling strategy?
            // error image or 1px image would be better?
            $this->notFoundAction();
        }

        if ($this->options->isCacheEnabled() && $contents) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->cacheManager->save($uriPath, $contents);
        }

        return $this->prepareResponse($contents, $result);
<?php

function getDate($date)
{
    if ($date !== null) {
        return new DateTime($date);
    }

    return false;
}
    }

    /**
     * Creates response object
     *
     * @param string $content
     * @param Result $result
     *
     * @return Response
     */
    protected function prepareResponse($content, Result $result)
    {
        $mimeType = $this->guessMimeType($result->getFilePath());

        if (function_exists('mb_strlen')) {
            $contentLength = mb_strlen($content, '8bit');
        } else {
            $contentLength = strlen($content);
        }

        /* @var $response Response */
        $response = $this->getResponse();
        $response->getHeaders()
            ->addHeaderLine('Content-Transfer-Encoding', 'binary')
            ->addHeaderLine('Content-Type', $mimeType)
            ->addHeaderLine('Content-Length', $contentLength)
            // fixme: maybe add cache options to config
            ->addHeaderLine('Cache-Control', 'max-age=31536000, public')
            ->addHeaderLine('Expires', date_create('+1 years')->format('D, d M Y H:i:s').' GMT');

        $response->setContent($content);

        return $response;
    }

    /**
     * Guess MimeType by extension
     *
     * @param $filename
     *
     * @return string
     * @throws SvImagesException
     *
     * TODO: create MimeType resolver. Current implementation has a lot of problems
     */
    protected function guessMimeType($filename)
    {
        $mimeTypes = [
            'jpeg' => 'image/jpeg',
            'jpg'  => 'image/jpeg',
            'gif'  => 'image/gif',
            'png'  => 'image/png',
            'wbmp' => 'image/vnd.wap.wbmp',
            'xbm'  => 'image/xbm',
        ];

        $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
        if (!isset($mimeTypes[$extension])) {
            throw new SvImagesException('Invalid format');
        }

        return $mimeTypes[$extension];
    }
}


1			<?php
2			namespace SvImages\Controller;
3
4			use SvImages\Exception\SvImagesException;
5			use SvImages\Options\ModuleOptions;
6			use SvImages\Parser\Result;
7			use SvImages\Router\RouteMatch;
8			use SvImages\Service\CacheManager;
9			use SvImages\Service\ImageService;
10			use Zend\Mvc\Controller\AbstractActionController;
11			use Zend\Http\Response;
12
13			/**
14			* @author Vytautas Stankus <[email protected]>
15			* @license MIT
16			*/
17			class ImageController extends AbstractActionController
18			{
19			/**
20			* @var ImageService
21			*/
22			protected $imageService;
23
24			/**
25			* @var CacheManager
26			*/
27			protected $cacheManager;
28
29			/**
30			* @var ModuleOptions
31			*/
32			private $options;
33
34			/**
35			* @param ImageService $imageService
36			* @param CacheManager $cacheManager
37			* @param ModuleOptions $options
38			*/
39			public function __construct(
40			ImageService $imageService,
41			CacheManager $cacheManager,
42			ModuleOptions $options
43			) {
44			$this->imageService = $imageService;
45			$this->cacheManager = $cacheManager;
46			$this->options = $options;
47			}
48
49			public function imageAction()
50			{
51			$routeMatch = $this->getEvent()->getRouteMatch();
52
53			if (!$routeMatch instanceof RouteMatch) {
54			$this->notFoundAction(); // todo
55			}
56
57			$result = $routeMatch->getParserResult();
58			$uriPath = $result->getUriPath();
59
60			if ($this->options->isCacheEnabled() && $contents = $this->cacheManager->get($uriPath)) {
61			return $this->prepareResponse($contents, $result);
62			}
63
64			// fixme: this makes debugging very difficult by hiding all exceptions
65			try {
66			$contents = $this->imageService->generateImage($result);
67			} catch (SvImagesException $exception) {
68			// TODO: maybe implement some kind of failure handling strategy?
69			// error image or 1px image would be better?
70			$this->notFoundAction();
71			}
72
73			if ($this->options->isCacheEnabled() && $contents) {
			0 ignored issues – show Bug Best Practice introduced 2016-03-01 07:52 UTC by Report Bug Copy Issue Report The expression `$contents` of type `false\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
74			$this->cacheManager->save($uriPath, $contents);
75			}
76
77			return $this->prepareResponse($contents, $result);
			0 ignored issues – show Security Bug introduced 2016-03-01 07:52 UTC by Report Bug Copy Issue Report It seems like `$contents` defined by `$this->imageService->generateImage($result)` on line `66` can also be of type `false`; however, `SvImages\Controller\Imag...ller::prepareResponse()` does only seem to accept `string`, did you maybe forget to handle an error condition? This check looks for type mismatches where the missing type is `false`. This is usually indicative of an error condtion. Consider the follow example <?php function getDate($date) { if ($date !== null) { return new DateTime($date); } return false; } This function either returns a new `DateTime` object or false, if there was an error. This is a typical pattern in PHP programming to show that an error has occurred without raising an exception. The calling code should check for this returned `false` before passing on the value to another function or method that may not be able to handle a `false`. Loading history...
78			}
79
80			/**
81			* Creates response object
82			*
83			* @param string $content
84			* @param Result $result
85			*
86			* @return Response
87			*/
88			protected function prepareResponse($content, Result $result)
89			{
90			$mimeType = $this->guessMimeType($result->getFilePath());
91
92			if (function_exists('mb_strlen')) {
93			$contentLength = mb_strlen($content, '8bit');
94			} else {
95			$contentLength = strlen($content);
96			}
97
98			/* @var $response Response */
99			$response = $this->getResponse();
100			$response->getHeaders()
101			->addHeaderLine('Content-Transfer-Encoding', 'binary')
102			->addHeaderLine('Content-Type', $mimeType)
103			->addHeaderLine('Content-Length', $contentLength)
104			// fixme: maybe add cache options to config
105			->addHeaderLine('Cache-Control', 'max-age=31536000, public')
106			->addHeaderLine('Expires', date_create('+1 years')->format('D, d M Y H:i:s').' GMT');
107
108			$response->setContent($content);
109
110			return $response;
111			}
112
113			/**
114			* Guess MimeType by extension
115			*
116			* @param $filename
117			*
118			* @return string
119			* @throws SvImagesException
120			*
121			* TODO: create MimeType resolver. Current implementation has a lot of problems
122			*/
123			protected function guessMimeType($filename)
124			{
125			$mimeTypes = [
126			'jpeg' => 'image/jpeg',
127			'jpg' => 'image/jpeg',
128			'gif' => 'image/gif',
129			'png' => 'image/png',
130			'wbmp' => 'image/vnd.wap.wbmp',
131			'xbm' => 'image/xbm',
132			];
133
134			$extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
135			if (!isset($mimeTypes[$extension])) {
136			throw new SvImagesException('Invalid format');
137			}
138
139			return $mimeTypes[$extension];
140			}
141			}
142

svycka / sv-images

ImageController::guessMimeType() A last analyzed 2016-04-07 06:56 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ImageController::guessMimeType() A
last analyzed 2016-04-07 06:56 UTC