FileStorage::store() - Code Metrics - Inspection of "PHPStan fixes and merge improvement for assoc." - Phauthentic/file-storage - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#9)

by mark

created 2020-11-04 00:23 UTC

FileStorage::store() A

↳ Parent: FileStorage

Complexity

Conditions	4
Paths	8

Size

Total Lines	22
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	4.0582

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	12
c	1
b	0
f	0
nc	8
nop	1
dl	0
loc	22
ccs	11
cts	13
cp	0.8462
crap	4.0582
rs	9.8666

<?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): 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());
        $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		*/
65	1	public function __construct(
66		StorageServiceInterface $storageService,
67		?PathBuilderInterface $pathBuilder = null,
68		?UrlBuilderInterface $urlBuilder = null
69		) {
70	1	$this->storageService = $storageService;
71	1	$this->pathBuilder = $pathBuilder;
72	1	$this->urlBuilder = $urlBuilder;
73	1	}
74
75		/**
76		* @param string $name Name of the callback
77		* @return void
78		*/
79	1	protected function checkCallbackName(string $name): void
80		{
81	1	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		}
88	1	}
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		*/
108	1	public function runCallbacks(string $name, FileInterface $file): FileInterface
109		{
110	1	$this->checkCallbackName($name);
111
112	1	foreach ($this->callbacks[$name] as $callback) {
113		$file = $callback($file);
114		}
115
116	1	return $file;
117		}
118
119		/**
120		* @inheritDoc
121		* @throws \RuntimeException
122		*/
123	1	public function store(FileInterface $file): FileInterface
124		{
125	1	$config = new Config();
126
127	1	if ($this->pathBuilder !== null) {
128	1	$file = $file->buildPath($this->pathBuilder);
129		}
130
131	1	if ($this->urlBuilder !== null) {
132		$file = $file->buildUrl($this->urlBuilder);
133		}
134
135	1	$file = $this->runCallbacks('beforeSave', $file);
136
137	1	$storage = $this->getStorage($file->storage());
138	1	$resource = $file->resource();
139	1	if ($resource === null) {
140		throw new RuntimeException('No resource given');
141		}
142	1	$storage->writeStream($file->path(), $resource, $config);
143
144	1	return $this->runCallbacks('afterSave', $file);
145		}
146
147		/**
148		* @inheritDoc
149		*/
150	1	public function remove(FileInterface $file): FileInterface
151		{
152	1	$file = $this->runCallbacks('beforeRemove', $file);
153
154		// Delete all variants of the file
155	1	foreach ($file->variants() as $variant) {
156		if (!empty($variant['path'])) {
157		$this->getStorage($file->storage())->delete($variant['path']);
158		}
159		}
160
161		// Delete the file
162	1	$this->getStorage($file->storage())->delete($file->path());
163
164	1	return $this->runCallbacks('afterRemove', $file);
165		}
166
167		/**
168		* @inheritDoc
169		*/
170		public function removeVariant(FileInterface $file, string $name): FileInterface
171		{
172		if (!$file->hasVariant($name)) {
173		throw VariantDoesNotExistException::withName($name);
174		}
175
176		$variant = $file->variant($name);
177		if (empty($variant['path'])) {
178		throw new VariantException(sprintf(
179		'Variant `%s` is missing a path',
180		$name
181		));
182		}
183
184		$this->getStorage($file->storage())->delete($variant['path']);
185
186		$variants = $file->variants();
187		unset($variants[$name]);
188
189		return $file->withVariants($variants, false);
190		}
191
192		/**
193		* Gets the storage abstraction to use
194		*
195		* @param string $storage Storage name to use
196		* @return \League\Flysystem\AdapterInterface
197		*/
198	1	public function getStorage(string $storage): AdapterInterface
199		{
200	1	return $this->storageService->adapter($storage);
201		}
202		}
203

Phauthentic / file-storage

Pull Request — develop (#9)

FileStorage::store() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like