ImageProvider::getHelperProperties() - Code Metrics - Inspection of "Merge remote-tracking branch 'upstream/3.x' into m..." - sonata-project/SonataMediaBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cf3a9d...627ec6 )

by Marko

created 2018-08-13 19:14 UTC

ImageProvider::getHelperProperties() C

↳ Parent: ImageProvider

Complexity

Conditions	11
Paths	15

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	68
rs	6.5515
c	0
b	0
f	0
cc	11
nc	15
nop	3

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\MediaBundle\Provider;

use Gaufrette\Filesystem;
use Imagine\Image\ImagineInterface;
use Sonata\CoreBundle\Model\Metadata;
use Sonata\MediaBundle\CDN\CDNInterface;
use Sonata\MediaBundle\Generator\GeneratorInterface;
use Sonata\MediaBundle\Metadata\MetadataBuilderInterface;
use Sonata\MediaBundle\Model\MediaInterface;
use Sonata\MediaBundle\Thumbnail\ThumbnailInterface;
use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\HttpFoundation\File\UploadedFile;

class ImageProvider extends FileProvider
{
    /**
     * @var ImagineInterface
     */
    protected $imagineAdapter;

    /**
     * @param string                   $name
     * @param Filesystem               $filesystem
     * @param CDNInterface             $cdn
     * @param GeneratorInterface       $pathGenerator
     * @param ThumbnailInterface       $thumbnail
     * @param array                    $allowedExtensions
     * @param array                    $allowedMimeTypes
     * @param ImagineInterface         $adapter
     * @param MetadataBuilderInterface $metadata
     */
    public function __construct($name, Filesystem $filesystem, CDNInterface $cdn, GeneratorInterface $pathGenerator, ThumbnailInterface $thumbnail, array $allowedExtensions, array $allowedMimeTypes, ImagineInterface $adapter, MetadataBuilderInterface $metadata = null)
    {
        parent::__construct($name, $filesystem, $cdn, $pathGenerator, $thumbnail, $allowedExtensions, $allowedMimeTypes, $metadata);

        $this->imagineAdapter = $adapter;
    }

    /**
     * {@inheritdoc}
     */
    public function getProviderMetadata()
    {
        return new Metadata($this->getName(), $this->getName().'.description', false, 'SonataMediaBundle', ['class' => 'fa fa-picture-o']);
    }

    /**
     * {@inheritdoc}
     */
    public function getHelperProperties(MediaInterface $media, $format, $options = [])
    {
        if (MediaProviderInterface::FORMAT_REFERENCE === $format) {
            $box = $media->getBox();
        } else {
            $resizerFormat = $this->getFormat($format);
            if (false === $resizerFormat) {
                throw new \RuntimeException(sprintf('The image format "%s" is not defined.
                        Is the format registered in your ``sonata_media`` configuration?', $format));
            }

            $box = $this->resizer->getBox($media, $resizerFormat);
        }

        $mediaWidth = $box->getWidth();

        $params = [
            'alt' => $media->getName(),
            'title' => $media->getName(),
            'src' => $this->generatePublicUrl($media, $format),
            'width' => $mediaWidth,
            'height' => $box->getHeight(),
        ];

        if (MediaProviderInterface::FORMAT_ADMIN !== $format) {
            $srcSetFormats = $this->getFormats();

            if (isset($options['srcset']) && is_array($options['srcset'])) {
                $srcSetFormats = [];
                foreach ($options['srcset'] as $srcSetFormat) {
                    $formatName = $this->getFormatName($media, $srcSetFormat);
                    $srcSetFormats[$formatName] = $this->getFormat($formatName);
                }
                unset($options['srcset']);

                // Make sure the requested format is also in the srcSetFormats
                if (!isset($srcSetFormats[$format])) {
                    $srcSetFormats[$format] = $this->getFormat($format);
                }
            }

            if (!isset($options['srcset'])) {
                $srcSet = [];

                foreach ($srcSetFormats as $providerFormat => $settings) {
                    // Check if format belongs to the current media's context
                    if (0 === strpos($providerFormat, $media->getContext())) {
                        $width = $this->resizer->getBox($media, $settings)->getWidth();

                        $srcSet[] = sprintf('%s %dw', $this->generatePublicUrl($media, $providerFormat), $width);
                    }
                }

                // The reference format is not in the formats list
                $srcSet[] = sprintf(
                    '%s %dw',
                    $this->generatePublicUrl($media, MediaProviderInterface::FORMAT_REFERENCE),
                    $media->getBox()->getWidth()
                );

                $params['srcset'] = implode(', ', $srcSet);
            }

            $params['sizes'] = sprintf('(max-width: %1$dpx) 100vw, %1$dpx', $mediaWidth);
        }

        return array_merge($params, $options);
    }

    /**
     * {@inheritdoc}
     */
    public function updateMetadata(MediaInterface $media, $force = true): void
    {
        try {
            if (!$media->getBinaryContent() instanceof \SplFileInfo) {
                // this is now optimized at all!!!
                $path = tempnam(sys_get_temp_dir(), 'sonata_update_metadata');
                $fileObject = new \SplFileObject($path, 'w');
                $fileObject->fwrite($this->getReferenceFile($media)->getContent());
            } else {
                $fileObject = $media->getBinaryContent();
            }

            $image = $this->imagineAdapter->open($fileObject->getPathname());
            $size = $image->getSize();

            $media->setSize($fileObject->getSize());
            $media->setWidth($size->getWidth());
            $media->setHeight($size->getHeight());
        } catch (\LogicException $e) {
            $media->setProviderStatus(MediaInterface::STATUS_ERROR);

            $media->setSize(0);
            $media->setWidth(0);
            $media->setHeight(0);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function generatePublicUrl(MediaInterface $media, $format)
    {
        if (MediaProviderInterface::FORMAT_REFERENCE === $format) {
            $path = $this->getReferenceImage($media);
        } else {
            $path = $this->thumbnail->generatePublicUrl($this, $media, $format);
        }

        // if $path is already an url, no further action is required
        if (null !== parse_url($path, PHP_URL_SCHEME)) {
            return $path;
        }

        return $this->getCdn()->getPath($path, $media->getCdnIsFlushable());
    }

    /**
     * {@inheritdoc}
     */
    public function generatePrivateUrl(MediaInterface $media, $format)
    {
        return $this->thumbnail->generatePrivateUrl($this, $media, $format);
    }

    /**
     * {@inheritdoc}
     */
    protected function doTransform(MediaInterface $media): void
    {
        parent::doTransform($media);

        if ($media->getBinaryContent() instanceof UploadedFile) {
            $fileName = $media->getBinaryContent()->getClientOriginalName();
        } elseif ($media->getBinaryContent() instanceof File) {
            $fileName = $media->getBinaryContent()->getFilename();
        } else {
            // Should not happen, FileProvider should throw an exception in that case
            return;
        }

        if (!in_array(strtolower(pathinfo($fileName, PATHINFO_EXTENSION)), $this->allowedExtensions)
            || !in_array($media->getBinaryContent()->getMimeType(), $this->allowedMimeTypes)) {
            return;
        }

        try {
            $image = $this->imagineAdapter->open($media->getBinaryContent()->getPathname());
        } catch (\RuntimeException $e) {
            $media->setProviderStatus(MediaInterface::STATUS_ERROR);

            return;
        }

        $size = $image->getSize();

        $media->setWidth($size->getWidth());
        $media->setHeight($size->getHeight());

        $media->setProviderStatus(MediaInterface::STATUS_OK);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\MediaBundle\Provider;
15
16			use Gaufrette\Filesystem;
17			use Imagine\Image\ImagineInterface;
18			use Sonata\CoreBundle\Model\Metadata;
19			use Sonata\MediaBundle\CDN\CDNInterface;
20			use Sonata\MediaBundle\Generator\GeneratorInterface;
21			use Sonata\MediaBundle\Metadata\MetadataBuilderInterface;
22			use Sonata\MediaBundle\Model\MediaInterface;
23			use Sonata\MediaBundle\Thumbnail\ThumbnailInterface;
24			use Symfony\Component\HttpFoundation\File\File;
25			use Symfony\Component\HttpFoundation\File\UploadedFile;
26
27			class ImageProvider extends FileProvider
28			{
29			/**
30			* @var ImagineInterface
31			*/
32			protected $imagineAdapter;
33
34			/**
35			* @param string $name
36			* @param Filesystem $filesystem
37			* @param CDNInterface $cdn
38			* @param GeneratorInterface $pathGenerator
39			* @param ThumbnailInterface $thumbnail
40			* @param array $allowedExtensions
41			* @param array $allowedMimeTypes
42			* @param ImagineInterface $adapter
43			* @param MetadataBuilderInterface $metadata
44			*/
45			public function __construct($name, Filesystem $filesystem, CDNInterface $cdn, GeneratorInterface $pathGenerator, ThumbnailInterface $thumbnail, array $allowedExtensions, array $allowedMimeTypes, ImagineInterface $adapter, MetadataBuilderInterface $metadata = null)
46			{
47			parent::__construct($name, $filesystem, $cdn, $pathGenerator, $thumbnail, $allowedExtensions, $allowedMimeTypes, $metadata);
48
49			$this->imagineAdapter = $adapter;
50			}
51
52			/**
53			* {@inheritdoc}
54			*/
55			public function getProviderMetadata()
56			{
57			return new Metadata($this->getName(), $this->getName().'.description', false, 'SonataMediaBundle', ['class' => 'fa fa-picture-o']);
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function getHelperProperties(MediaInterface $media, $format, $options = [])
64			{
65			if (MediaProviderInterface::FORMAT_REFERENCE === $format) {
66			$box = $media->getBox();
67			} else {
68			$resizerFormat = $this->getFormat($format);
69			if (false === $resizerFormat) {
70			throw new \RuntimeException(sprintf('The image format "%s" is not defined.
71			Is the format registered in your ``sonata_media`` configuration?', $format));
72			}
73
74			$box = $this->resizer->getBox($media, $resizerFormat);
75			}
76
77			$mediaWidth = $box->getWidth();
78
79			$params = [
80			'alt' => $media->getName(),
81			'title' => $media->getName(),
82			'src' => $this->generatePublicUrl($media, $format),
83			'width' => $mediaWidth,
84			'height' => $box->getHeight(),
85			];
86
87			if (MediaProviderInterface::FORMAT_ADMIN !== $format) {
88			$srcSetFormats = $this->getFormats();
89
90			if (isset($options['srcset']) && is_array($options['srcset'])) {
91			$srcSetFormats = [];
92			foreach ($options['srcset'] as $srcSetFormat) {
93			$formatName = $this->getFormatName($media, $srcSetFormat);
94			$srcSetFormats[$formatName] = $this->getFormat($formatName);
95			}
96			unset($options['srcset']);
97
98			// Make sure the requested format is also in the srcSetFormats
99			if (!isset($srcSetFormats[$format])) {
100			$srcSetFormats[$format] = $this->getFormat($format);
101			}
102			}
103
104			if (!isset($options['srcset'])) {
105			$srcSet = [];
106
107			foreach ($srcSetFormats as $providerFormat => $settings) {
108			// Check if format belongs to the current media's context
109			if (0 === strpos($providerFormat, $media->getContext())) {
110			$width = $this->resizer->getBox($media, $settings)->getWidth();
111
112			$srcSet[] = sprintf('%s %dw', $this->generatePublicUrl($media, $providerFormat), $width);
113			}
114			}
115
116			// The reference format is not in the formats list
117			$srcSet[] = sprintf(
118			'%s %dw',
119			$this->generatePublicUrl($media, MediaProviderInterface::FORMAT_REFERENCE),
120			$media->getBox()->getWidth()
121			);
122
123			$params['srcset'] = implode(', ', $srcSet);
124			}
125
126			$params['sizes'] = sprintf('(max-width: %1$dpx) 100vw, %1$dpx', $mediaWidth);
127			}
128
129			return array_merge($params, $options);
130			}
131
132			/**
133			* {@inheritdoc}
134			*/
135			public function updateMetadata(MediaInterface $media, $force = true): void
136			{
137			try {
138			if (!$media->getBinaryContent() instanceof \SplFileInfo) {
139			// this is now optimized at all!!!
140			$path = tempnam(sys_get_temp_dir(), 'sonata_update_metadata');
141			$fileObject = new \SplFileObject($path, 'w');
142			$fileObject->fwrite($this->getReferenceFile($media)->getContent());
143			} else {
144			$fileObject = $media->getBinaryContent();
145			}
146
147			$image = $this->imagineAdapter->open($fileObject->getPathname());
148			$size = $image->getSize();
149
150			$media->setSize($fileObject->getSize());
151			$media->setWidth($size->getWidth());
152			$media->setHeight($size->getHeight());
153			} catch (\LogicException $e) {
154			$media->setProviderStatus(MediaInterface::STATUS_ERROR);
155
156			$media->setSize(0);
157			$media->setWidth(0);
158			$media->setHeight(0);
159			}
160			}
161
162			/**
163			* {@inheritdoc}
164			*/
165			public function generatePublicUrl(MediaInterface $media, $format)
166			{
167			if (MediaProviderInterface::FORMAT_REFERENCE === $format) {
168			$path = $this->getReferenceImage($media);
169			} else {
170			$path = $this->thumbnail->generatePublicUrl($this, $media, $format);
171			}
172
173			// if $path is already an url, no further action is required
174			if (null !== parse_url($path, PHP_URL_SCHEME)) {
175			return $path;
176			}
177
178			return $this->getCdn()->getPath($path, $media->getCdnIsFlushable());
179			}
180
181			/**
182			* {@inheritdoc}
183			*/
184			public function generatePrivateUrl(MediaInterface $media, $format)
185			{
186			return $this->thumbnail->generatePrivateUrl($this, $media, $format);
187			}
188
189			/**
190			* {@inheritdoc}
191			*/
192			protected function doTransform(MediaInterface $media): void
193			{
194			parent::doTransform($media);
195
196			if ($media->getBinaryContent() instanceof UploadedFile) {
197			$fileName = $media->getBinaryContent()->getClientOriginalName();
198			} elseif ($media->getBinaryContent() instanceof File) {
199			$fileName = $media->getBinaryContent()->getFilename();
200			} else {
201			// Should not happen, FileProvider should throw an exception in that case
202			return;
203			}
204
205			if (!in_array(strtolower(pathinfo($fileName, PATHINFO_EXTENSION)), $this->allowedExtensions)
206			\|\| !in_array($media->getBinaryContent()->getMimeType(), $this->allowedMimeTypes)) {
207			return;
208			}
209
210			try {
211			$image = $this->imagineAdapter->open($media->getBinaryContent()->getPathname());
212			} catch (\RuntimeException $e) {
213			$media->setProviderStatus(MediaInterface::STATUS_ERROR);
214
215			return;
216			}
217
218			$size = $image->getSize();
219
220			$media->setWidth($size->getWidth());
221			$media->setHeight($size->getHeight());
222
223			$media->setProviderStatus(MediaInterface::STATUS_OK);
224			}
225			}
226

sonata-project / SonataMediaBundle

Push — master ( cf3a9d...627ec6 )

ImageProvider::getHelperProperties() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like