File::withoutMetadataElement() - Code Metrics - Inspection of "Read metadata key." - Phauthentic/file-storage - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#12)

by mark

created 2020-11-12 01:50 UTC

File::withoutMetadataElement() A

↳ Parent: File

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	6
ccs	4
cts	4
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?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 Phauthentic\Infrastructure\Storage\Exception\InvalidStreamResourceException;
use Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface;
use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantDoesNotExistException;
use Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface;
use RuntimeException;

/**
 * File
 */
class File implements FileInterface
{
    /**
     * @var int
     */
    protected int $id;

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

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

    /**
     * @var int
     */
    protected int $filesize;

    /**
     * @var string
     */
    protected string $mimeType = '';

    /**
     * @var string|null
     */
    protected ?string $extension = null;

    /**
     * @var string|null
     */
    protected ?string $path = null;

    /**
     * @var string|null
     */
    protected ?string $collection = null;

    /**
     * @var string
     */
    protected string $storage = 'local';

    /**
     * @var array
     */
    protected array $metadata = [];

    /**
     * @var string|null
     */
    protected ?string $model = null;

    /**
     * @var string|null
     */
    protected ?string $modelId = null;

    /**
     * Source file to be stored in our system
     *
     * @var mixed
     */
    protected $sourceFile;

    /**
     * @var resource
     */
    protected $resource;

    /**
     * @var string
     */
    protected string $url = '';

    /**
     * @var array
     */
    protected array $variants = [];

    /**
     * Creates a new instance
     *
     * @param string $filename Filename
     * @param int $filesize Filesize
     * @param string $mimeType Mime Type
     * @param string $storage Storage config name
     * @param string|null $collection Collection name
     * @param string|null $model Model name
     * @param string|null $modelId Model id
     * @param array $variants Variants
     * @param array $metadata Meta data
     * @param resource|null $resource
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public static function create(
        string $filename,
        int $filesize,
        string $mimeType,
        string $storage,
        ?string $collection = null,
        ?string $model = null,
        ?string $modelId = null,
        array $metadata = [],
        array $variants = [],
        $resource = null
    ): FileInterface {
        $that = new self();

        $that->filename = $filename;
        $that->filesize = $filesize;
        $that->mimeType = $mimeType;
        $that->storage = $storage;
        $that->model = $model;
        $that->modelId = $modelId;
        $that->collection = $collection;
        $that->variants = $variants;
        $that->metadata = $metadata;

        $extension = pathinfo($filename, PATHINFO_EXTENSION);
        $that->extension = empty($extension) ? null : (string)$extension;

        if ($resource !== null) {
            $that = $that->withResource($resource);
        }

        return $that;
    }

    /**
     * Storage name
     *
     * @return string
     */
    public function storage(): string
    {
        return $this->storage;
    }

    /**
     * UUID of the file
     *
     * @param string $uuid UUID string
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withUuid(string $uuid): FileInterface
    {
        $that = clone $this;
        $that->uuid = $uuid;

        return $that;
    }

    /**
     * Stream resource that should be stored
     *
     * @return resource|null
     */
    public function resource()
    {
        return $this->resource;
    }

    /**
     * Same as withResource() but takes a file path
     *
     * @param string $file File
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withFile(string $file): FileInterface
    {
        $resource = fopen($file, 'rb');

        return $this->withResource($resource);
    }

    /**
     * @param mixed $resource
     * @return void
     */
    protected function assertStreamResource($resource): void
    {
        if (
            !is_resource($resource)
            || get_resource_type($resource) !== 'stream'
        ) {
            throw InvalidStreamResourceException::create();
        }
    }

    /**
     * Stream resource of the file to be stored
     *
     * @param resource $resource Stream Resource
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withResource($resource): FileInterface
    {
        $this->assertStreamResource($resource);

        $that = clone $this;
        $that->resource = $resource;

        return $that;
    }

    /**
     * Assign a model and model id to a file
     *
     * @param string $model Model
     * @param string|int $modelId Model ID, UUID string or integer
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function belongsToModel(string $model, $modelId): FileInterface
    {
        $this->model = $model;
        $this->modelId = (string)$modelId;

        return $this;
    }

    /**
     * Adds the file to a collection
     *
     * @param string $collection Collection
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function addToCollection(string $collection): FileInterface
    {
        $this->collection = $collection;

        return $this;
    }

    /**
     * Sets the path, immutable
     *
     * @param string $path Path to the file
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withPath(string $path): FileInterface
    {
        $that = clone $this;
        $that->path = $path;

        return $that;
    }

    /**
     * Filename
     *
     * @param string $filename Filename
     * @return self
     */
    public function withFilename(string $filename): self
    {
        $that = clone $this;
        $that->filename = $filename;

        $extension = pathinfo($filename, PATHINFO_EXTENSION);
        $that->extension = empty($extension) ? null : (string)$extension;

        return $that;
    }

    /**
     * The collections name this file belongs into
     *
     * @return string|null
     */
    public function collection(): ?string
    {
        return $this->collection;
    }

    /**
     * Model name
     *
     * @return string|null
     */
    public function model(): ?string
    {
        return $this->model;
    }

    /**
     * Model ID
     *
     * @return string|null
     */
    public function modelId(): ?string
    {
        return $this->modelId;
    }

    /**
     * Size of the file in bytes
     *
     * @return int
     */
    public function filesize(): int
    {
        return $this->filesize;
    }

    /**
     * Returns a human readable file size
     *
     * @return string
     */
    public function readableSize(): string
    {
        $i = floor(log($this->filesize, 1024));
        $round = (string)round($this->filesize / (1024 ** $i), [0, 0, 2, 2, 3][$i]);

        return $round . ['B','kB','MB','GB','TB'][$i];
    }

    /**
     * @return string|null
     */
    public function extension(): ?string
    {
        return $this->extension;
    }

    /**
     * @return string
     */
    public function mimeType(): string
    {
        return $this->mimeType;
    }

    /**
     * @return string
     */
    public function filename(): string
    {
        return $this->filename;
    }

    /**
     * @return string
     */
    public function uuid(): string
    {
        return $this->uuid;
    }

    /**
     * @return string
     */
    public function path(): string
    {
        if ($this->path === null) {
            throw new RuntimeException(
                'Path has not been set'
            );
        }

        return $this->path;
    }

    /**
     * Builds the path for this file
     *
     * @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface $pathBuilder Path Builder
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function buildPath(PathBuilderInterface $pathBuilder): FileInterface
    {
        $that = clone $this;
        $that->path = $pathBuilder->path($this);

        return $that;
    }

    /**
     * @param array $metadata Meta data
     * @param bool $overwrite Overwrite whole metadata instead of assoc merging.
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withMetadata(array $metadata, bool $overwrite = false): FileInterface
    {
        $that = clone $this;
        if ($overwrite) {
            $that->metadata = $metadata;
        } else {
            $that->metadata = $metadata + $that->metadata;
        }

        return $that;
    }

    /**
     * @param string $name Name
     * @param mixed $data Data
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withMetadataElement(string $name, $data): FileInterface
    {
        $that = clone $this;
        $that->metadata[$name] = $data;

        return $that;
    }

    /**
     * @param string $name Name
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withoutMetadataElement(string $name): FileInterface
    {
        $that = clone $this;
        unset($that->metadata[$name]);

        return $that;
    }

    /**
     * @return $this
     */
    public function withoutMetadata(): self
    {
        $that = clone $this;
        $that->metadata = [];

        return $that;
    }

    /**
     * @return array
     */
    public function metadata(): array
    {
        return $this->metadata;
    }

    /**
     * @param string $key
     *
     * @throws \RuntimeException
     *
     * @return mixed
     */
    public function metadataElement(string $key)
    {
        if (!isset($this->metadata[$key])) {
            throw new RuntimeException(
                'Metadata key does not exist'
            );
        }

        return $this->metadata[$key];
    }

    /**
     * @return bool
     */
    public function hasVariants(): bool
    {
        return !empty($this->variants);
    }

    /**
     * @param string $name Name
     * @return bool
     */
    public function hasVariant(string $name): bool
    {
        return isset($this->variants[$name]);
    }

    /**
     * @return array
     */
    public function variants(): array
    {
        return $this->variants;
    }

    /**
     * Returns a variant by name
     *
     * @param string $name Name
     * @return array
     */
    public function variant(string $name): array
    {
        if (!isset($this->variants[$name])) {
            throw VariantDoesNotExistException::withName($name);
        }

        return $this->variants[$name];
    }

    /**
     * Adds a variant
     *
     * @param string $name Name
     * @param array $data Data
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withVariant(string $name, array $data): FileInterface
    {
        $that = clone $this;
        $that->variants[$name] = $data;

        return $that;
    }

    /**
     * Gets the paths for all variants
     *
     * @return array
     */
    public function variantPaths(): array
    {
        $paths = [];
        foreach ($this->variants as $variant => $data) {
            if (isset($data['path'])) {
                $paths[$variant] = $data['path'];
            }
        }

        return $paths;
    }

    /**
     * Sets many variants at once
     *
     * @param array $variants Variants
     * @param bool $merge Merge Variants, default is true
     * @return \Phauthentic\Infrastructure\Storage\FileInterface
     */
    public function withVariants(array $variants, bool $merge = true): FileInterface
    {
        $that = clone $this;
        $that->variants = array_merge_recursive(
            $merge ? $that->variants : [],
            $variants
        );

        return $that;
    }

    /**
     * @inheritDoc
     */
    public function buildUrl(UrlBuilderInterface $urlBuilder): FileInterface
    {
        $this->url = $urlBuilder->url($this);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function url(): string
    {
        return $this->url;
    }

    /**
     * @inheritDoc
     */
    public function withUrl(string $url): FileInterface
    {
        $that = clone $this;
        $that->url = $url;

        return $that;
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return [
            'uuid' => $this->uuid,
            'filename' => $this->filename,
            'filesize' => $this->filesize,
            'mimeType' => $this->mimeType,
            'extension' => $this->extension,
            'path' => $this->path,
            'model' => $this->model,
            'modelId' => $this->modelId,
            'collection' => $this->collection,
            'readableSize' => $this->readableSize(),
            'variants' => $this->variants,
            'metadata' => $this->metadata,
            'url' => $this->url
        ];
    }

    /**
     * @inheritDoc
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }
}


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 Phauthentic\Infrastructure\Storage\Exception\InvalidStreamResourceException;
20		use Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface;
21		use Phauthentic\Infrastructure\Storage\Processor\Exception\VariantDoesNotExistException;
22		use Phauthentic\Infrastructure\Storage\UrlBuilder\UrlBuilderInterface;
23		use RuntimeException;
24
25		/**
26		* File
27		*/
28		class File implements FileInterface
29		{
30		/**
31		* @var int
32		*/
33		protected int $id;
34
35		/**
36		* @var string
37		*/
38		protected string $uuid;
39
40		/**
41		* @var string
42		*/
43		protected string $filename;
44
45		/**
46		* @var int
47		*/
48		protected int $filesize;
49
50		/**
51		* @var string
52		*/
53		protected string $mimeType = '';
54
55		/**
56		* @var string\|null
57		*/
58		protected ?string $extension = null;
59
60		/**
61		* @var string\|null
62		*/
63		protected ?string $path = null;
64
65		/**
66		* @var string\|null
67		*/
68		protected ?string $collection = null;
69
70		/**
71		* @var string
72		*/
73		protected string $storage = 'local';
74
75		/**
76		* @var array
77		*/
78		protected array $metadata = [];
79
80		/**
81		* @var string\|null
82		*/
83		protected ?string $model = null;
84
85		/**
86		* @var string\|null
87		*/
88		protected ?string $modelId = null;
89
90		/**
91		* Source file to be stored in our system
92		*
93		* @var mixed
94		*/
95		protected $sourceFile;
96
97		/**
98		* @var resource
99		*/
100		protected $resource;
101
102		/**
103		* @var string
104		*/
105		protected string $url = '';
106
107		/**
108		* @var array
109		*/
110		protected array $variants = [];
111
112		/**
113		* Creates a new instance
114		*
115		* @param string $filename Filename
116		* @param int $filesize Filesize
117		* @param string $mimeType Mime Type
118		* @param string $storage Storage config name
119		* @param string\|null $collection Collection name
120		* @param string\|null $model Model name
121		* @param string\|null $modelId Model id
122		* @param array $variants Variants
123		* @param array $metadata Meta data
124		* @param resource\|null $resource
125		* @return \Phauthentic\Infrastructure\Storage\FileInterface
126		*/
127	12	public static function create(
128		string $filename,
129		int $filesize,
130		string $mimeType,
131		string $storage,
132		?string $collection = null,
133		?string $model = null,
134		?string $modelId = null,
135		array $metadata = [],
136		array $variants = [],
137		$resource = null
138		): FileInterface {
139	12	$that = new self();
140
141	12	$that->filename = $filename;
142	12	$that->filesize = $filesize;
143	12	$that->mimeType = $mimeType;
144	12	$that->storage = $storage;
145	12	$that->model = $model;
146	12	$that->modelId = $modelId;
147	12	$that->collection = $collection;
148	12	$that->variants = $variants;
149	12	$that->metadata = $metadata;
150
151	12	$extension = pathinfo($filename, PATHINFO_EXTENSION);
152	12	$that->extension = empty($extension) ? null : (string)$extension;
153
154	12	if ($resource !== null) {
155		$that = $that->withResource($resource);
156		}
157
158	12	return $that;
159		}
160
161		/**
162		* Storage name
163		*
164		* @return string
165		*/
166	1	public function storage(): string
167		{
168	1	return $this->storage;
169		}
170
171		/**
172		* UUID of the file
173		*
174		* @param string $uuid UUID string
175		* @return \Phauthentic\Infrastructure\Storage\FileInterface
176		*/
177	8	public function withUuid(string $uuid): FileInterface
178		{
179	8	$that = clone $this;
180	8	$that->uuid = $uuid;
181
182	8	return $that;
183		}
184
185		/**
186		* Stream resource that should be stored
187		*
188		* @return resource\|null
189		*/
190	2	public function resource()
191		{
192	2	return $this->resource;
193		}
194
195		/**
196		* Same as withResource() but takes a file path
197		*
198		* @param string $file File
199		* @return \Phauthentic\Infrastructure\Storage\FileInterface
200		*/
201		public function withFile(string $file): FileInterface
202		{
203		$resource = fopen($file, 'rb');
204
205		return $this->withResource($resource);
206		}
207
208		/**
209		* @param mixed $resource
210		* @return void
211		*/
212	11	protected function assertStreamResource($resource): void
213		{
214		if (
215	11	!is_resource($resource)
216	11	\|\| get_resource_type($resource) !== 'stream'
217		) {
218		throw InvalidStreamResourceException::create();
219		}
220	11	}
221
222		/**
223		* Stream resource of the file to be stored
224		*
225		* @param resource $resource Stream Resource
226		* @return \Phauthentic\Infrastructure\Storage\FileInterface
227		*/
228	11	public function withResource($resource): FileInterface
229		{
230	11	$this->assertStreamResource($resource);
231
232	11	$that = clone $this;
233	11	$that->resource = $resource;
234
235	11	return $that;
236		}
237
238		/**
239		* Assign a model and model id to a file
240		*
241		* @param string $model Model
242		* @param string\|int $modelId Model ID, UUID string or integer
243		* @return \Phauthentic\Infrastructure\Storage\FileInterface
244		*/
245	6	public function belongsToModel(string $model, $modelId): FileInterface
246		{
247	6	$this->model = $model;
248	6	$this->modelId = (string)$modelId;
249
250	6	return $this;
251		}
252
253		/**
254		* Adds the file to a collection
255		*
256		* @param string $collection Collection
257		* @return \Phauthentic\Infrastructure\Storage\FileInterface
258		*/
259	3	public function addToCollection(string $collection): FileInterface
260		{
261	3	$this->collection = $collection;
262
263	3	return $this;
264		}
265
266		/**
267		* Sets the path, immutable
268		*
269		* @param string $path Path to the file
270		* @return \Phauthentic\Infrastructure\Storage\FileInterface
271		*/
272	1	public function withPath(string $path): FileInterface
273		{
274	1	$that = clone $this;
275	1	$that->path = $path;
276
277	1	return $that;
278		}
279
280		/**
281		* Filename
282		*
283		* @param string $filename Filename
284		* @return self
285		*/
286	2	public function withFilename(string $filename): self
287		{
288	2	$that = clone $this;
289	2	$that->filename = $filename;
290
291	2	$extension = pathinfo($filename, PATHINFO_EXTENSION);
292	2	$that->extension = empty($extension) ? null : (string)$extension;
293
294	2	return $that;
295		}
296
297		/**
298		* The collections name this file belongs into
299		*
300		* @return string\|null
301		*/
302	7	public function collection(): ?string
303		{
304	7	return $this->collection;
305		}
306
307		/**
308		* Model name
309		*
310		* @return string\|null
311		*/
312	8	public function model(): ?string
313		{
314	8	return $this->model;
315		}
316
317		/**
318		* Model ID
319		*
320		* @return string\|null
321		*/
322	7	public function modelId(): ?string
323		{
324	7	return $this->modelId;
325		}
326
327		/**
328		* Size of the file in bytes
329		*
330		* @return int
331		*/
332	1	public function filesize(): int
333		{
334	1	return $this->filesize;
335		}
336
337		/**
338		* Returns a human readable file size
339		*
340		* @return string
341		*/
342	1	public function readableSize(): string
343		{
344	1	$i = floor(log($this->filesize, 1024));
345	1	$round = (string)round($this->filesize / (1024 ** $i), [0, 0, 2, 2, 3][$i]);
346
347	1	return $round . ['B','kB','MB','GB','TB'][$i];
348		}
349
350		/**
351		* @return string\|null
352		*/
353	7	public function extension(): ?string
354		{
355	7	return $this->extension;
356		}
357
358		/**
359		* @return string
360		*/
361	7	public function mimeType(): string
362		{
363	7	return $this->mimeType;
364		}
365
366		/**
367		* @return string
368		*/
369	7	public function filename(): string
370		{
371	7	return $this->filename;
372		}
373
374		/**
375		* @return string
376		*/
377	7	public function uuid(): string
378		{
379	7	return $this->uuid;
380		}
381
382		/**
383		* @return string
384		*/
385	4	public function path(): string
386		{
387	4	if ($this->path === null) {
388	1	throw new RuntimeException(
389	1	'Path has not been set'
390		);
391		}
392
393	3	return $this->path;
394		}
395
396		/**
397		* Builds the path for this file
398		*
399		* @param \Phauthentic\Infrastructure\Storage\PathBuilder\PathBuilderInterface $pathBuilder Path Builder
400		* @return \Phauthentic\Infrastructure\Storage\FileInterface
401		*/
402	3	public function buildPath(PathBuilderInterface $pathBuilder): FileInterface
403		{
404	3	$that = clone $this;
405	3	$that->path = $pathBuilder->path($this);
406
407	3	return $that;
408		}
409
410		/**
411		* @param array $metadata Meta data
412		* @param bool $overwrite Overwrite whole metadata instead of assoc merging.
413		* @return \Phauthentic\Infrastructure\Storage\FileInterface
414		*/
415	1	public function withMetadata(array $metadata, bool $overwrite = false): FileInterface
416		{
417	1	$that = clone $this;
418	1	if ($overwrite) {
419		$that->metadata = $metadata;
420		} else {
421	1	$that->metadata = $metadata + $that->metadata;
422		}
423
424	1	return $that;
425		}
426
427		/**
428		* @param string $name Name
429		* @param mixed $data Data
430		* @return \Phauthentic\Infrastructure\Storage\FileInterface
431		*/
432	2	public function withMetadataElement(string $name, $data): FileInterface
433		{
434	2	$that = clone $this;
435	2	$that->metadata[$name] = $data;
436
437	2	return $that;
438		}
439
440		/**
441		* @param string $name Name
442		* @return \Phauthentic\Infrastructure\Storage\FileInterface
443		*/
444	1	public function withoutMetadataElement(string $name): FileInterface
445		{
446	1	$that = clone $this;
447	1	unset($that->metadata[$name]);
448
449	1	return $that;
450		}
451
452		/**
453		* @return $this
454		*/
455	1	public function withoutMetadata(): self
456		{
457	1	$that = clone $this;
458	1	$that->metadata = [];
459
460	1	return $that;
461		}
462
463		/**
464		* @return array
465		*/
466	1	public function metadata(): array
467		{
468	1	return $this->metadata;
469		}
470
471		/**
472		* @param string $key
473		*
474		* @throws \RuntimeException
475		*
476		* @return mixed
477		*/
478		public function metadataElement(string $key)
479		{
480		if (!isset($this->metadata[$key])) {
481		throw new RuntimeException(
482		'Metadata key does not exist'
483		);
484		}
485
486		return $this->metadata[$key];
487		}
488
489		/**
490		* @return bool
491		*/
492	1	public function hasVariants(): bool
493		{
494	1	return !empty($this->variants);
495		}
496
497		/**
498		* @param string $name Name
499		* @return bool
500		*/
501	1	public function hasVariant(string $name): bool
502		{
503	1	return isset($this->variants[$name]);
504		}
505
506		/**
507		* @return array
508		*/
509	3	public function variants(): array
510		{
511	3	return $this->variants;
512		}
513
514		/**
515		* Returns a variant by name
516		*
517		* @param string $name Name
518		* @return array
519		*/
520		public function variant(string $name): array
521		{
522		if (!isset($this->variants[$name])) {
523		throw VariantDoesNotExistException::withName($name);
524		}
525
526		return $this->variants[$name];
527		}
528
529		/**
530		* Adds a variant
531		*
532		* @param string $name Name
533		* @param array $data Data
534		* @return \Phauthentic\Infrastructure\Storage\FileInterface
535		*/
536	1	public function withVariant(string $name, array $data): FileInterface
537		{
538	1	$that = clone $this;
539	1	$that->variants[$name] = $data;
540
541	1	return $that;
542		}
543
544		/**
545		* Gets the paths for all variants
546		*
547		* @return array
548		*/
549		public function variantPaths(): array
550		{
551		$paths = [];
552		foreach ($this->variants as $variant => $data) {
553		if (isset($data['path'])) {
554		$paths[$variant] = $data['path'];
555		}
556		}
557
558		return $paths;
559		}
560
561		/**
562		* Sets many variants at once
563		*
564		* @param array $variants Variants
565		* @param bool $merge Merge Variants, default is true
566		* @return \Phauthentic\Infrastructure\Storage\FileInterface
567		*/
568	2	public function withVariants(array $variants, bool $merge = true): FileInterface
569		{
570	2	$that = clone $this;
571	2	$that->variants = array_merge_recursive(
572	2	$merge ? $that->variants : [],
573		$variants
574		);
575
576	2	return $that;
577		}
578
579		/**
580		* @inheritDoc
581		*/
582		public function buildUrl(UrlBuilderInterface $urlBuilder): FileInterface
583		{
584		$this->url = $urlBuilder->url($this);
585
586		return $this;
587		}
588
589		/**
590		* @inheritDoc
591		*/
592		public function url(): string
593		{
594		return $this->url;
595		}
596
597		/**
598		* @inheritDoc
599		*/
600		public function withUrl(string $url): FileInterface
601		{
602		$that = clone $this;
603		$that->url = $url;
604
605		return $that;
606		}
607
608		/**
609		* @return array
610		*/
611	1	public function toArray(): array
612		{
613		return [
614	1	'uuid' => $this->uuid,
615	1	'filename' => $this->filename,
616	1	'filesize' => $this->filesize,
617	1	'mimeType' => $this->mimeType,
618	1	'extension' => $this->extension,
619	1	'path' => $this->path,
620	1	'model' => $this->model,
621	1	'modelId' => $this->modelId,
622	1	'collection' => $this->collection,
623	1	'readableSize' => $this->readableSize(),
624	1	'variants' => $this->variants,
625	1	'metadata' => $this->metadata,
626	1	'url' => $this->url
627		];
628		}
629
630		/**
631		* @inheritDoc
632		*/
633	1	public function jsonSerialize()
634		{
635	1	return $this->toArray();
636		}
637		}
638

Phauthentic / file-storage

Pull Request — develop (#12)

File::withoutMetadataElement() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like