FileStorage::runCallbacks() - Code Metrics - Inspection of "Adding callbacks back, improved documentation" - Phauthentic/file-storage - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7)

by Florian

created 2020-11-02 23:36 UTC

FileStorage::runCallbacks() A

↳ Parent: FileStorage

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.032

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	4
nc	2
nop	2
dl	0
loc	9
c	1
b	0
f	0
cc	2
ccs	4
cts	5
cp	0.8
crap	2.032
rs	10

<?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;

/**
 * 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
     */
    public function store(FileInterface $file): FileInterface
    {
        $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());
        $storage->writeStream($file->path(), $file->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
27		/**
28		* File Storage
29		*/
30		class FileStorage implements FileStorageInterface
31		{
32		/**
33		* @var array
34		*/
35		protected array $callbacks = [
36		'beforeSave' => [],
37		'afterSave' => [],
38		'beforeRemove' => [],
39		'afterRemove' => [],
40		];
41
42		/**
43		* @var \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface\|null
44		*/
45		protected ?PathBuilderInterface $pathBuilder;
46
47		/**
48		* @var \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface\|null
49		*/
50		protected ?UrlBuilderInterface $urlBuilder;
51
52		/**
53		* @var \Phauthentic\Infrastructure\Storage\StorageServiceInterface
54		*/
55		protected StorageServiceInterface $storageService;
56
57		/**
58		* Constructor
59		*
60		* @param \Phauthentic\Infrastructure\Storage\StorageServiceInterface $storageService Storage Service
61		* @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface\|null $pathBuilder Path Builder
62		* @param \Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface\|null $urlBuilder Path Builder
63		*/
64	1	public function __construct(
65		StorageServiceInterface $storageService,
66		?PathBuilderInterface $pathBuilder = null,
67		?UrlBuilderInterface $urlBuilder = null
68		) {
69	1	$this->storageService = $storageService;
70	1	$this->pathBuilder = $pathBuilder;
71	1	$this->urlBuilder = $urlBuilder;
72	1	}
73
74		/**
75		* @param string $name Name of the callback
76		* @return void
77		*/
78	1	protected function checkCallbackName(string $name): void
79		{
80	1	if (!array_key_exists($name, $this->callbacks)) {
81		throw new InvalidArgumentException(sprintf(
82		'Invalid callback `%s`, only %s are valid',
83		$name,
84		implode(', ', array_keys($this->callbacks))
85		));
86		}
87	1	}
88
89		/**
90		* Adds a callback
91		*
92		* @param string $name
93		* @param callable $callable Callable
94		* @return void
95		*/
96		public function addCallback($name, callable $callable): void
97		{
98		$this->checkCallbackName($name);
99		$this->callbacks[$name][] = $callable;
100		}
101
102		/**
103		* @param string $name Name of the callback
104		* @param \Phauthentic\Infrastructure\Storage\FileInterface $file File
105		* @return \Phauthentic\Infrastructure\Storage\FileInterface
106		*/
107	1	public function runCallbacks(string $name, FileInterface $file): FileInterface
108		{
109	1	$this->checkCallbackName($name);
110
111	1	foreach ($this->callbacks[$name] as $callback) {
112		$file = $callback($file);
113		}
114
115	1	return $file;
116		}
117
118		/**
119		* @inheritDoc
120		*/
121	1	public function store(FileInterface $file): FileInterface
122		{
123	1	$config = new Config();
124
125	1	if ($this->pathBuilder !== null) {
126	1	$file = $file->buildPath($this->pathBuilder);
127		}
128
129	1	if ($this->urlBuilder !== null) {
130		$file = $file->buildUrl($this->urlBuilder);
131		}
132
133	1	$file = $this->runCallbacks('beforeSave', $file);
134
135	1	$storage = $this->getStorage($file->storage());
136	1	$storage->writeStream($file->path(), $file->resource(), $config);
137
138	1	return $this->runCallbacks('afterSave', $file);
139		}
140
141		/**
142		* @inheritDoc
143		*/
144	1	public function remove(FileInterface $file): FileInterface
145		{
146	1	$file = $this->runCallbacks('beforeRemove', $file);
147
148		// Delete all variants of the file
149	1	foreach ($file->variants() as $variant) {
150		if (!empty($variant['path'])) {
151		$this->getStorage($file->storage())->delete($variant['path']);
152		}
153		}
154
155		// Delete the file
156	1	$this->getStorage($file->storage())->delete($file->path());
157
158	1	return $this->runCallbacks('afterRemove', $file);
159		}
160
161		/**
162		* @inheritDoc
163		*/
164		public function removeVariant(FileInterface $file, string $name): FileInterface
165		{
166		if (!$file->hasVariant($name)) {
167		throw VariantDoesNotExistException::withName($name);
168		}
169
170		$variant = $file->variant($name);
171		if (empty($variant['path'])) {
172		throw new VariantException(sprintf(
173		'Variant `%s` is missing a path',
174		$name
175		));
176		}
177
178		$this->getStorage($file->storage())->delete($variant['path']);
179
180		$variants = $file->variants();
181		unset($variants[$name]);
182
183		return $file->withVariants($variants, false);
184		}
185
186		/**
187		* Gets the storage abstraction to use
188		*
189		* @param string $storage Storage name to use
190		* @return \League\Flysystem\AdapterInterface
191		*/
192	1	public function getStorage(string $storage): AdapterInterface
193		{
194	1	return $this->storageService->adapter($storage);
195		}
196		}
197

Phauthentic / file-storage

Pull Request — master (#7)

FileStorage::runCallbacks() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like