Graze\CiffRenderer\Renderer\FieldRenderer\FieldRendererComplexText

Complexity

Total Complexity

22

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Test Coverage

Coverage

84.62%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	factory()	0	4	1
B	wrap()	0	25	7
B	renderLine()	0	56	6
B	render()	0	57	7

<?php

namespace Graze\CiffRenderer\Renderer\FieldRenderer;

use Graze\CiffRenderer\Parser\FieldParser\FieldParserComplexText;
use Graze\CiffRenderer\Parser\FieldParser\FieldParserInterface;
use Intervention\Image\Gd\Font;
use Intervention\Image\ImageManager;

class FieldRendererComplexText implements FieldRendererInterface
{
    /**
     * @var float
     */
    const LETTER_SPACING_ADJUSTMENT = 0.97;

    /**
     * @var Font
     */
    private $font;

    /**
     * @param Font $font
     */
    public function __construct(Font $font)
    {
        $this->font = $font;
    }

    /**
     * @param ImageManager $imageManager
     * @param FieldParserInterface $parser
     * @param null|callable $fontResolver
     * @param null|callable $graphicResolver
     * @return \Intervention\Image\Image
     */
    public function render(
        ImageManager $imageManager,
        FieldParserInterface $parser,
        callable $fontResolver = null,
        callable $graphicResolver = null
    ) {
        $fontPath = $fontResolver($parser->getFontFace());

        // Input may be multiline so grab the raw lines but preserve empty lines by injecting spaces
        $rawLines = explode("\n", str_replace("\n\n", "\n \n", $parser->getText()));
        $lines = [];
        foreach ($rawLines as $rawLine) {
            // Pass each raw line through the wrapping function
            $lines = array_merge($lines, explode("\n", $this->wrap($parser->getFontSize(), $fontPath, $rawLine, $parser->getWidth())));
        }

        $renderedTexts = [];
        $width = 0;
        $height = 0;

        foreach ($lines as $line) {
            $renderedText = $this->renderLine($imageManager, $parser, $fontPath, $line);
            if (is_null($renderedText)) {
                continue;
            }

            // store dimensions ready to create a canvas
            $width = max($width, $renderedText->getWidth());
            $height += $renderedText->getHeight();

            $renderedTexts[] = $renderedText;
        }

        if (empty($renderedTexts)) {
            // nothing to render
            return null;
        }

        // create a canvas to add each line of text to
        $canvas = $imageManager->canvas($width, $height);

        $offsetX = 0;
        $offsetY = 0;
        foreach ($renderedTexts as $renderedText) {
            // add the text to the canvas
            $canvas->insert($renderedText, 'top-left', (int) $offsetX, (int) $offsetY);

            // increase the offset for the next line
            $offsetY += $renderedText->getHeight();
        }

        $orientation = $parser->getOrientation();
        if ($orientation) {
            $canvas->rotate(360 - $orientation);
        }

        return $canvas;
    }

    /**
     * @param ImageManager $imageManager
     * @param FieldParserInterface $parser
     * @param string $fontPath
     * @param string $text
     * @return \Intervention\Image\Image
     */
    private function renderLine(ImageManager $imageManager, FieldParserInterface $parser, $fontPath, $text)
    {
        // create the text here so it can be measured
        $this->font->text($text);

        $this->font->file($fontPath);
        $this->font->size($parser->getFontSize());
        $this->font->color('#000');
        $this->font->align($parser->getTextAlignment());
        $this->font->valign('top');

        $size = $this->font->getBoxSize();

        // If we are trying to render a single space, it will have zero height and be skipped. Temporarily use the
        // dimensions of the letter 'l' to ensure it isn't skipped.
        if ($text == ' ') {
            $this->font->text('l');
            $size = $this->font->getBoxSize();
            $this->font->text($text);
        }

        // if text consists of invisible chars, measured size will be zero, nothing to print
        if ($size['width'] < 1 || $size['height'] < 1) {
            return null;
        }

        $fontCallback = function (&$font) {
            // override the font created by Canvas::text()
            $font = $this->font;
        };

        $canvas = $imageManager->canvas($parser->getWidth(), $size['height']);

        // figure out the correct reference point for this alignment
        switch ($parser->getTextAlignment()) {
            case FieldParserComplexText::ALIGN_CENTRE:
                $posX = round($parser->getWidth()/2);
                break;

            case FieldParserComplexText::ALIGN_RIGHT:
                $posX = $parser->getWidth();
                break;

            default:
                $posX = 0;
                break;
        }

        // no need to pass the text in here as we override the font in the callback
        $canvas->text('', $posX, 0, $fontCallback);

It seems like $posX can also be of type double; however, parameter $x of Intervention\Image\Image::text() does only seem to accept integer, maybe add an additional type check?

        // attempt to correct differences between this and Clarisoft
        $width = (int) round($parser->getWidth() * self::LETTER_SPACING_ADJUSTMENT);
        $canvas->resize($width, $size['height']);

        return $canvas;
    }

    /**
     * Wrap the given text such that it doesn't exceed the given width using the given font and size.
     *
     * Derived from https://www.php.net/manual/en/function.imagettftext.php#89505
     *
     * @param string $fontSize
     * @param string $fontFace
     * @param string $string
     * @param int $width
     * @return string
     */
    private function wrap($fontSize, $fontFace, $string, $width)
    {
        // Font size needs to be scaled a bit to render to the same width as in Clarisoft.
        $fontSize = $fontSize * 0.8;
        $wrappedString = "";

        if ($string == ' ') {
            return $string;
        }

        $words = explode(' ', $string);

        foreach ($words as $word) {
            $teststring = $wrappedString=="" ? $word : $wrappedString.' '.$word;
            $testbox = imagettfbbox($fontSize, 0, $fontFace, $teststring);

The call to Graze\CiffRenderer\Renderer\FieldRenderer\imagettfbbox() has too many arguments starting with $fontSize.

            // Check that adding the new word does not exceed the width we want.
            // This isn't exact for various (unknown) reasons, so there is a 10 pixel buffer.
            if ($testbox[2] > ($width+10)) {
                $wrappedString.=($wrappedString=="" ? "" : "\n").$word;
            } else {
                $wrappedString.=($wrappedString=="" ? "" : ' ').$word;
            }
        }

        return $wrappedString;
    }

    /**
     * @return FieldRendererInterface
     */
    public static function factory()
    {
        return new static(
            new Font()
        );
    }
}