SixtyNine\Cloud\Factory\FontsFactory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

92.86%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	4
A	create()	0	4	1
A	loadFonts()	0	7	2
A	addFont()	0	6	1
A	getFont()	0	5	1
A	getImagineFont()	0	5	1
A	getFonts()	0	4	1

<?php


namespace SixtyNine\Cloud\Factory;

use Imagine\Gd\Imagine;
use Imagine\Image\Box;
use Imagine\Image\Color;
use Imagine\Image\Point;
use Imagine\Gd\Font as ImagineFont;
use SixtyNine\Cloud\Model\Font;
use Webmozart\Assert\Assert;

class FontsFactory
{
    /** @var array */
    protected $fonts = array();

    /**
     * Initialize the FontsFactory.
     *
     * If $isFontPath is true then the first parameter is considered as a path to
     * a directory containing the fonts. This directory is scanned for TTF and OTF
     * fonts.
     *
     * If $isFontPath is false, then the first parameter must contain a path to
     * a TTF/ODF font, or must be an array of those paths.
     *
     * @param string|array $fonts
     * @param bool $isFontPath
     */
    protected function __construct($fonts, $isFontPath = true)
    {
        if ($isFontPath) {
            $this->loadFonts($fonts);

It seems like $fonts defined by parameter $fonts on line 32 can also be of type array; however, SixtyNine\Cloud\Factory\FontsFactory::loadFonts() does only seem to accept string, maybe add an additional type check?

            return;
        }

        $fonts = is_array($fonts) ? $fonts : [$fonts];
        foreach ($fonts as $font) {
            $this->addFont($font);
        }
    }

    /**
     * @param string $fonts
     * @param bool $isFontPath
     * @return FontsFactory
     */
    public static function create($fonts, $isFontPath = true)
    {
        return new self($fonts, $isFontPath);
    }

    /**
     * @param string $fontsPath
     */
    public function loadFonts($fontsPath)
    {
        Assert::fileExists($fontsPath, 'The fonts path must exist');
        foreach (glob($fontsPath . '/*.{ttf,otf}', GLOB_BRACE) as $filename) {
            $this->addFont($filename);
        }
    }

    /**
     * @param string $filename
     */
    protected function addFont($filename)
    {
        Assert::fileExists($filename, 'The font file must exist');
        $name = basename($filename);
        $this->fonts[$name] = realpath($filename);
    }

    /**
     * @param string $name
     * @return Font
     * @throws \InvalidArgumentException
     */
    public function getFont($name)
    {
        Assert::keyExists($this->fonts, $name, 'Font not found: ' . $name);
        return new Font($name, $this->fonts[$name]);
    }

    /**
     * @param string $name
     * @param int $size
     * @param string $color
     * @return ImagineFont
     */
    public function getImagineFont($name, $size, $color = '#000000')
    {
        $font = $this->getFont($name);
        return new ImagineFont($font->getFile(), $size, new Color($color));
    }

    /**
     * @return array
     */
    public function getFonts()
    {
        return array_keys($this->fonts);
    }
}