Spatie\Backup\BackupDestination\BackupCollection

Complexity

Total Complexity

13

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	createFromFiles()	0	14	1
A	pathRepresentsBackup()	0	5	2
A	pathExtensionRepresentsBackup()	0	4	1
A	pathMimeTypeRepresetsBackup()	0	9	2
A	pathMimeType()	0	4	3
A	newest()	0	4	1
A	oldest()	0	6	1
A	size()	0	8	2

<?php

namespace Spatie\Backup\BackupDestination;

use Exception;
use Illuminate\Support\Collection;

class BackupCollection extends Collection
{
    /** @var null|int */
    protected $sizeCache = null;

    /** @var array */
    protected static $allowedMimeTypes = [
        'application/zip', 'application/x-zip', 'application/x-gzip',
    ];

    /**
     * @param \Illuminate\Contracts\Filesystem\Filesystem|null $disk
     * @param array                                            $files
     *
     * @return \Spatie\Backup\BackupDestination\BackupCollection
     */
    public static function createFromFiles($disk, array $files): self
    {
        return (new static($files))
            ->filter(function ($path) use ($disk) {
                return static::pathRepresentsBackup($disk, $path);
            })
            ->map(function ($path) use ($disk) {
                return new Backup($disk, $path);

It seems like $disk defined by parameter $disk on line 24 can be null; however, Spatie\Backup\BackupDestination\Backup::__construct() does not accept null, maybe add an additional type check?

            })
            ->sortByDesc(function (Backup $backup) {
                return $backup->date()->timestamp;
            })
            ->values();
    }

    /**
     * @param \Illuminate\Contracts\Filesystem\Filesystem|null $disk
     * @param string $path
     *
     * @return bool
     */
    protected static function pathRepresentsBackup($disk, $path)
    {
        return static::pathMimeTypeRepresetsBackup($disk, $path)
            ?: static::pathExtensionRepresentsBackup($path);
    }

    /**
     * @param string $path
     *
     * @return bool
     */
    protected static function pathExtensionRepresentsBackup($path)
    {
        return pathinfo($path, PATHINFO_EXTENSION) === 'zip';
    }

    /**
     * @param \Illuminate\Contracts\Filesystem\Filesystem|null $disk
     * @param string $path
     *
     * @return bool
     */
    protected static function pathMimeTypeRepresetsBackup($disk, $path)
    {
        // Some drivers throw exceptions when checking mime types.
        try {
            return in_array(static::pathMimeType($disk, $path), self::$allowedMimeTypes);
        } catch (Exception $e) {
            return false;
        }
    }


    /**
     * @param \Illuminate\Contracts\Filesystem\Filesystem|null $disk
     * @param string $path
     *
     * @return string|false
     */
    protected static function pathMimeType($disk, $path)
    {
        return ($disk && method_exists($disk, 'mimeType')) ? $disk->mimeType($path) : false;
    }

    /**
     * @return \Spatie\Backup\BackupDestination\Backup|null
     */
    public function newest()
    {
        return $this->first();
    }

    /**
     * @return \Spatie\Backup\BackupDestination\Backup|null
     */
    public function oldest()
    {
        return $this
            ->filter->exists()
            ->last();
    }

    public function size(): int
    {
        if ($this->sizeCache !== null) {
            return $this->sizeCache;
        }

        return $this->sizeCache = $this->sum->size();
    }
}