Kaloa\Image\Image

Complexity

Total Complexity

37

Size/Duplication

Total Lines	238
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

42.98%

Importance

Changes	5
Bugs	1	Features	4

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__call()	0	11	2
A	create()	0	4	1
C	getMimeTypeFromBinary()	0	32	7
A	getMimeType()	0	4	1
A	createFromPath()	0	4	1
A	createFromGd()	0	6	1
A	createFromString()	0	7	1
A	filter()	0	6	1
A	isInitialized()	0	4	1
A	getResource()	0	8	2
C	output()	0	31	7
C	outputRaw()	0	29	7
A	getFactory()	0	4	1
A	setFactory()	0	4	1
A	__clone()	0	6	2

<?php

/*
 * This file is part of the kaloa/image package.
 *
 * For full copyright and license information, please view the LICENSE file
 * that was distributed with this source code.
 */

namespace Kaloa\Image;

use Kaloa\Image\Filter\FilterInterface;
use Kaloa\Image\ImageException;
use Kaloa\Image\ImageFactory;

/**
 *
 */
final class Image
{
    /**
     *
     * @var resource
     */
    private $resource = null;

    const TYPE_UNKNOWN = 'application/octet-stream';
    const TYPE_JPEG    = 'image/jpeg';
    const TYPE_PNG     = 'image/png';
    const TYPE_GIF     = 'image/gif';
    const TYPE_BMP     = 'image/x-windows-bmp';
    const TYPE_TIFF    = 'image/tiff';

    /**
     *
     * @var resource
     */
    private $mimeType = null;

    /**
     *
     * @var ImageFactory
     */
    private $factory;

    /**
     *
     * @param ImageFactory $factory
     */
    public function __construct(ImageFactory $factory)
    {
        $this->mimeType = self::TYPE_UNKNOWN;

It seems like self::TYPE_UNKNOWN of type string is incompatible with the declared type resource of property $mimeType.

        $this->factory = $factory;
    }

    public function __call($name, $arguments)
    {
        if (!$this->factory->_hasFilter($name)) {
            throw new ImageException('Unknown filter or unknown method: '
                    . $name);
        }

        $this->filter($this->factory->_getFilterInstance($name, $arguments));

        return $this;
    }

    private function create($resource)
    {
        $this->resource = $resource;
    }

    /**
     *
     *
     * @param  string $binary
     * @return string TYPE_* constant
     */
    private function getMimeTypeFromBinary($binary)
    {
        $type = self::TYPE_UNKNOWN;

$type is not used, you could remove the assignment.

        switch (true) {
            case (1 === preg_match('/\A\xff\xd8\xff/', $binary)):
                $type = self::TYPE_JPEG;
                break;
            case (1 === preg_match('/\AGIF8[79]a/', $binary)):
                $type = self::TYPE_GIF;
                break;
            case (1 === preg_match('/\A\x89PNG\x0d\x0a/', $binary)):
                $type = self::TYPE_PNG;
                break;
            case (1 === preg_match('/\ABM/', $binary)):
                $type = self::TYPE_BMP;
                break;
            case (1 === preg_match('/\A\x49\x49(?:\x2a\x00|\x00\x4a)/',
                        $binary)):
                $type = self::TYPE_TIFF;
                break;
            case (1 === preg_match('/\AFORM.{4}ILBM/', $binary)):
                /** TODO Find out what this is */
                $type = self::TYPE_UNKNOWN;
                break;
            default:
                $type = self::TYPE_UNKNOWN;
                break;
        }

        return $type;
    }

    public function getMimeType()
    {
        return $this->mimeType;
    }

    public function createFromPath($path)
    {
        return $this->createFromString(file_get_contents($path));
    }

    public function createFromGd($resource)
    {
        $this->create($resource);

        return $this;
    }

    public function createFromString($imageData)
    {
        $this->mimeType = $this->getMimeTypeFromBinary($imageData);

It seems like $this->getMimeTypeFromBinary($imageData) of type string is incompatible with the declared type resource of property $mimeType.

        $this->create(imagecreatefromstring($imageData));

        return $this;
    }

    public function filter(FilterInterface $filter)
    {
        $this->resource = $filter->render($this);

        return $this;
    }

    public function isInitialized()
    {
        return ($this->resource !== null);
    }

    public function getResource()
    {
        if (!$this->isInitialized()) {
            throw new ImageException('Image is not initialized');
        }

        return $this->resource;
    }

    /**
     * Output image directly
     *
     * Appopriate MIME types will be set.
     */
    public function output()
    {
        switch ($this->mimeType) {
            case self::TYPE_JPEG:
                header('Content-Type: image/jpeg');
                imagejpeg($this->resource);
                break;
            case self::TYPE_PNG:
                header('Content-Type: image/png');
                imagepng($this->resource);
                break;
            case self::TYPE_GIF:
                header('Content-Type: image/gif');
                imagegif($this->resource);
                break;
            case self::TYPE_BMP:
                header('Content-Type: image/x-windows-bmp');
                imagewbmp($this->resource);
                break;
            case self::TYPE_TIFF:
                /** TODO */
                header('Content-Type: image/x-windows-bmp');
                imagewbmp($this->resource);
                break;
            case self::TYPE_UNKNOWN:
                /** TODO */
                header('Content-Type: image/png');
                imagepng($this->resource);
                break;
        }
    }

    /**
     *
     * @return string Binary string containing image data
     */
    public function outputRaw()
    {
        ob_start();

        switch ($this->mimeType) {
            case self::TYPE_JPEG:
                imagejpeg($this->resource);
                break;
            case self::TYPE_PNG:
                imagepng($this->resource);
                break;
            case self::TYPE_GIF:
                imagegif($this->resource);
                break;
            case self::TYPE_BMP:
                imagewbmp($this->resource);
                break;
            case self::TYPE_TIFF:
                /** TODO */
                imagewbmp($this->resource);
                break;
            case self::TYPE_UNKNOWN:
                /** TODO */
                imagepng($this->resource);
                break;
        }

        return ob_get_clean();
    }

    /**
     *
     * @return ImageFactory
     */
    public function getFactory()
    {
        return $this->factory;
    }

    /**
     *
     * @param ImageFactory $factory
     */
    public function setFactory(ImageFactory $factory)
    {
        $this->factory = $factory;
    }

    /**
     *
     */
    public function __clone()
    {
        if (null !== $this->resource) {
            $this->createFromString($this->outputRaw());
        }
    }
}