UploadedFileFactory::asUploadedFileInstance() - Code Metrics - dmt-software/aura-web-psr - Measure and Improve Code Quality continuously with Scrutinizer

UploadedFileFactory::asUploadedFileInstance() A
last analyzed 2021-12-31 16:34 UTC

↳ Parent: UploadedFileFactory

Complexity

Conditions	3
Paths	3

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	3
eloc	12
c	1
b	0
f	1
nc	3
nop	1
dl	0
loc	18
ccs	12
cts	12
cp	1
crap	3
rs	9.8666

<?php

namespace DMT\Aura\Psr\Factory;

use DMT\Aura\Psr\Message\UploadedFile;
use InvalidArgumentException;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UploadedFileFactoryInterface;
use Psr\Http\Message\UploadedFileInterface;
use const UPLOAD_ERR_OK;

/**
 * Class UploadedFileFactory
 *
 * @package DMT\Aura\Psr\Factory
 */
class UploadedFileFactory implements UploadedFileFactoryInterface
{
    /** @var StreamFactoryInterface $streamFactory */
    protected $streamFactory;

    /**
     * UploadedFileFactory constructor.
     * @param StreamFactoryInterface $streamFactory
     */
    public function __construct(StreamFactoryInterface $streamFactory = null)
    {
        $this->streamFactory = $streamFactory ?? new StreamFactory();
    }

    /**
     * Create a new uploaded file.
     *
     * If a size is not provided it will be determined by checking the size of
     * the file.
     *
     * @see http://php.net/manual/features.file-upload.post-method.php
     * @see http://php.net/manual/features.file-upload.errors.php
     *
     * @param StreamInterface $stream Underlying stream representing the uploaded file content.
     * @param int $size in bytes
     * @param int $error PHP file upload error
     * @param string $clientFilename Filename as provided by the client, if any.
     * @param string $clientMediaType Media type as provided by the client, if any.
     *
     * @return UploadedFileInterface
     *
     * @throws InvalidArgumentException If the file resource is not readable.
     */
    public function createUploadedFile(
        StreamInterface $stream,
        int $size = null,
        int $error = UPLOAD_ERR_OK,
        string $clientFilename = null,
        string $clientMediaType = null
    ): UploadedFileInterface {
        if (!$stream->isReadable()) {
            throw new InvalidArgumentException('file can not be read');
        }

        return new UploadedFile($stream, $size, $error, $clientFilename, $clientMediaType);
    }

    /**
     * Create uploaded files from $_FILES.
     *
     * @param array $uploadedFiles
     * @return array|UploadedFileInterface[]
     */
    public function createUploadedFilesFromGlobalFiles(array $uploadedFiles): array
    {
        foreach ($uploadedFiles as $file => &$uploadedFile) {
            if (!is_array($uploadedFile) || !array_key_exists('tmp_name', $uploadedFile)) {
                continue;
            }

            if (is_array($uploadedFile['tmp_name'])) {
                $files = [];
                foreach ($uploadedFile as $key => $values) {
                    if (is_string(key($values))) {
                        $files[key($values)][$key] = current($values);
                    }
                }
                if ($files) {
                    $uploadedFile = $this->createUploadedFilesFromGlobalFiles($files);
                }
            }

            if ($this->isUploadedFileEntry($uploadedFile)) {
                $uploadedFile = $this->asUploadedFileInstance($uploadedFile);
            }
        }

        return $uploadedFiles;
    }

    /**
     * @param array $uploadedFileEntry
     * @return bool
     */
    private function isUploadedFileEntry($uploadedFileEntry): bool
    {
        if (!is_array($uploadedFileEntry) || !array_key_exists('tmp_name', $uploadedFileEntry)) {

            return false;
        }

        return is_string($uploadedFileEntry['tmp_name']) || is_string(current((array)$uploadedFileEntry['tmp_name']));
    }

    /**
     * @param array $uploadedFile
     * @return array|UploadedFileInterface
     */
    private function asUploadedFileInstance($uploadedFile)
    {
        if (is_array($uploadedFile['tmp_name'])) {
            return array_map([$this, __FUNCTION__], $this->normalizeUploadedFileArray($uploadedFile));
        }

        if ($uploadedFile['error'] === UPLOAD_ERR_OK) {
            $stream = $this->streamFactory->createStreamFromFile($uploadedFile['tmp_name']);
        } else {
            $stream = $this->streamFactory->createStream();
        }

        return $this->createUploadedFile(
            $stream,
            $uploadedFile['size'] ?? null,
            $uploadedFile['error'] ?? UPLOAD_ERR_OK,
            $uploadedFile['name'] ?? null,
            $uploadedFile['type'] ?? null
        );
    }

    /**
     * @param array $uploadedFile
     * @return array
     */
    private function normalizeUploadedFileArray(array $uploadedFile)
    {
        if (!is_string($uploadedFile['tmp_name'])) {
            $files = [];
            for ($i = 0; $i < count($uploadedFile['tmp_name']); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                $files[$i] = [];
                foreach ($uploadedFile as $key => $value) {
                    $files[$i][$key] = $value[$i] ?? null;
                }
            }
            $uploadedFile = $files;
        }

        return $uploadedFile;
    }
}


1		<?php
2
3		namespace DMT\Aura\Psr\Factory;
4
5		use DMT\Aura\Psr\Message\UploadedFile;
6		use InvalidArgumentException;
7		use Psr\Http\Message\StreamFactoryInterface;
8		use Psr\Http\Message\StreamInterface;
9		use Psr\Http\Message\UploadedFileFactoryInterface;
10		use Psr\Http\Message\UploadedFileInterface;
11		use const UPLOAD_ERR_OK;
12
13		/**
14		* Class UploadedFileFactory
15		*
16		* @package DMT\Aura\Psr\Factory
17		*/
18		class UploadedFileFactory implements UploadedFileFactoryInterface
19		{
20		/** @var StreamFactoryInterface $streamFactory */
21		protected $streamFactory;
22
23		/**
24		* UploadedFileFactory constructor.
25		* @param StreamFactoryInterface $streamFactory
26		*/
27	16	public function __construct(StreamFactoryInterface $streamFactory = null)
28		{
29	16	$this->streamFactory = $streamFactory ?? new StreamFactory();
30	16	}
31
32		/**
33		* Create a new uploaded file.
34		*
35		* If a size is not provided it will be determined by checking the size of
36		* the file.
37		*
38		* @see http://php.net/manual/features.file-upload.post-method.php
39		* @see http://php.net/manual/features.file-upload.errors.php
40		*
41		* @param StreamInterface $stream Underlying stream representing the uploaded file content.
42		* @param int $size in bytes
43		* @param int $error PHP file upload error
44		* @param string $clientFilename Filename as provided by the client, if any.
45		* @param string $clientMediaType Media type as provided by the client, if any.
46		*
47		* @return UploadedFileInterface
48		*
49		* @throws InvalidArgumentException If the file resource is not readable.
50		*/
51	16	public function createUploadedFile(
52		StreamInterface $stream,
53		int $size = null,
54		int $error = UPLOAD_ERR_OK,
55		string $clientFilename = null,
56		string $clientMediaType = null
57		): UploadedFileInterface {
58	16	if (!$stream->isReadable()) {
59	1	throw new InvalidArgumentException('file can not be read');
60		}
61
62	15	return new UploadedFile($stream, $size, $error, $clientFilename, $clientMediaType);
63		}
64
65		/**
66		* Create uploaded files from $_FILES.
67		*
68		* @param array $uploadedFiles
69		* @return array\|UploadedFileInterface[]
70		*/
71	4	public function createUploadedFilesFromGlobalFiles(array $uploadedFiles): array
72		{
73	4	foreach ($uploadedFiles as $file => &$uploadedFile) {
74	4	if (!is_array($uploadedFile) \|\| !array_key_exists('tmp_name', $uploadedFile)) {
75		continue;
76		}
77
78	4	if (is_array($uploadedFile['tmp_name'])) {
79	2	$files = [];
80	2	foreach ($uploadedFile as $key => $values) {
81	2	if (is_string(key($values))) {
82	2	$files[key($values)][$key] = current($values);
83		}
84		}
85	2	if ($files) {
86	1	$uploadedFile = $this->createUploadedFilesFromGlobalFiles($files);
87		}
88		}
89
90	4	if ($this->isUploadedFileEntry($uploadedFile)) {
91	4	$uploadedFile = $this->asUploadedFileInstance($uploadedFile);
92		}
93		}
94
95	4	return $uploadedFiles;
96		}
97
98		/**
99		* @param array $uploadedFileEntry
100		* @return bool
101		*/
102	4	private function isUploadedFileEntry($uploadedFileEntry): bool
103		{
104	4	if (!is_array($uploadedFileEntry) \|\| !array_key_exists('tmp_name', $uploadedFileEntry)) {
		0 ignored issues – show introduced 2021-02-15 21:54 UTC by Report Bug Copy Issue Report The condition `is_array($uploadedFileEntry)` is always `true`. Loading history...
105	1	return false;
106		}
107
108	4	return is_string($uploadedFileEntry['tmp_name']) \|\| is_string(current((array)$uploadedFileEntry['tmp_name']));
109		}
110
111		/**
112		* @param array $uploadedFile
113		* @return array\|UploadedFileInterface
114		*/
115	4	private function asUploadedFileInstance($uploadedFile)
116		{
117	4	if (is_array($uploadedFile['tmp_name'])) {
118	1	return array_map([$this, __FUNCTION__], $this->normalizeUploadedFileArray($uploadedFile));
119		}
120
121	4	if ($uploadedFile['error'] === UPLOAD_ERR_OK) {
122	3	$stream = $this->streamFactory->createStreamFromFile($uploadedFile['tmp_name']);
123		} else {
124	1	$stream = $this->streamFactory->createStream();
125		}
126
127	4	return $this->createUploadedFile(
128	4	$stream,
129	4	$uploadedFile['size'] ?? null,
130	4	$uploadedFile['error'] ?? UPLOAD_ERR_OK,
131	4	$uploadedFile['name'] ?? null,
132	4	$uploadedFile['type'] ?? null
133		);
134		}
135
136		/**
137		* @param array $uploadedFile
138		* @return array
139		*/
140	1	private function normalizeUploadedFileArray(array $uploadedFile)
141		{
142	1	if (!is_string($uploadedFile['tmp_name'])) {
143	1	$files = [];
144	1	for ($i = 0; $i < count($uploadedFile['tmp_name']); $i++) {
		0 ignored issues – show Performance Best Practice introduced 2021-02-15 21:54 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
145	1	$files[$i] = [];
146	1	foreach ($uploadedFile as $key => $value) {
147	1	$files[$i][$key] = $value[$i] ?? null;
148		}
149		}
150	1	$uploadedFile = $files;
151		}
152
153	1	return $uploadedFile;
154		}
155		}
156

dmt-software / aura-web-psr

UploadedFileFactory::asUploadedFileInstance() A last analyzed 2021-12-31 16:34 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

UploadedFileFactory::asUploadedFileInstance() A
last analyzed 2021-12-31 16:34 UTC