nstdio\svg\container\SVG

Complexity

Total Complexity

19

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	10

Test Coverage

Coverage

46.27%

Importance

Changes	7
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	22	1
A	apply()	0	6	1
A	getRoot()	0	4	1
A	getName()	0	4	1
A	getElement()	0	4	1
A	createElement()	0	8	1
A	__toString()	0	4	1
A	draw()	0	4	1
A	asBase64()	0	6	1
A	copy()	0	4	1
A	asString()	0	4	1
A	asSVG()	0	4	1
A	asSVGZ()	0	8	3
A	asDataUriBase64()	0	7	1
A	asFile()	0	8	1
A	asImageFile()	0	9	1
A	asImage()	0	8	1

<?php
namespace nstdio\svg\container;

use DOMElement;
use Hoa\Mime\Mime;
use nstdio\svg\Base;
use nstdio\svg\ElementFactoryInterface;
use nstdio\svg\ElementStorage;
use nstdio\svg\output\IOFormat;
use nstdio\svg\output\Output;
use nstdio\svg\output\OutputInterface;
use nstdio\svg\output\SVGOutputInterface;
use nstdio\svg\traits\ChildTrait;
use nstdio\svg\traits\ElementTrait;
use nstdio\svg\util\KeyValueWriter;
use nstdio\svg\XMLDocumentInterface;

/**
 * Class SVG
 *
 * @property string viewBox
 * @package nstdio\svg
 * @author  Edgar Asatryan <nstdio@gmail.com>
 */
class SVG extends Base implements ContainerInterface, ElementFactoryInterface, SVGOutputInterface
{
    use ElementTrait, ChildTrait;

    /**
     * @var XMLDocumentInterface
     */
    private $svg;

    /**
     * @var OutputInterface
     */
    private $outputImpl;

    public function __construct($width = 640, $height = 480, XMLDocumentInterface $dom = null)
    {
        parent::__construct($dom);

        $this->svg = $this->element('svg');
        $this->child = new ElementStorage();
        $this->outputImpl = new Output();

        $this->apply([
            'width'   => $width,
            'height'  => $height,
            'version' => '1.1',
            'xmlns'   => self::XML_NS,
            'viewBox' => sprintf("0 0 %d %d", $width, $height),
        ]);

        $this->domImpl->appendChild($this->svg);

        $this->svg->setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:xlink', self::XML_NS_XLINK);

        new Defs($this);
    }

    /**
     * @param array $assoc
     *
     * @return mixed
     */
    public function apply(array $assoc)
    {
        KeyValueWriter::apply($this->svg, $assoc);

        return $this;
    }

    public function getRoot()
    {
        return $this->svg;
    }

    public function getName()
    {
        return 'svg';
    }

    /**
     * @return DOMElement
     */
    public function getElement()
    {
        return $this->svg->getElement();
    }

    public function createElement($name, $value = null, $attributes = [])
    {
        $element = $this->domImpl->createElement($name, $value);

        KeyValueWriter::apply($element, $attributes);

        return $element;
    }

    public function __toString()
    {
        return $this->draw();
    }

    public function draw()
    {
        return $this->domImpl->saveHTML();
    }

    public function asBase64()
    {
        $data = base64_encode($this->domImpl->saveHTML());

        return "data:image/svg+xml;base64,{$data}";
    }

    /**
     * @inheritdoc
     */
    public function copy(array $apply = [], array $ignore = [], ContainerInterface $parent = null)
    {
        throw new \BadMethodCallException("You cannot copy SVG element.");
    }

    /**
     * Returns escaped svg as plain text.
     *
     * @return string
     */
    public function asString()
    {
        return htmlspecialchars($this->draw());
    }

    /**
     * @inheritdoc
     */
    public function asSVG()
    {
        return $this->draw();
    }

    /**
     * @inheritdoc
     */
    public function asSVGZ($sendHeader = false)
    {
        if ($sendHeader && !headers_sent()) {
            header("Content-Encoding: gzip");
        }

        return gzencode($this->draw(), 9);
    }

    /**
     * @inheritdoc
     */
    public function asDataUriBase64()
    {
        $encoded = base64_encode($this->draw());
        $mimeType = Mime::getMimeFromExtension('svg');

        return sprintf("data:%s;base64,%s", $mimeType, $encoded);
    }

    /**
     * @inheritdoc
     */
    public function asFile($name, $prettyPrint = false, $override = false)
    {
        return $this->outputImpl->file(
            $name,
            $this->domImpl->saveXML($prettyPrint),
            $override
        );
    }

    /**
     * @inheritdoc
     */
    public function asImageFile($name, $format = IOFormat::PNG, $override = false)
    {
        return $this->outputImpl->imageFile(
            $this->domImpl->saveXML(),

The call to saveXML() misses a required argument $formatOutput.

            $name,
            $format,
            $override
        );
    }

    /**
     * @inheritdoc
     */
    public function asImage($format = IOFormat::PNG, $sendHeader = false)
    {
        return $this->outputImpl->image(
            $this->domImpl->saveXML(),

The call to saveXML() misses a required argument $formatOutput.

            $format,
            $sendHeader
        );
    }
}