UploadedFileHelper::uploadedFileArrayTrim() - Code Metrics - terrylinooo/psr-http - Measure and Improve Code Quality continuously with Scrutinizer

UploadedFileHelper::uploadedFileArrayTrim() A
last analyzed 2023-06-06 08:32 UTC

↳ Parent: UploadedFileHelper

Complexity

Conditions	4
Paths	2

Size

Total Lines	20
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	9
c	1
b	0
f	0
dl	0
loc	20
ccs	9
cts	9
cp	1
rs	9.9666
cc	4
nc	2
nop	1
crap	4

<?php 
/**
 * This file is part of the Shieldon package.
 *
 * (c) Terry L. <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Shieldon\Psr7\Utils;

use Shieldon\Psr7\UploadedFile;

use function array_merge_recursive;
use function rtrim;
use function is_array;
use function is_string;
use function is_numeric;

/*
 * The helper functions for converting $_FILES to an array of UploadedFile
 * instance, only used on ServerRequest class.
 * This class is not a part of PSR 7.
 */
class UploadedFileHelper
{
/**
     * Create an array for PSR-7 Uploaded File needed.
     * 
     * @param array $files     An array generally from $_FILES
     * @param bool  $isConvert To covert and return $files as an UploadedFile instance.
     * 
     * @return array|UploadedFile
     */
    public static function uploadedFileParse(array $files)
    {
        $specTree = [];

        $specFields = [
            0 => 'tmp_name',
            1 => 'name',
            2 => 'type',
            3 => 'size',
            4 => 'error',
        ];

        foreach ($files as $fileKey => $fileValue) {
            if (!isset($fileValue['tmp_name'])) {
                // @codeCoverageIgnoreStart
                return [];
                // @codeCoverageIgnoreEnd
            }

            if (is_string($fileValue['tmp_name']) || is_numeric($fileValue['tmp_name'])) {
                $specTree[$fileKey] = $fileValue;

            } elseif (is_array($fileValue['tmp_name'])) {

                $tmp = [];

                // We want to find out how many levels of array it has.
                foreach ($specFields as $i => $attr) {
                    $tmp[$i] = self::uploadedFileNestedFields($fileValue, $attr);
                }

                $parsedTree = array_merge_recursive(
                    $tmp[0], // tmp_name
                    $tmp[1], // name
                    $tmp[2], // type
                    $tmp[3], // size
                    $tmp[4]  // error
                );
  
                $specTree[$fileKey] = $parsedTree;
                unset($tmp, $parsedTree);
            }
        }

        return self::uploadedFileArrayTrim($specTree);
    }

    /**
     * Find out how many levels of an array it has.
     *
     * @param array  $files Data structure from $_FILES.
     * @param string $attr  The attributes of a file.
     *
     * @return array
     */
    public static function uploadedFileNestedFields(array $files, string $attr): array
    {
        $result = [];
        $values = $files;

        if (isset($files[$attr])) {
            $values = $files[$attr];
        }

        foreach ($values as $key => $value) {

            /**
             * Hereby to add `_` to be a part of the key for letting `array_merge_recursive`
             * method can deal with numeric keys as string keys. 
             * It will be restored in the next step.
             *
             * @see uploadedFileArrayTrim
             */
            if (is_numeric($key)) {
                $key .= '_';
            }

            if (is_array($value)) {
                $result[$key] = self::uploadedFileNestedFields($value, $attr);
            } else {
                $result[$key][$attr] = $value;
            }
        }

        return $result;
    }

    /**
     * That's because that PHP function `array_merge_recursive` has the different
     * results as dealing with string keys and numeric keys.
     * In the previous step, we made numeric keys to stringify, so that we want to
     * restore them back to numeric ones.
     *
     * @param array|string $values
     *
     * @return array|string
     */
    public static function uploadedFileArrayTrim($values)
    {
        $result = [];

        if (is_array($values)) {

            foreach ($values as $key => $value) {

                // Restore the keys back to the original ones.
                $key = rtrim($key, '_');

                if (is_array($value)) {
                    $result[$key] = self::uploadedFileArrayTrim($value);
                } else {
                    $result[$key] = $value;
                }
            }
        }

        return $result;
    }

    /**
     * Convert the parse-ready array into PSR-7 specs.
     *
     * @param string|array $values
     * 
     * @return array
     */
    public static function uploadedFileSpecsConvert($values) 
    {
        $result = [];

        if (is_array($values)) {

            foreach ($values as $key => $value) {

                if (is_array($value)) {

                    // Continue querying self, until a string is found.
                    $result[$key] = self::uploadedFileSpecsConvert($value);

                } elseif ($key === 'tmp_name') {

                    /**
                     * Once one of the keys on the same level has been found,
                     * then we can fetch the others at a time.
                     * In this case, the `tmp_name` found.
                     */
                    $result = new uploadedFile(
                        $values['tmp_name'],
                        $values['name'],
                        $values['type'],
                        $values['size'],
                        $values['error']
                    );
                }
            }
        }

        return $result;

    }
}


1		<?php
2		/**
3		* This file is part of the Shieldon package.
4		*
5		* (c) Terry L. <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		declare(strict_types=1);
12
13		namespace Shieldon\Psr7\Utils;
14
15		use Shieldon\Psr7\UploadedFile;
16
17		use function array_merge_recursive;
18		use function rtrim;
19		use function is_array;
20		use function is_string;
21		use function is_numeric;
22
23		/*
24		* The helper functions for converting $_FILES to an array of UploadedFile
25		* instance, only used on ServerRequest class.
26		* This class is not a part of PSR 7.
27		*/
28		class UploadedFileHelper
29		{
30		/**
31		* Create an array for PSR-7 Uploaded File needed.
32		*
33		* @param array $files An array generally from $_FILES
34		* @param bool $isConvert To covert and return $files as an UploadedFile instance.
35		*
36		* @return array\|UploadedFile
37		*/
38	6	public static function uploadedFileParse(array $files)
39		{
40	6	$specTree = [];
41
42	6	$specFields = [
43	6	0 => 'tmp_name',
44	6	1 => 'name',
45	6	2 => 'type',
46	6	3 => 'size',
47	6	4 => 'error',
48	6	];
49
50	6	foreach ($files as $fileKey => $fileValue) {
51	6	if (!isset($fileValue['tmp_name'])) {
52		// @codeCoverageIgnoreStart
53		return [];
54		// @codeCoverageIgnoreEnd
55		}
56
57	6	if (is_string($fileValue['tmp_name']) \|\| is_numeric($fileValue['tmp_name'])) {
58	6	$specTree[$fileKey] = $fileValue;
59
60	2	} elseif (is_array($fileValue['tmp_name'])) {
61
62	2	$tmp = [];
63
64		// We want to find out how many levels of array it has.
65	2	foreach ($specFields as $i => $attr) {
66	2	$tmp[$i] = self::uploadedFileNestedFields($fileValue, $attr);
67		}
68
69	2	$parsedTree = array_merge_recursive(
70	2	$tmp[0], // tmp_name
71	2	$tmp[1], // name
72	2	$tmp[2], // type
73	2	$tmp[3], // size
74	2	$tmp[4] // error
75	2	);
76
77	2	$specTree[$fileKey] = $parsedTree;
78	2	unset($tmp, $parsedTree);
79		}
80		}
81
82	6	return self::uploadedFileArrayTrim($specTree);
83		}
84
85		/**
86		* Find out how many levels of an array it has.
87		*
88		* @param array $files Data structure from $_FILES.
89		* @param string $attr The attributes of a file.
90		*
91		* @return array
92		*/
93	2	public static function uploadedFileNestedFields(array $files, string $attr): array
94		{
95	2	$result = [];
96	2	$values = $files;
97
98	2	if (isset($files[$attr])) {
99	2	$values = $files[$attr];
100		}
101
102	2	foreach ($values as $key => $value) {
103
104		/**
105		* Hereby to add `_` to be a part of the key for letting `array_merge_recursive`
106		* method can deal with numeric keys as string keys.
107		* It will be restored in the next step.
108		*
109		* @see uploadedFileArrayTrim
110		*/
111	2	if (is_numeric($key)) {
112	2	$key .= '_';
113		}
114
115	2	if (is_array($value)) {
116	2	$result[$key] = self::uploadedFileNestedFields($value, $attr);
117		} else {
118	2	$result[$key][$attr] = $value;
119		}
120		}
121
122	2	return $result;
123		}
124
125		/**
126		* That's because that PHP function `array_merge_recursive` has the different
127		* results as dealing with string keys and numeric keys.
128		* In the previous step, we made numeric keys to stringify, so that we want to
129		* restore them back to numeric ones.
130		*
131		* @param array\|string $values
132		*
133		* @return array\|string
134		*/
135	6	public static function uploadedFileArrayTrim($values)
136		{
137	6	$result = [];
138
139	6	if (is_array($values)) {
140
141	6	foreach ($values as $key => $value) {
142
143		// Restore the keys back to the original ones.
144	6	$key = rtrim($key, '_');
145
146	6	if (is_array($value)) {
147	6	$result[$key] = self::uploadedFileArrayTrim($value);
148		} else {
149	6	$result[$key] = $value;
150		}
151		}
152		}
153
154	6	return $result;
155		}
156
157		/**
158		* Convert the parse-ready array into PSR-7 specs.
159		*
160		* @param string\|array $values
161		*
162		* @return array
163		*/
164	6	public static function uploadedFileSpecsConvert($values)
165		{
166	6	$result = [];
167
168	6	if (is_array($values)) {
169
170	6	foreach ($values as $key => $value) {
171
172	6	if (is_array($value)) {
173
174		// Continue querying self, until a string is found.
175	6	$result[$key] = self::uploadedFileSpecsConvert($value);
176
177	6	} elseif ($key === 'tmp_name') {
178
179		/**
180		* Once one of the keys on the same level has been found,
181		* then we can fetch the others at a time.
182		* In this case, the `tmp_name` found.
183		*/
184	6	$result = new uploadedFile(
185	6	$values['tmp_name'],
186	6	$values['name'],
187	6	$values['type'],
188	6	$values['size'],
189	6	$values['error']
190	6	);
191		}
192		}
193		}
194
195	6	return $result;
		0 ignored issues – show Bug Best Practice introduced 2020-06-19 03:09 UTC by Report Bug Copy Issue Report The expression `return $result` also could return the type `Shieldon\Psr7\UploadedFile` which is incompatible with the documented return type `array`. Loading history...
196		}
197		}
198

terrylinooo / psr-http

UploadedFileHelper::uploadedFileArrayTrim() A last analyzed 2023-06-06 08:32 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

UploadedFileHelper::uploadedFileArrayTrim() A
last analyzed 2023-06-06 08:32 UTC