Thinktomorrow\AssetLibrary\Asset

Complexity

Total Complexity

52

Size/Duplication

Total Lines	255
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	1

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getData()	0	5	2
A	getPath()	0	3	2
A	hasData()	0	5	2
A	getHumanReadableSize()	0	3	1
A	getSize()	0	3	1
A	getExtensionType()	0	8	1
A	getBaseName()	0	3	1
C	getUrl()	0	25	12
A	getImageDimensions()	0	17	4
A	isImage()	0	3	1
A	hasFile()	0	3	1
A	getFileName()	0	5	2
A	getImageWidth()	0	3	1
A	getExtension()	0	3	1
A	url()	0	3	1
A	exists()	0	15	4
A	filename()	0	3	1
A	getMimeType()	0	3	1
A	getImageHeight()	0	3	1
A	getMediaPropertyValue()	0	7	2
A	getConversions()	0	8	2
B	registerMediaConversions()	0	32	8

<?php

namespace Thinktomorrow\AssetLibrary;

use Spatie\MediaLibrary\InteractsWithMedia;
use Spatie\MediaLibrary\MediaCollections\Models\Media;
use Illuminate\Database\Eloquent\Model;
use Spatie\MediaLibrary\HasMedia;

class Asset extends Model implements HasMedia
{
    use InteractsWithMedia;

The trait Spatie\MediaLibrary\InteractsWithMedia requires some properties which are not provided by Thinktomorrow\AssetLibrary\Asset: $fallbackPath, $mediaConversionRegistrations, $forceDeleting, $fallbackUrl, $media, $collection_name

    /**
     * The asset model always has one collection type. Different collection types for
     * the owning model are set on the asset model instead of the media model.
     */
    const MEDIA_COLLECTION = 'default';

    /**
     * Proxy for the data values on the associated pivot. This is the context data
     * relevant and unique for each owner - asset relation.
     */
    public function hasData(string $key): bool
    {
        if (!$this->pivot) return false;

The property pivot does not seem to exist on Thinktomorrow\AssetLibrary\Asset. Are you sure there is no database migration missing?

        return $this->pivot->hasData($key);
    }

    /**
     * Proxy for the data values on the associated pivot. This is the context data
     * relevant and unique for each owner - asset relation.
     */
    public function getData(string $key, $default = null)
    {
        if (!$this->pivot) return $default;

The property pivot does not seem to exist on Thinktomorrow\AssetLibrary\Asset. Are you sure there is no database migration missing?

        return $this->pivot->getData($key, $default);
    }

    /**
     * Return path of the media file. In case the passed conversion
     * does not exist, the path to the original is returned.
     */
    public function getPath($conversionName = ''): ?string
    {
        return $this->getFirstMediaPath(self::MEDIA_COLLECTION, $conversionName) ?: null;
    }

    /**
     * Return url of the media file. In case the passed conversion
     * does not exist, the url to the original is returned.
     */
    public function getUrl(string $conversionName = '', ?string $format = null): ?string
    {
        if ($conversionName !== '' && $format) {
            $conversionName = $format . '-' . $conversionName;
        }

        if (!$media = $this->getFirstMedia(self::MEDIA_COLLECTION)) {
            return $this->getFallbackMediaUrl(self::MEDIA_COLLECTION) ?: null;
        }

        if ($conversionName !== '') {
            if ($media->hasGeneratedConversion($conversionName)) {
                return $media->getUrl($conversionName) ?: null;
            }

            if (str_contains($conversionName, '-')) {
                $conversionNameWithoutFormat = substr($conversionName, strpos($conversionName, '-') + 1);

                if ($media->hasGeneratedConversion($conversionNameWithoutFormat)) {
                    return $media->getUrl($conversionNameWithoutFormat) ?: null;
                }
            }
        }

        return $media->getUrl() ?: null;
    }

    /**
     * Return filename of the media file. In case the passed conversion
     * does not exist, the name to the original is returned.
     */
    public function getFileName(string $conversionName = ''): ?string
    {
        if (!$path = $this->getFirstMediaPath(self::MEDIA_COLLECTION, $conversionName)) return null;

        return basename($path);
    }

    public function getBaseName(string $conversionName = ''): string
    {
        return basename($this->getFileName($conversionName), '.' . $this->getExtension());

It seems like $this->getFileName($conversionName) can also be of type null; however, parameter $path of basename() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * Checks if the conversion exists. It checks if file
     * exists as media record and on the server
     */
    public function exists(string $conversionName = ''): bool
    {
        // In case there is no media model attached to our Asset.
        if (!$path = $this->getFirstMediaPath(self::MEDIA_COLLECTION, $conversionName)) {
            return false;
        }

        // When we specifically check if a conversion exists, we need to explicitly check if the provided path is that of the conversion.
        // This is because Media Library falls back to returning the original path if the converted file does not exist.
        if ($conversionName) {
            $originalPath = $this->getFirstMediaPath(self::MEDIA_COLLECTION, '');
            if ($originalPath == $path) return false;
        }

        return file_exists($path);
    }

    public function getSize(): int
    {
        return $this->getMediaPropertyValue('size', 0);
    }

    public function getHumanReadableSize(): string
    {
        return $this->getMediaPropertyValue('human_readable_size', '');
    }

    public function getMimeType(): ?string
    {
        return $this->getMediaPropertyValue('mime_type');
    }

    public function getExtension(): string
    {
        return $this->getMediaPropertyValue('extension', '');
    }

    public function getExtensionType(): string
    {
        return match (strtolower($this->getExtension())) {
            'xls', 'xlsx', 'numbers', 'sheets' => 'spreadsheet',
            'png', 'jpg', 'jpeg', 'gif', 'svg', 'webp' => 'image',
            'pdf' => 'pdf',
            'mp4', 'webm', 'mpeg', 'mov' => 'video',
            default => 'file'
        };
    }

    public function isImage(): bool
    {
        return $this->getExtensionType() == 'image';
    }

    public function getImageWidth(string $conversionName = ''): ?int
    {
        return $this->getImageDimensions($conversionName)['width'];
    }

    public function getImageHeight(string $conversionName = ''): ?int
    {
        return $this->getImageDimensions($conversionName)['height'];
    }

    private function getImageDimensions(string $conversionName = ''): array
    {
        $result = [
            'width' => null,
            'height' => null,
        ];

        if (!$this->isImage() || !$this->exists($conversionName)) {
            return $result;
        }

        if ($dimensions = getimagesize($this->getPath($conversionName))) {
            $result['width'] = $dimensions[0];
            $result['height'] = $dimensions[1];
        }

        return $result;
    }

    private function getMediaPropertyValue(string $property, $default = null)
    {
        if (!$mediaModel = $this->getFirstMedia(self::MEDIA_COLLECTION)) {
            return $default;
        }

        return $mediaModel->{$property};
    }

    /**
     * @deprecated Use getFileName instead
     */
    public function filename($size = ''): string
    {
        return $this->getFileName($size);

The expression return $this->getFileName($size) could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * @deprecated use getUrl() instead
     */
    public function url($size = ''): string
    {
        return $this->getUrl($size);

The expression return $this->getUrl($size) could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * @deprecated use exists() instead
     */
    public function hasFile(): bool
    {
        return $this->exists();
    }

    public function getConversions(): array
    {
        if (!$media = $this->getFirstMedia()) return [];

        return $media
            ->getGeneratedConversions()
            ->keys()
            ->all();
    }

    /**
     * Register the conversions that should be performed.
     *
     * @param Media|null $media
     * @throws \Spatie\Image\Exceptions\InvalidManipulation
     */
    public function registerMediaConversions(Media $media = null): void
    {
        $conversions = config('thinktomorrow.assetlibrary.conversions');
        $formats = config('thinktomorrow.assetlibrary.formats', []);

        // Remove format when original is already in one of these formats
        $originalFormat = null;
        $canKeepOriginalFormat = true;

        if ($media && false !== $formatKey = array_search($media->extension, $formats)) {
            unset($formats[$formatKey]);

            $originalFormat = $media->extension;
            $canKeepOriginalFormat = in_array(strtolower($originalFormat), ['jpg', 'jpeg', 'pjpg', 'png', 'gif']);
        }

        foreach ($conversions as $key => $value) {
            $conversion = $this->addMediaConversion($key)
                ->width($value['width'])
                ->height($value['height']);

            ($canKeepOriginalFormat || !$originalFormat)
                ? $conversion->keepOriginalImageFormat()
                : $conversion->format($originalFormat);
        }

        foreach ($formats as $format) {
            foreach ($conversions as $conversionName => $values) {
                $this->addMediaConversion($format . '-' . $conversionName)
                    ->width($value['width'])

The variable $value seems to be defined by a foreach iteration on line 249. Are you sure the iterator is never empty, otherwise this variable is not defined?

                    ->height($value['height'])
                    ->format($format);
            }
        }
    }
}