Spatie\Backup\BackupDestination\BackupDestination

Complexity

Total Complexity

27

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	disk()	0	4	1
A	diskName()	0	4	1
A	filesystemType()	0	12	2
A	create()	0	14	2
A	write()	0	18	3
A	backupName()	0	4	1
A	backups()	0	13	3
A	connectionError()	0	4	1
A	isReachable()	0	16	3
A	usedStorage()	0	4	1
A	newestBackup()	0	4	1
A	oldestBackup()	0	4	1
A	newestBackupIsOlderThan()	0	10	2
A	fresh()	0	6	1
A	extraOptions()	0	10	3

<?php

namespace Spatie\Backup\BackupDestination;

use Exception;
use Carbon\Carbon;
use Illuminate\Contracts\Filesystem\Factory;
use Illuminate\Contracts\Filesystem\Filesystem;
use Spatie\Backup\Exceptions\InvalidBackupDestination;

class BackupDestination
{
    /** @var \Illuminate\Contracts\Filesystem\Filesystem */
    protected $disk;

    /** @var string */
    protected $diskName;

    /** @var string */
    protected $backupName;

    /** @var Exception */
    public $connectionError;

    /** @var null|\Spatie\Backup\BackupDestination\BackupCollection */
    protected $backupCollectionCache = null;

    public function __construct(Filesystem $disk = null, string $backupName, string $diskName)
    {
        $this->disk = $disk;

        $this->diskName = $diskName;

        $this->backupName = preg_replace('/[^a-zA-Z0-9.]/', '-', $backupName);
    }

    public function disk(): Filesystem
    {
        return $this->disk;
    }

    public function diskName(): string
    {
        return $this->diskName;
    }

    public function filesystemType(): string
    {
        if (is_null($this->disk)) {
            return 'unknown';
        }

        $adapterClass = get_class($this->disk->getDriver()->getAdapter());

        $filesystemType = last(explode('\\', $adapterClass));

        return strtolower($filesystemType);
    }

    public static function create(string $diskName, string $backupName): self
    {
        try {
            $disk = app(Factory::class)->disk($diskName);

            return new static($disk, $backupName, $diskName);
        } catch (Exception $exception) {
            $backupDestination = new static(null, $backupName, $diskName);

            $backupDestination->connectionError = $exception;

            return $backupDestination;
        }
    }

    public function write(string $file)
    {
        if (is_null($this->disk)) {
            throw InvalidBackupDestination::diskNotSet();
        }

        $destination = $this->backupName.'/'.pathinfo($file, PATHINFO_BASENAME);

        $handle = fopen($file, 'r+');

        $options = $this->extraOptions();

        $this->disk->getDriver()->writeStream($destination, $handle, $options);

        if (is_resource($handle)) {
            fclose($handle);
        }
    }

    public function backupName(): string
    {
        return $this->backupName;
    }

    public function backups(): BackupCollection
    {
        if ($this->backupCollectionCache) {
            return $this->backupCollectionCache;
        }

        $files = is_null($this->disk) ? [] : $this->disk->allFiles($this->backupName);

        return $this->backupCollectionCache = BackupCollection::createFromFiles(

It seems like \Spatie\Backup\BackupDestination\BackupCollection::createFromFiles($this->disk, $files) of type object<self> is incompatible with the declared type null|object<Spatie\Backup\BackupDestination\BackupCollection> of property $backupCollectionCache.

            $this->disk,
            $files
        );
    }

    public function connectionError(): Exception
    {
        return $this->connectionError;
    }

    public function extraOptions(): ?array
    {
        $extraConfig = config('filesystems.disks.'.$this->diskName().'.backup_extra_options') ?? [];

        if (! is_array($extraConfig) || (count($extraConfig) < 1)) {
            return [];
        }

        return $extraConfig;
    }

    public function isReachable(): bool
    {
        if (is_null($this->disk)) {
            return false;
        }

        try {
            $this->disk->allFiles($this->backupName);

            return true;
        } catch (Exception $exception) {
            $this->connectionError = $exception;

            return false;
        }
    }

    public function usedStorage(): int
    {
        return $this->backups()->size();
    }

    public function newestBackup(): ?Backup
    {
        return $this->backups()->newest();
    }

    public function oldestBackup(): ?Backup
    {
        return $this->backups()->oldest();
    }

    public function newestBackupIsOlderThan(Carbon $date): bool
    {
        $newestBackup = $this->newestBackup();

        if (is_null($newestBackup)) {
            return true;
        }

        return $newestBackup->date()->gt($date);
    }

    public function fresh(): self
    {
        $this->backupCollectionCache = null;

        return $this;
    }
}