floor12\imagenator\Imagenator

Complexity

Total Complexity

33

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	saveImage()	0	3	2
A	setFont()	0	5	1
A	loadImage()	0	8	3
A	setText()	0	5	1
A	generate()	0	6	1
A	calculateParams()	0	6	1
A	prepareRows()	0	20	6
A	setFontSize()	0	7	3
A	setPadding()	0	7	3
A	setRowHeight()	0	7	3
A	setMarginTopInPercents()	0	6	3
A	putRowsToImage()	0	6	2
A	setColor()	0	13	3

<?php

namespace floor12\imagenator;

use floor12\imagenator\exception\FontNotFoundException;
use floor12\imagenator\exception\ImageNotFoundException;
use floor12\imagenator\exception\ImageNotLoadedException;
use floor12\imagenator\exception\InvalidFontSizeException;
use floor12\imagenator\exception\InvalidHexColorException;
use floor12\imagenator\exception\InvalidPositionValueException;
use floor12\imagenator\exception\InvalidRowHeightException;

class Imagenator
{
    const DEFAULT_IMAGE = __DIR__ . '/../assets/default.png';
    /**
     * @var string Path to TTF font file
     */
    protected $font = __DIR__ . '/../assets/Rubik.ttf';
    /**
     * @var string
     */
    protected $text = "Dont forget to put some text here :-)";
    /**
     * @var resource
     */
    protected $image;
    /**
     * @var int
     */
    protected $imageWidth;
    /**
     * @var int
     */
    protected $imageHeight;
    /**
     * @var int
     */
    protected $rowHeight = 8;
    /**
     * @var int
     */
    protected $marginTopInPercents = 50;
    /**
     * @var int
     */
    protected $paddingLeftRightInPercents = 5;
    /**
     * @var int Default color is white
     */
    private $textColor = '16777215';
    /**
     * @var int
     */
    private $fontSizeInPercents = 5;
    /**
     * @var array
     */
    private $rows = [];
    /**
     * @var float|int
     */
    private $positionX;
    /**
     * @var float|int
     */
    private $positionStartY;
    /**
     * @var float|int
     */
    private $rowHeightInPx;
    /**
     * @var float|int
     */
    private $fontSizeInPx;

    /**
     * Imagenator constructor.
     * @param string $backgroundImagePath
     * @throws ImageNotFoundException
     */
    public function __construct(string $backgroundImagePath = self::DEFAULT_IMAGE)
    {
        $this->loadImage($backgroundImagePath);
    }

    /**
     * @param string $backgroundImagePath
     * @throws ImageNotFoundException
     * @throws ImageNotLoadedException
     */
    protected function loadImage(string $backgroundImagePath)
    {
        if (!file_exists($backgroundImagePath))
            throw new ImageNotFoundException();
        $this->image = imagecreatefrompng($backgroundImagePath);

It seems like imagecreatefrompng($backgroundImagePath) can also be of type false. However, the property $image is declared as type resource. Maybe add an additional type check?

        if ($this->image == null)
            throw new ImageNotLoadedException();
        list($this->imageWidth, $this->imageHeight) = getimagesize($backgroundImagePath);
    }

    /**
     * @param string $resultImagePath
     * @return bool
     * @throws FontNotFoundException
     */
    public function generate(string $resultImagePath): bool
    {
        $this->calculateParams();
        $this->prepareRows();
        $this->putRowsToImage();
        return $this->saveImage($resultImagePath);
    }

    /**
     * @param string $pathToSave
     * @return bool
     */
    protected function saveImage(string $pathToSave): bool
    {
        return imagepng($this->image, $pathToSave) && imagedestroy($this->image);
    }

    protected function calculateParams()
    {
        $this->positionStartY = intval($this->imageHeight / 100 * $this->marginTopInPercents);
        $this->rowHeightInPx = intval($this->imageHeight / 100 * $this->rowHeight);
        $this->fontSizeInPx = intval($this->imageHeight / 100 * $this->fontSizeInPercents);
        $this->positionX = intval($this->imageWidth / 100 * $this->paddingLeftRightInPercents);
    }

    /**
     * @throws FontNotFoundException
     */
    protected function prepareRows(): void
    {
        if (!file_exists($this->font))
            throw new FontNotFoundException();

        $wordsArray = explode(' ', $this->text);
        $validRowWidth = $this->imageWidth - $this->positionX * 2;
        $currentRow = 0;

        foreach ($wordsArray as $word) {
            $testRow = isset($this->rows[$currentRow]) ? array_merge($this->rows[$currentRow], [$word]) : [$word];
            $imageBox = imagettfbbox($this->fontSizeInPx, 0, $this->font, implode('', $testRow));
            if ($imageBox[2] >= $validRowWidth) {
                $lastWord = end($this->rows[$currentRow]);
                if (mb_strlen($lastWord) <= 2) {
                    $this->rows[$currentRow + 1][] = array_pop($this->rows[$currentRow]);
                }
                $this->rows[++$currentRow][] = $word;
            } else {
                $this->rows[$currentRow][] = $word;
            }
        }
    }

    /**
     *
     */
    protected function putRowsToImage()
    {
        foreach ($this->rows as $rowNumber => $row) {
            $string = implode(' ', $row);
            $positionY = intval($this->positionStartY + ($rowNumber * $this->rowHeightInPx));
            imagettftext($this->image, $this->fontSizeInPx, 0, $this->positionX, $positionY, $this->textColor, $this->font, $string);

It seems like $this->positionX can also be of type double; however, parameter $x of imagettftext() does only seem to accept integer, maybe add an additional type check?

        }
    }

    /**
     * @param string $text
     * @return self
     */
    public
    function setText(string $text): self
    {
        $this->text = $text;
        return $this;
    }

    /**
     * @param string $font
     * @return self
     */
    public
    function setFont(string $font): self
    {
        $this->font = $font;
        return $this;
    }

    /**
     * @param string $colorInHex
     * @return self
     * @throws InvalidHexColorException
     */
    public
    function setColor(string $colorInHex): self
    {
        $colorInHex = str_replace('#', '', $colorInHex);

        if (!ctype_xdigit($colorInHex) || strlen($colorInHex) !== 6)
            throw new InvalidHexColorException();

        $red = intval(hexdec(substr($colorInHex, 0, 2)));
        $green = intval(hexdec(substr($colorInHex, 2, 2)));
        $blue = intval(hexdec(substr($colorInHex, 4, 2)));
        $this->textColor = imagecolorallocate($this->image, $red, $green, $blue);
        return $this;
    }

    /**
     * @param int $size
     * @return Imagenator
     * @throws InvalidFontSizeException
     */
    public
    function setFontSize(int $size)
    {
        if ($size < 1 || $size > 20)
            throw new InvalidFontSizeException();
        $this->fontSizeInPercents = $size;
        return $this;
    }

    /**
     * @param int $percent
     * @return Imagenator
     * @throws InvalidPositionValueException
     */
    public
    function setPadding(int $percent)
    {
        if ($percent < 1 || $percent > 100)
            throw new InvalidPositionValueException();
        $this->paddingLeftRightInPercents = $percent;
        return $this;
    }

    /**
     * @param int $percent
     * @return Imagenator
     * @throws InvalidPositionValueException
     */
    public function setMarginTopInPercents(int $percent)
    {
        if ($percent < 1 || $percent > 100)
            throw new InvalidPositionValueException();
        $this->marginTopInPercents = $percent;
        return $this;
    }

    /**
     * @param int $percent
     * @return Imagenator
     * @throws InvalidRowHeightException
     */
    public
    function setRowHeight(int $percent)
    {
        if ($percent < 1 || $percent > 30)
            throw new InvalidRowHeightException();
        $this->rowHeight = $percent;
        return $this;
    }
}