UploadedFile::getClientFilename() - Code Metrics - zapheus/psr-07-bridge - Measure and Improve Code Quality continuously with Scrutinizer

UploadedFile::getClientFilename() A
last analyzed 2020-10-04 15:14 UTC

↳ Parent: UploadedFile

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace Zapheus\Bridge\Psr;

use Psr\Http\Message\UploadedFileInterface;

/**
 * Uploaded File
 *
 * @package Zapheus
 * @author  Rougin Gutib <[email protected]>
 */
class UploadedFile implements UploadedFileInterface
{
    /**
     * @var string
     */
    protected $file;

    /**
     * @var integer|null
     */
    protected $size;

    /**
     * @var integer
     */
    protected $error;

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

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

    /**
     * Initializes the uploaded file instance.
     *
     * @param string       $file
     * @param integer|null $size
     * @param integer      $error
     * @param string|null  $name
     * @param string|null  $media
     */
    public function __construct($file, $size = null, $error = UPLOAD_ERR_OK, $name = null, $media = null)
    {
        $this->error = $error;

        $this->file = $file;

        $this->media = $media;

        $this->name = $name;

        $this->size = $size;
    }

    /**
     * Retrieves the filename sent by the client.
     *
     * @return string|null
     */
    public function getClientFilename()
    {
        return $this->name;
    }

    /**
     * Retrieves the media type sent by the client.
     *
     * @return string|null
     */
    public function getClientMediaType()
    {
        return $this->media;
    }

    /**
     * Retrieves the error associated with the uploaded file.
     *
     * @return integer
     */
    public function getError()
    {
        return $this->error;
    }

    /**
     * Retrieves the file size.
     *
     * @return integer|null
     */
    public function getSize()
    {
        return $this->size;
    }

    /**
     * Retrieves a stream representing the uploaded file.
     *
     * @return \Psr\Http\Message\StreamInterface
     *
     * @throws \RuntimeException
     */
    public function getStream()
    {
        // TODO: Add \RuntimeException

        $stream = fopen($this->file, 'r+');

        $stream = $stream === false ? null : $stream;

        return new Stream($stream);
    }

    /**
     * Move the uploaded file to a new location.
     *
     * @param string $target
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     */
    public function moveTo($target)
    {
        // TODO: Add \InvalidArgumentException
        // TODO: Add \RuntimeException

        rename($this->file, $target);
    }

    /**
     * Parses the $_FILES into multiple \File instances.
     *
     * @param  array $uploaded
     * @param  array $files
     * @return \Zapheus\Http\Message\FileInterface[]
     */
    public static function normalize(array $uploaded, $files = array())
    {
        foreach (self::diverse($uploaded) as $name => $file)
        {
            list($files[$name], $items) = array($file, array());

            if (isset($file['name']) === true)
            {
                foreach ($file['name'] as $key => $value)
                {
                    $instance = self::create($file, $key);

                    array_push($items, $instance);
                }

                $files[$name] = (array) $items;
            }
        }

        return $files;
    }

    /**
     * Creates a new UploadedFile instance.
     *
     * @param  array   $file
     * @param  integer $key
     * @return \Psr\Http\Message\UploadedFile
     */
    protected static function create(array $file, $key)
    {
        $tmp = $file['tmp_name'][$key];

        $size = $file['size'][$key];

        $error = $file['error'][$key];

        $original = $file['name'][$key];

        $type = $file['type'][$key];

        return new UploadedFile($tmp, $size, $error, $original, $type);
    }

    /**
     * Diverse the $_FILES into a consistent result.
     *
     * @param  array $uploaded
     * @return array
     */
    protected static function diverse(array $uploaded)
    {
        $result = array();

        foreach ($uploaded as $file => $item)
        {
            foreach ($item as $key => $value)
            {
                $diversed = (array) $value;

                $result[$file][$key] = $diversed;
            }
        }

        return $result;
    }
}


1		<?php
2
3		namespace Zapheus\Bridge\Psr;
4
5		use Psr\Http\Message\UploadedFileInterface;
6
7		/**
8		* Uploaded File
9		*
10		* @package Zapheus
11		* @author Rougin Gutib <[email protected]>
12		*/
13		class UploadedFile implements UploadedFileInterface
14		{
15		/**
16		* @var string
17		*/
18		protected $file;
19
20		/**
21		* @var integer\|null
22		*/
23		protected $size;
24
25		/**
26		* @var integer
27		*/
28		protected $error;
29
30		/**
31		* @var string
32		*/
33		protected $name;
34
35		/**
36		* @var string
37		*/
38		protected $media;
39
40		/**
41		* Initializes the uploaded file instance.
42		*
43		* @param string $file
44		* @param integer\|null $size
45		* @param integer $error
46		* @param string\|null $name
47		* @param string\|null $media
48		*/
49	48	public function __construct($file, $size = null, $error = UPLOAD_ERR_OK, $name = null, $media = null)
50		{
51	48	$this->error = $error;
52
53	48	$this->file = $file;
54
55	48	$this->media = $media;
56
57	48	$this->name = $name;
58
59	48	$this->size = $size;
60	48	}
61
62		/**
63		* Retrieves the filename sent by the client.
64		*
65		* @return string\|null
66		*/
67	48	public function getClientFilename()
68		{
69	48	return $this->name;
70		}
71
72		/**
73		* Retrieves the media type sent by the client.
74		*
75		* @return string\|null
76		*/
77	48	public function getClientMediaType()
78		{
79	48	return $this->media;
80		}
81
82		/**
83		* Retrieves the error associated with the uploaded file.
84		*
85		* @return integer
86		*/
87	48	public function getError()
88		{
89	48	return $this->error;
90		}
91
92		/**
93		* Retrieves the file size.
94		*
95		* @return integer\|null
96		*/
97	48	public function getSize()
98		{
99	48	return $this->size;
100		}
101
102		/**
103		* Retrieves a stream representing the uploaded file.
104		*
105		* @return \Psr\Http\Message\StreamInterface
106		*
107		* @throws \RuntimeException
108		*/
109	3	public function getStream()
110		{
111		// TODO: Add \RuntimeException
112
113	3	$stream = fopen($this->file, 'r+');
114
115	3	$stream = $stream === false ? null : $stream;
116
117	3	return new Stream($stream);
118		}
119
120		/**
121		* Move the uploaded file to a new location.
122		*
123		* @param string $target
124		*
125		* @throws \InvalidArgumentException
126		* @throws \RuntimeException
127		*/
128	3	public function moveTo($target)
129		{
130		// TODO: Add \InvalidArgumentException
131		// TODO: Add \RuntimeException
132
133	3	rename($this->file, $target);
134	3	}
135
136		/**
137		* Parses the $_FILES into multiple \File instances.
138		*
139		* @param array $uploaded
140		* @param array $files
141		* @return \Zapheus\Http\Message\FileInterface[]
142		*/
143	81	public static function normalize(array $uploaded, $files = array())
144		{
145	81	foreach (self::diverse($uploaded) as $name => $file)
146		{
147	27	list($files[$name], $items) = array($file, array());
148
149	27	if (isset($file['name']) === true)
150	9	{
151	27	foreach ($file['name'] as $key => $value)
152		{
153	27	$instance = self::create($file, $key);
154
155	27	array_push($items, $instance);
156	9	}
157
158	27	$files[$name] = (array) $items;
159	9	}
160	27	}
161
162	81	return $files;
163		}
164
165		/**
166		* Creates a new UploadedFile instance.
167		*
168		* @param array $file
169		* @param integer $key
170		* @return \Psr\Http\Message\UploadedFile
171		*/
172	27	protected static function create(array $file, $key)
173		{
174	27	$tmp = $file['tmp_name'][$key];
175
176	27	$size = $file['size'][$key];
177
178	27	$error = $file['error'][$key];
179
180	27	$original = $file['name'][$key];
181
182	27	$type = $file['type'][$key];
183
184	27	return new UploadedFile($tmp, $size, $error, $original, $type);
185		}
186
187		/**
188		* Diverse the $_FILES into a consistent result.
189		*
190		* @param array $uploaded
191		* @return array
192		*/
193	81	protected static function diverse(array $uploaded)
194		{
195	81	$result = array();
196
197	81	foreach ($uploaded as $file => $item)
198		{
199	27	foreach ($item as $key => $value)
200		{
201	27	$diversed = (array) $value;
202
203	27	$result[$file][$key] = $diversed;
204	9	}
205	27	}
206
207	81	return $result;
208		}
209		}
210

zapheus / psr-07-bridge

UploadedFile::getClientFilename() A last analyzed 2020-10-04 15:14 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

UploadedFile::getClientFilename() A
last analyzed 2020-10-04 15:14 UTC