ChunkFile::__construct() - Code Metrics - recca0120/upload - Measure and Improve Code Quality continuously with Scrutinizer

ChunkFile::__construct() A
last analyzed 2018-09-25 05:57 UTC

↳ Parent: ChunkFile

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

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

<?php

namespace Recca0120\Upload;

use ErrorException;
use Recca0120\Upload\Exceptions\ChunkedResponseException;

class ChunkFile
{
    /**
     * TMPFILE_EXTENSION.
     *
     * @var string
     */
    const TMPFILE_EXTENSION = '.part';

    /**
     * $files.
     *
     * @var \Recca0120\Upload\Filesystem
     */
    protected $files;

    /**
     * $token.
     *
     * @var string
     */
    protected $token = null;

    /**
     * $chunkPath.
     *
     * @var string
     */
    protected $chunkPath = null;

    /**
     * $storagePath.
     *
     * @var string
     */
    protected $storagePath = null;

    /**
     * $name.
     *
     * @var string
     */
    protected $name = null;

    /**
     * $mimeType.
     *
     * @var string
     */
    protected $mimeType = null;

    /**
     * $tmpfilename.
     *
     * @var string
     */
    protected $tmpfilename = null;

    /**
     * __construct.
     *
     * @param string $name
     * @param string $chunkPath
     * @param string $storagePath
     * @param string $mimeType
     * @param string $token
     * @param \Recca0120\Upload\Filesystem $files
     */
    public function __construct($name, $chunkPath, $storagePath, $token = null, $mimeType = null, Filesystem $files = null)
    {
        $this->files = $files ?: new Filesystem();
        $this->name = $name;
        $this->chunkPath = $chunkPath;
        $this->storagePath = $storagePath;
        $this->token = $token;
        $this->mimeType = $mimeType;
    }

    /**
     * getMimeType.
     *
     * @return string
     */
    public function getMimeType()
    {
        try {
            return $this->mimeType ?: $this->files->mimeType($this->name);
        } catch (ErrorException $e) {
            return;
        }
    }

    /**
     * throwException.
     *
     * @param mixed $message
     * @param array $headers
     * @throws \Recca0120\Upload\Exceptions\ChunkedResponseException
     */
    public function throwException($message = '', $headers = [])
    {
        throw new ChunkedResponseException($message, $headers);
    }

    /**
     * appendStream.
     *
     * @param mixed $source
     * @param int $offset
     * @return $this
     */
    public function appendStream($source, $offset = 0)
    {
        $chunkFile = $this->chunkFile();
        $this->files->appendStream($chunkFile, $source, (int) $offset);

        return $this;
    }

    /**
     * appendFile.
     *
     * @param mixed $source
     * @param int $index
     * @return $this
     */
    public function appendFile($source, $index = 0)
    {
        $chunkFile = $this->chunkFile().'.'.$index;
        $this->files->appendStream($chunkFile, $source, 0);

        return $this;
    }

    /**
     * createUploadedFile.
     *
     * @return \Illuminate\Http\UploadedFile
     */
    public function createUploadedFile($chunks = null, $storageFile = null)
    {
        $chunkFile = $this->chunkFile();
        $storageFile = $storageFile ?: $this->storageFile();

        if (is_null($chunks) === false) {
            for ($i = 0; $i < $chunks; $i++) {
                $chunk = $chunkFile.'.'.$i;
                $this->files->append(
                    $storageFile,
                    $this->files->get($chunk)
                );
                $this->files->delete($chunk);
            }
        } else {
            $this->files->move($chunkFile, $storageFile);
        }

        return $this->files->createUploadedFile(
            $storageFile, $this->name, $this->getMimeType()

        );
    }

    /**
     * tmpfilename.
     *
     * @return string
     */
    protected function tmpfilename()
    {
        if (is_null($this->tmpfilename) === true) {
            $this->tmpfilename = $this->files->tmpfilename($this->name, $this->token);
        }

        return $this->tmpfilename;
    }

    /**
     * chunkFile.
     *
     * @return string
     */
    protected function chunkFile()
    {
        return $this->chunkPath.$this->tmpfilename().static::TMPFILE_EXTENSION;
    }

    /**
     * storageFile.
     *
     * @return string
     */
    protected function storageFile()
    {
        return $this->storagePath.$this->tmpfilename();
    }
}


1		<?php
2
3		namespace Recca0120\Upload;
4
5		use ErrorException;
6		use Recca0120\Upload\Exceptions\ChunkedResponseException;
7
8		class ChunkFile
9		{
10		/**
11		* TMPFILE_EXTENSION.
12		*
13		* @var string
14		*/
15		const TMPFILE_EXTENSION = '.part';
16
17		/**
18		* $files.
19		*
20		* @var \Recca0120\Upload\Filesystem
21		*/
22		protected $files;
23
24		/**
25		* $token.
26		*
27		* @var string
28		*/
29		protected $token = null;
30
31		/**
32		* $chunkPath.
33		*
34		* @var string
35		*/
36		protected $chunkPath = null;
37
38		/**
39		* $storagePath.
40		*
41		* @var string
42		*/
43		protected $storagePath = null;
44
45		/**
46		* $name.
47		*
48		* @var string
49		*/
50		protected $name = null;
51
52		/**
53		* $mimeType.
54		*
55		* @var string
56		*/
57		protected $mimeType = null;
58
59		/**
60		* $tmpfilename.
61		*
62		* @var string
63		*/
64		protected $tmpfilename = null;
65
66		/**
67		* __construct.
68		*
69		* @param string $name
70		* @param string $chunkPath
71		* @param string $storagePath
72		* @param string $mimeType
73		* @param string $token
74		* @param \Recca0120\Upload\Filesystem $files
75		*/
76	5	public function __construct($name, $chunkPath, $storagePath, $token = null, $mimeType = null, Filesystem $files = null)
77		{
78	5	$this->files = $files ?: new Filesystem();
79	5	$this->name = $name;
80	5	$this->chunkPath = $chunkPath;
81	5	$this->storagePath = $storagePath;
82	5	$this->token = $token;
83	5	$this->mimeType = $mimeType;
84	5	}
85
86		/**
87		* getMimeType.
88		*
89		* @return string
90		*/
91	1	public function getMimeType()
92		{
93		try {
94	1	return $this->mimeType ?: $this->files->mimeType($this->name);
95		} catch (ErrorException $e) {
96		return;
97		}
98		}
99
100		/**
101		* throwException.
102		*
103		* @param mixed $message
104		* @param array $headers
105		* @throws \Recca0120\Upload\Exceptions\ChunkedResponseException
106		*/
107	3	public function throwException($message = '', $headers = [])
108		{
109	3	throw new ChunkedResponseException($message, $headers);
110		}
111
112		/**
113		* appendStream.
114		*
115		* @param mixed $source
116		* @param int $offset
117		* @return $this
118		*/
119	1	public function appendStream($source, $offset = 0)
120		{
121	1	$chunkFile = $this->chunkFile();
122	1	$this->files->appendStream($chunkFile, $source, (int) $offset);
123
124	1	return $this;
125		}
126
127		/**
128		* appendFile.
129		*
130		* @param mixed $source
131		* @param int $index
132		* @return $this
133		*/
134	1	public function appendFile($source, $index = 0)
135		{
136	1	$chunkFile = $this->chunkFile().'.'.$index;
137	1	$this->files->appendStream($chunkFile, $source, 0);
138
139	1	return $this;
140		}
141
142		/**
143		* createUploadedFile.
144		*
145		* @return \Illuminate\Http\UploadedFile
146		*/
147	1	public function createUploadedFile($chunks = null, $storageFile = null)
148		{
149	1	$chunkFile = $this->chunkFile();
150	1	$storageFile = $storageFile ?: $this->storageFile();
151
152	1	if (is_null($chunks) === false) {
153		for ($i = 0; $i < $chunks; $i++) {
154		$chunk = $chunkFile.'.'.$i;
155		$this->files->append(
156		$storageFile,
157		$this->files->get($chunk)
158		);
159		$this->files->delete($chunk);
160		}
161		} else {
162	1	$this->files->move($chunkFile, $storageFile);
163		}
164
165	1	return $this->files->createUploadedFile(
166	1	$storageFile, $this->name, $this->getMimeType()
		0 ignored issues – show Security Bug introduced 2018-03-23 11:39 UTC by Report Bug Copy Issue Report It seems like `$this->getMimeType()` targeting `Recca0120\Upload\ChunkFile::getMimeType()` can also be of type `false`; however, `Recca0120\Upload\Filesystem::createUploadedFile()` does only seem to accept `string\|null`, did you maybe forget to handle an error condition? Loading history...
167		);
168		}
169
170		/**
171		* tmpfilename.
172		*
173		* @return string
174		*/
175	3	protected function tmpfilename()
176		{
177	3	if (is_null($this->tmpfilename) === true) {
178	3	$this->tmpfilename = $this->files->tmpfilename($this->name, $this->token);
179		}
180
181	3	return $this->tmpfilename;
182		}
183
184		/**
185		* chunkFile.
186		*
187		* @return string
188		*/
189	3	protected function chunkFile()
190		{
191	3	return $this->chunkPath.$this->tmpfilename().static::TMPFILE_EXTENSION;
192		}
193
194		/**
195		* storageFile.
196		*
197		* @return string
198		*/
199	1	protected function storageFile()
200		{
201	1	return $this->storagePath.$this->tmpfilename();
202		}
203		}
204

recca0120 / upload

ChunkFile::__construct() A last analyzed 2018-09-25 05:57 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ChunkFile::__construct() A
last analyzed 2018-09-25 05:57 UTC