DMT\Aura\Psr\Factory\UploadedFileFactory

Complexity

Total Complexity

23

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Test Coverage

Coverage

97.83%

Importance

Changes	2
Bugs	0	Features	2

6 Methods

Rating	Name	Duplication	Size	Complexity
A	asUploadedFileInstance()	0	18	3
A	createUploadedFile()	0	12	2
A	isUploadedFileEntry()	0	7	4
A	__construct()	0	3	1
A	normalizeUploadedFileArray()	0	14	4
B	createUploadedFilesFromGlobalFiles()	0	25	9

<?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)) {

The condition is_array($uploadedFileEntry) is always true.

            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++) {

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.

                $files[$i] = [];
                foreach ($uploadedFile as $key => $value) {
                    $files[$i][$key] = $value[$i] ?? null;
                }
            }
            $uploadedFile = $files;
        }

        return $uploadedFile;
    }
}