SWP\Bundle\ContentBundle\Processor\EmbeddedImageProcessor

Complexity

Total Complexity

17

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	supports()	0	4	1
A	__construct()	0	5	1
B	process()	0	36	6
A	setDefaultImageRendition()	0	4	1
A	appendImageByline()	0	8	1
A	applyByline()	0	4	1
A	processImageElement()	0	23	4
A	getDefaultImageRendition()	0	8	2

<?php

declare(strict_types=1);

/*
 * This file is part of the Superdesk Web Publisher Content Bundle.
 *
 * Copyright 2018 Sourcefabric z.ú. and contributors.
 *
 * For the full copyright and license information, please see the
 * AUTHORS and LICENSE files distributed with this source code.
 *
 * @copyright 2018 Sourcefabric z.ú
 * @license http://www.superdesk.org/license
 */

namespace SWP\Bundle\ContentBundle\Processor;

use SWP\Bundle\ContentBundle\File\FileExtensionCheckerInterface;
use SWP\Bundle\ContentBundle\Manager\MediaManagerInterface;
use SWP\Bundle\ContentBundle\Model\ArticleInterface;
use SWP\Bundle\ContentBundle\Model\ArticleMediaInterface;
use SWP\Bundle\ContentBundle\Model\ImageRendition;
use Symfony\Component\DomCrawler\Crawler;

class EmbeddedImageProcessor implements EmbeddedImageProcessorInterface
{
    private const DEFAULT_ARTICLE_BODY_IMAGE_RENDITION = 'original';

    /**
     * @var MediaManagerInterface
     */
    private $mediaManager;

    /**
     * @var FileExtensionCheckerInterface
     */
    private $fileExtensionChecker;

    /**
     * @var string
     */
    private $defaultImageRendition;

    public function __construct(MediaManagerInterface $mediaManager, FileExtensionCheckerInterface $fileExtensionChecker)
    {
        $this->mediaManager = $mediaManager;
        $this->fileExtensionChecker = $fileExtensionChecker;
    }

    public function process(ArticleInterface $article, ArticleMediaInterface $articleMedia): void
    {
        $body = $article->getBody();
        $mediaId = str_replace('/', '\\/', $articleMedia->getKey());

        preg_match(
            "/(<!-- ?EMBED START Image {id: \"$mediaId\"} ?-->)(.+?)(<!-- ?EMBED END Image {id: \"$mediaId\"} ?-->)/im",
            str_replace(PHP_EOL, '', $body),
            $embeds
        );

        if (empty($embeds)) {
            return;
        }

        $figureString = $embeds[2];
        $crawler = new Crawler($figureString);
        $images = $crawler->filter('figure img');

        /** @var \DOMElement $imageElement */
        foreach ($images as $imageElement) {
            /** @var ImageRendition $rendition */
            foreach ($articleMedia->getRenditions() as $rendition) {
                if ($this->getDefaultImageRendition() === $rendition->getName()) {
                    $this->processImageElement($imageElement, $rendition, $mediaId);
                }
            }
        }

        $figCaptionNode = $crawler->filter('figure figcaption')->getNode(0);
        if (null !== $figCaptionNode) {
            $this->appendImageByline($articleMedia, $figCaptionNode);
        }

        $article->setBody(str_replace($figureString, $crawler->filter('body')->html(), $body));
    }

    public function setDefaultImageRendition(string $renditionName): void
    {
        $this->defaultImageRendition = $renditionName;
    }

    public function supports(string $type): bool
    {
        return $this->fileExtensionChecker->isImage($type);
    }

    private function appendImageByline(ArticleMediaInterface $articleMedia, \DOMElement $figCaptionNode): void
    {
        $element = new \DOMElement('span');
        $figCaptionNode->appendChild($element);

        $authorDiv = $figCaptionNode->childNodes[1];
        $authorDiv->textContent = $this->applyByline($articleMedia);
    }

    public function applyByline(ArticleMediaInterface $articleMedia): string
    {
        return $articleMedia->getByLine();
    }

    protected function processImageElement(\DOMElement $imageElement, ImageRendition $rendition, string $mediaId): void
    {
        $attributes = $imageElement->attributes;
        $altAttribute = null;
        if ($imageElement->hasAttribute('alt')) {
            $altAttribute = $attributes->getNamedItem('alt');
        }

        while ($attributes->length) {

The property length does not seem to exist in DOMNamedNodeMap.

            $imageElement->removeAttribute($attributes->item(0)->name);

The property name does not seem to exist in DOMNode.

        }

        $imageElement->setAttribute('src', $this->mediaManager->getMediaUri($rendition->getImage()));
        $imageElement->setAttribute('data-media-id', $mediaId);
        $imageElement->setAttribute('data-image-id', $rendition->getImage()->getAssetId());
        $imageElement->setAttribute('data-rendition-name', $this->getDefaultImageRendition());
        $imageElement->setAttribute('width', (string) $rendition->getWidth());
        $imageElement->setAttribute('height', (string) $rendition->getHeight());

        if (null !== $altAttribute) {
            $imageElement->setAttribute('alt', $altAttribute->nodeValue);
        }
    }

    protected function getDefaultImageRendition(): string
    {
        if (null === $this->defaultImageRendition) {
            return self::DEFAULT_ARTICLE_BODY_IMAGE_RENDITION;
        }

        return $this->defaultImageRendition;
    }
}