FileStorage::removeVariant() - Code Metrics - Phauthentic/file-storage - Measure and Improve Code Quality continuously with Scrutinizer

FileStorage::removeVariant() A
last analyzed 2022-10-18 19:50 UTC

↳ Parent: FileStorage

Complexity

Conditions	3
Paths	3

Size

Total Lines	20
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
cc	3
eloc	11
c	0
b	0
f	0
nc	3
nop	2
dl	0
loc	20
ccs	0
cts	6
cp	0
crap	12
rs	9.9

<?php

/**
 * Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
 * @author    Florian Krämer
 * @link      https://github.com/Phauthentic
 * @license   https://opensource.org/licenses/MIT MIT License
 */

declare(strict_types=1);

namespace Phauthentic\Infrastructure\Storage;

use InvalidArgumentException;
use League\Flysystem\AdapterInterface;
use League\Flysystem\Config;
use Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface;
use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantDoesNotExistException;
use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantException;
use Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface;
use RuntimeException;

/**
 * File Storage
 */
class FileStorage implements FileStorageInterface
{
    /**
     * @var array
     */
    protected array $callbacks = [
        'beforeSave' => [],
        'afterSave' => [],
        'beforeRemove' => [],
        'afterRemove' => [],
    ];

    /**
     * @var \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface|null
     */
    protected ?PathBuilderInterface $pathBuilder;

    /**
     * @var \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface|null
     */
    protected ?UrlBuilderInterface $urlBuilder;

    /**
     * @var \Phauthentic\Infrastructure\Storage\StorageServiceInterface
     */
    protected StorageServiceInterface $storageService;

    /**
     * Constructor
     *
     * @param \Phauthentic\Infrastructure\Storage\StorageServiceInterface $storageService Storage Service
     * @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface|null $pathBuilder Path Builder
     * @param \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface|null $urlBuilder Path Builder
     */
    public function __construct(
        StorageServiceInterface $storageService,
        ?PathBuilderInterface $pathBuilder = null,
        ?UrlBuilderInterface $urlBuilder = null
    ) {
        $this->storageService = $storageService;
        $this->pathBuilder = $pathBuilder;
        $this->urlBuilder = $urlBuilder;
    }

    /**
     * @param string $name Name of the callback
     * @return void
     */
    protected function checkCallbackName(string $name): void
    {
        if (!array_key_exists($name, $this->callbacks)) {
            throw new InvalidArgumentException(sprintf(
                'Invalid callback `%s`, only %s are valid',
                $name,
                implode(', ', array_keys($this->callbacks))
            ));
        }
    }

    /**
     * Adds a callback
     *
     * @param string $name
     * @param callable $callable Callable
     * @return void
     */
    public function addCallback($name, callable $callable): void
    {
        $this->checkCallbackName($name);
        $this->callbacks[$name][] = $callable;
    }

    /**
     * @param string $name Name of the callback
     * @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function runCallbacks(string $name, FileInterface $file): FileInterface
    {
        $this->checkCallbackName($name);

        foreach ($this->callbacks[$name] as $callback) {
            $file = $callback($file);
        }

        return $file;
    }

    /**
     * @inheritDoc
     * @throws \RuntimeException
     */
    public function store(FileInterface $file, ?Config $config = null): FileInterface
    {
        if ($config === null) {
            $config = new Config();
        }

        if ($this->pathBuilder !== null) {
            $file = $file->buildPath($this->pathBuilder);
        }

        if ($this->urlBuilder !== null) {
            $file = $file->buildUrl($this->urlBuilder);
        }

        $file = $this->runCallbacks('beforeSave', $file);

        $storage = $this->getStorage($file->storage());
        $resource = $file->resource();
        if ($resource === null) {
            throw new RuntimeException('No resource given');
        }
        $storage->writeStream($file->path(), $resource, $config);

        return $this->runCallbacks('afterSave', $file);
    }

    /**
     * @inheritDoc
     */
    public function remove(FileInterface $file): FileInterface
    {
        $file = $this->runCallbacks('beforeRemove', $file);

        // Delete all variants of the file
        foreach ($file->variants() as $variant) {
            if (!empty($variant['path'])) {
                $this->getStorage($file->storage())->delete($variant['path']);
            }
        }

        // Delete the file
        $this->getStorage($file->storage())->delete($file->path());

        return $this->runCallbacks('afterRemove', $file);
    }

    /**
     * @inheritDoc
     */
    public function removeVariant(FileInterface $file, string $name): FileInterface
    {
        if (!$file->hasVariant($name)) {
            throw VariantDoesNotExistException::withName($name);
        }

        $variant = $file->variant($name);
        if (empty($variant['path'])) {
            throw new VariantException(sprintf(
                'Variant `%s` is missing a path',
                $name
            ));
        }

        $this->getStorage($file->storage())->delete($variant['path']);

        $variants = $file->variants();
        unset($variants[$name]);

        return $file->withVariants($variants, false);
    }

    /**
     * Gets the storage abstraction to use
     *
     * @param string $storage Storage name to use
     * @return \League\Flysystem\AdapterInterface
     */
    public function getStorage(string $storage): AdapterInterface
    {
        return $this->storageService->adapter($storage);
    }
}


1		<?php
2
3		/**
4		* Copyright (c) Florian Krämer (https://florian-kraemer.net)
5		* Licensed under The MIT License
6		* For full copyright and license information, please see the LICENSE.txt
7		* Redistributions of files must retain the above copyright notice.
8		*
9		* @copyright Copyright (c) Florian Krämer (https://florian-kraemer.net)
10		* @author Florian Krämer
11		* @link https://github.com/Phauthentic
12		* @license https://opensource.org/licenses/MIT MIT License
13		*/
14
15		declare(strict_types=1);
16
17		namespace Phauthentic\Infrastructure\Storage;
18
19		use InvalidArgumentException;
20		use League\Flysystem\AdapterInterface;
21		use League\Flysystem\Config;
22		use Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface;
23		use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantDoesNotExistException;
24		use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantException;
25		use Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface;
26		use RuntimeException;
27
28		/**
29		* File Storage
30		*/
31		class FileStorage implements FileStorageInterface
32		{
33		/**
34		* @var array
35		*/
36		protected array $callbacks = [
37		'beforeSave' => [],
38		'afterSave' => [],
39		'beforeRemove' => [],
40		'afterRemove' => [],
41		];
42
43		/**
44		* @var \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface\|null
45		*/
46		protected ?PathBuilderInterface $pathBuilder;
47
48		/**
49		* @var \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface\|null
50		*/
51		protected ?UrlBuilderInterface $urlBuilder;
52
53		/**
54		* @var \Phauthentic\Infrastructure\Storage\StorageServiceInterface
55		*/
56		protected StorageServiceInterface $storageService;
57
58		/**
59		* Constructor
60		*
61		* @param \Phauthentic\Infrastructure\Storage\StorageServiceInterface $storageService Storage Service
62		* @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface\|null $pathBuilder Path Builder
63		* @param \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface\|null $urlBuilder Path Builder
64	1	*/
65		public function __construct(
66		StorageServiceInterface $storageService,
67		?PathBuilderInterface $pathBuilder = null,
68		?UrlBuilderInterface $urlBuilder = null
69	1	) {
70	1	$this->storageService = $storageService;
71	1	$this->pathBuilder = $pathBuilder;
72	1	$this->urlBuilder = $urlBuilder;
73		}
74
75		/**
76		* @param string $name Name of the callback
77		* @return void
78	1	*/
79		protected function checkCallbackName(string $name): void
80	1	{
81		if (!array_key_exists($name, $this->callbacks)) {
82		throw new InvalidArgumentException(sprintf(
83		'Invalid callback `%s`, only %s are valid',
84		$name,
85		implode(', ', array_keys($this->callbacks))
86		));
87	1	}
88		}
89
90		/**
91		* Adds a callback
92		*
93		* @param string $name
94		* @param callable $callable Callable
95		* @return void
96		*/
97		public function addCallback($name, callable $callable): void
98		{
99		$this->checkCallbackName($name);
100		$this->callbacks[$name][] = $callable;
101		}
102
103		/**
104		* @param string $name Name of the callback
105		* @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
106		* @return \Phauthentic\Infrastructure\Storage\FileInterface
107	1	*/
108		public function runCallbacks(string $name, FileInterface $file): FileInterface
109	1	{
110		$this->checkCallbackName($name);
111	1
112		foreach ($this->callbacks[$name] as $callback) {
113		$file = $callback($file);
114		}
115	1
116		return $file;
117		}
118
119		/**
120		* @inheritDoc
121	1	* @throws \RuntimeException
122		*/
123	1	public function store(FileInterface $file, ?Config $config = null): FileInterface
124		{
125	1	if ($config === null) {
126	1	$config = new Config();
127		}
128
129	1	if ($this->pathBuilder !== null) {
130		$file = $file->buildPath($this->pathBuilder);
131		}
132
133	1	if ($this->urlBuilder !== null) {
134		$file = $file->buildUrl($this->urlBuilder);
135	1	}
136	1
137		$file = $this->runCallbacks('beforeSave', $file);
138	1
139		$storage = $this->getStorage($file->storage());
140		$resource = $file->resource();
141		if ($resource === null) {
142		throw new RuntimeException('No resource given');
143		}
144	1	$storage->writeStream($file->path(), $resource, $config);
145
146	1	return $this->runCallbacks('afterSave', $file);
147		}
148
149	1	/**
150		* @inheritDoc
151		*/
152		public function remove(FileInterface $file): FileInterface
153		{
154		$file = $this->runCallbacks('beforeRemove', $file);
155
156	1	// Delete all variants of the file
157		foreach ($file->variants() as $variant) {
158	1	if (!empty($variant['path'])) {
159		$this->getStorage($file->storage())->delete($variant['path']);
160		}
161		}
162
163		// Delete the file
164		$this->getStorage($file->storage())->delete($file->path());
165
166		return $this->runCallbacks('afterRemove', $file);
167		}
168
169		/**
170		* @inheritDoc
171		*/
172		public function removeVariant(FileInterface $file, string $name): FileInterface
173		{
174		if (!$file->hasVariant($name)) {
175		throw VariantDoesNotExistException::withName($name);
176		}
177
178		$variant = $file->variant($name);
179		if (empty($variant['path'])) {
180		throw new VariantException(sprintf(
181		'Variant `%s` is missing a path',
182		$name
183		));
184		}
185
186		$this->getStorage($file->storage())->delete($variant['path']);
187
188		$variants = $file->variants();
189		unset($variants[$name]);
190
191		return $file->withVariants($variants, false);
192	1	}
193
194	1	/**
195		* Gets the storage abstraction to use
196		*
197		* @param string $storage Storage name to use
198		* @return \League\Flysystem\AdapterInterface
199		*/
200		public function getStorage(string $storage): AdapterInterface
201		{
202		return $this->storageService->adapter($storage);
203		}
204		}
205

Phauthentic / file-storage

FileStorage::removeVariant() A last analyzed 2022-10-18 19:50 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

FileStorage::removeVariant() A
last analyzed 2022-10-18 19:50 UTC