Uploadable::__construct() - Code Metrics - Inspection of "Gedmo hints on all extended builders through phpdo..." - laravel-doctrine/fluent - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — extensions-support ( 9e9e57...39a83b )

by Guido

created 2016-02-23 12:22 UTC

Uploadable::__construct() A

↳ Parent: Uploadable

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace LaravelDoctrine\Fluent\Extensions\Gedmo;

use Gedmo\Uploadable\Mapping\Driver\Fluent as UploadableDriver;
use Gedmo\Uploadable\Mapping\Validator;
use LaravelDoctrine\Fluent\Buildable;
use LaravelDoctrine\Fluent\Builders\Builder;
use LaravelDoctrine\Fluent\Builders\Delay;
use LaravelDoctrine\Fluent\Extensions\ExtensibleClassMetadata;

class Uploadable implements Buildable, Delay
{
    const MACRO_METHOD = 'uploadable';

    /**
     * @var bool
     */
    private $allowOverwrite = false;

    /**
     * @var bool
     */
    private $appendNumber = false;

    /**
     * @var string
     */
    private $path = '';

    /**
     * @var string
     */
    private $pathMethod = '';

    /**
     * @var string
     */
    private $callback = '';

    /**
     * @var string
     */
    private $filenameGenerator = Validator::FILENAME_GENERATOR_NONE;

    /**
     * @var int
     */
    private $maxSize = 0;

    /**
     * @var string
     */
    private $allowedTypes = '';

    /**
     * @var string
     */
    private $disallowedTypes = '';

    /**
     * @var ExtensibleClassMetadata
     */
    private $classMetadata;

    /**
     * @param ExtensibleClassMetadata $classMetadata
     */
    public function __construct(ExtensibleClassMetadata $classMetadata)
    {
        $this->classMetadata = $classMetadata;
    }

    /**
     * Enable the Uploadable extension.
     *
     * @return void
     */
    public static function enable()
    {
        Builder::macro(self::MACRO_METHOD, function (Builder $builder) {
            return new static($builder->getClassMetadata());

        });

        UploadableFile::enable();
    }

    /**
     * If this option is true, it will overwrite a file if it already exists. If you set "false",
     * an exception will be thrown.
     *
     * Default: false
     *
     * @return Uploadable
     */
    public function allowOverwrite()
    {
        $this->allowOverwrite = true;

        return $this;
    }

    /**
     * If the file already exists and "allowOverwrite" is false, append a number to the filename.
     *
     * Example: if you're uploading a file named "test.txt", if the file already exists and this option
     * is true, the extension will modify the name of the uploaded file to "test-1.txt", where "1" could
     * be any number. The extension will check if the file exists until it finds a filename with a number
     * as its postfix that is not used. If you use a filename generator and this option is true, it will
     * append a number to the filename anyway if a file with the same name already exists.
     *
     * Default value: false
     *
     * @return Uploadable
     */
    public function appendNumber()
    {
        $this->appendNumber = true;

        return $this;
    }

    /**
     * The path where the files represented by this entity will be moved. Path can be set in other ways:
     * From the listener or from a method.
     *
     * Default: "".
     *
     * @param string $path
     *
     * @return Uploadable
     */
    public function path($path)
    {
        $this->path = $path;

        return $this;
    }

    /**
     * Similar to "path", this represents the name of a method on the entity that will return the path
     * where the files represented by this entity will be moved. This is useful in several cases. For
     * example, you can set specific paths for specific entities, or you can get the path from other
     * sources (like a framework configuration) instead of hard-coding it in the entity.
     *
     * As first argument this method takes default path, so you can return a path relative to the default.
     *
     * Default: "".
     *
     * @param string $methodName
     *
     * @return Uploadable
     */
    public function pathMethod($methodName)
    {
        $this->pathMethod = $methodName;

        return $this;
    }

    /**
     * Allows you to set a method name. If set, the method will be called after the file is moved.
     *
     * This method will receive an array with information about the uploaded file, which includes the
     * following keys:
     *
     * <ul>
     * <li>fileName: The filename.</li>
     * <li>fileExtension: The extension of the file (including the dot). Example: .jpg</li>
     * <li>fileWithoutExt: The filename without the extension.</li>
     * <li>filePath: The file path. Example: /my/path/filename.jpg</li>
     * <li>fileMimeType: The mime-type of the file. Example: text/plain.</li>
     * <li>fileSize: Size of the file in bytes. Example: 140000.</li>
     * </ul>
     *
     * Default value: "".
     *
     * @param string $callback
     *
     * @return Uploadable
     */
    public function callback($callback)
    {
        $this->callback = $callback;

        return $this;
    }

    /**
     * Normalizes the filename, leaving only alphanumeric characters in the filename, and replacing
     * anything else with a "-".
     *
     * @return Uploadable
     */
    public function alphanumericFilename()
    {
        $this->filenameGenerator = Validator::FILENAME_GENERATOR_ALPHANUMERIC;

        return $this;
    }

    /**
     * Generates a sha1 filename for the file.
     *
     * @return Uploadable
     */
    public function sha1Filename()
    {
        $this->filenameGenerator = Validator::FILENAME_GENERATOR_SHA1;

        return $this;
    }

    /**
     * Set a custom FilenameGenerator class. This class must implement
     * `Gedmo\Uploadable\FilenameGenerator\FilenameGeneratorInterface`.
     *
     * @param string $className
     *
     * @return Uploadable
     */
    public function customFilename($className)
    {
        $this->filenameGenerator = $className;

        return $this;
    }

    /**
     * Set a maximum size for the file, in bytes. If file size exceeds the value set in this
     * configuration, `UploadableMaxSizeException` will be thrown.
     *
     * Default value: 0, meaning that no size validation will occur.
     *
     * @param float $bytes
     *
     * @return Uploadable
     */
    public function maxSize($bytes)
    {
        $this->maxSize = $bytes;
$answer = 42;

$correct = false;

$correct = (bool) $answer;

        return $this;
    }

    /**
     * Allow only specific types.
     *
     * @param array|string ...$type can be an array or multiple string parameters
     *
     * @return Uploadable
     */
    public function allow($type)
    {
        if (!is_array($type)) {
            $type = func_get_args();
        }
        $this->allowedTypes = implode(',', $type);

        return $this;
    }

    /**
     * Disallow specific types
     *
     * @param array|string ...$type can be an array or multiple string parameters
     *
     * @return Uploadable
     */
    public function disallow($type)
    {
        if (!is_array($type)) {
            $type = func_get_args();
        }
        $this->disallowedTypes = implode(',', $type);

        return $this;
    }

    /**
     * Execute the build process
     */
    public function build()
    {
        $config = $this->getConfiguration();

        Validator::validateConfiguration($this->classMetadata, $config);

        $this->classMetadata->addExtension(UploadableDriver::EXTENSION_NAME, $config);
    }

    /**
     * Build the configuration, based on defaults, current extension configuration and accumulated parameters.
     *
     * @return array
     */
    private function getConfiguration()
    {
        return array_merge(
            [
                'fileMimeTypeField' => false,
                'fileNameField'     => false,
                'filePathField'     => false,
                'fileSizeField'     => false,
            ],
            $this->classMetadata->getExtension(UploadableDriver::EXTENSION_NAME),
            [
                'uploadable'        => true,
                'allowOverwrite'    => $this->allowOverwrite,
                'appendNumber'      => $this->appendNumber,
                'path'              => $this->path,
                'pathMethod'        => $this->pathMethod,
                'callback'          => $this->callback,
                'filenameGenerator' => $this->filenameGenerator,
                'maxSize'           => (double)$this->maxSize,
                'allowedTypes'      => $this->allowedTypes,
                'disallowedTypes'   => $this->disallowedTypes,
            ]
        );
    }
}


1		<?php
2
3		namespace LaravelDoctrine\Fluent\Extensions\Gedmo;
4
5		use Gedmo\Uploadable\Mapping\Driver\Fluent as UploadableDriver;
6		use Gedmo\Uploadable\Mapping\Validator;
7		use LaravelDoctrine\Fluent\Buildable;
8		use LaravelDoctrine\Fluent\Builders\Builder;
9		use LaravelDoctrine\Fluent\Builders\Delay;
10		use LaravelDoctrine\Fluent\Extensions\ExtensibleClassMetadata;
11
12		class Uploadable implements Buildable, Delay
13		{
14		const MACRO_METHOD = 'uploadable';
15
16		/**
17		* @var bool
18		*/
19		private $allowOverwrite = false;
20
21		/**
22		* @var bool
23		*/
24		private $appendNumber = false;
25
26		/**
27		* @var string
28		*/
29		private $path = '';
30
31		/**
32		* @var string
33		*/
34		private $pathMethod = '';
35
36		/**
37		* @var string
38		*/
39		private $callback = '';
40
41		/**
42		* @var string
43		*/
44		private $filenameGenerator = Validator::FILENAME_GENERATOR_NONE;
45
46		/**
47		* @var int
48		*/
49		private $maxSize = 0;
50
51		/**
52		* @var string
53		*/
54		private $allowedTypes = '';
55
56		/**
57		* @var string
58		*/
59		private $disallowedTypes = '';
60
61		/**
62		* @var ExtensibleClassMetadata
63		*/
64		private $classMetadata;
65
66		/**
67		* @param ExtensibleClassMetadata $classMetadata
68		*/
69	95	public function __construct(ExtensibleClassMetadata $classMetadata)
70		{
71	95	$this->classMetadata = $classMetadata;
72	95	}
73
74		/**
75		* Enable the Uploadable extension.
76		*
77		* @return void
78		*/
79		public static function enable()
80		{
81	74	Builder::macro(self::MACRO_METHOD, function (Builder $builder) {
82	74	return new static($builder->getClassMetadata());
		0 ignored issues – show Compatibility introduced 2016-02-23 12:26 UTC by Report Bug Copy Issue Report `$builder->getClassMetadata()` of type `object<Doctrine\ORM\Mapping\ClassMetadata>` is not a sub-type of `object<LaravelDoctrine\F...xtensibleClassMetadata>`. It seems like you assume a child class of the class `Doctrine\ORM\Mapping\ClassMetadata` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
83	74	});
84
85	74	UploadableFile::enable();
86	74	}
87
88		/**
89		* If this option is true, it will overwrite a file if it already exists. If you set "false",
90		* an exception will be thrown.
91		*
92		* Default: false
93		*
94		* @return Uploadable
95		*/
96	1	public function allowOverwrite()
97		{
98	1	$this->allowOverwrite = true;
99
100	1	return $this;
101		}
102
103		/**
104		* If the file already exists and "allowOverwrite" is false, append a number to the filename.
105		*
106		* Example: if you're uploading a file named "test.txt", if the file already exists and this option
107		* is true, the extension will modify the name of the uploaded file to "test-1.txt", where "1" could
108		* be any number. The extension will check if the file exists until it finds a filename with a number
109		* as its postfix that is not used. If you use a filename generator and this option is true, it will
110		* append a number to the filename anyway if a file with the same name already exists.
111		*
112		* Default value: false
113		*
114		* @return Uploadable
115		*/
116	1	public function appendNumber()
117		{
118	1	$this->appendNumber = true;
119
120	1	return $this;
121		}
122
123		/**
124		* The path where the files represented by this entity will be moved. Path can be set in other ways:
125		* From the listener or from a method.
126		*
127		* Default: "".
128		*
129		* @param string $path
130		*
131		* @return Uploadable
132		*/
133	1	public function path($path)
134		{
135	1	$this->path = $path;
136
137	1	return $this;
138		}
139
140		/**
141		* Similar to "path", this represents the name of a method on the entity that will return the path
142		* where the files represented by this entity will be moved. This is useful in several cases. For
143		* example, you can set specific paths for specific entities, or you can get the path from other
144		* sources (like a framework configuration) instead of hard-coding it in the entity.
145		*
146		* As first argument this method takes default path, so you can return a path relative to the default.
147		*
148		* Default: "".
149		*
150		* @param string $methodName
151		*
152		* @return Uploadable
153		*/
154	2	public function pathMethod($methodName)
155		{
156	2	$this->pathMethod = $methodName;
157
158	2	return $this;
159		}
160
161		/**
162		* Allows you to set a method name. If set, the method will be called after the file is moved.
163		*
164		* This method will receive an array with information about the uploaded file, which includes the
165		* following keys:
166		*
167		* <ul>
168		* <li>fileName: The filename.</li>
169		* <li>fileExtension: The extension of the file (including the dot). Example: .jpg</li>
170		* <li>fileWithoutExt: The filename without the extension.</li>
171		* <li>filePath: The file path. Example: /my/path/filename.jpg</li>
172		* <li>fileMimeType: The mime-type of the file. Example: text/plain.</li>
173		* <li>fileSize: Size of the file in bytes. Example: 140000.</li>
174		* </ul>
175		*
176		* Default value: "".
177		*
178		* @param string $callback
179		*
180		* @return Uploadable
181		*/
182	2	public function callback($callback)
183		{
184	2	$this->callback = $callback;
185
186	2	return $this;
187		}
188
189		/**
190		* Normalizes the filename, leaving only alphanumeric characters in the filename, and replacing
191		* anything else with a "-".
192		*
193		* @return Uploadable
194		*/
195	1	public function alphanumericFilename()
196		{
197	1	$this->filenameGenerator = Validator::FILENAME_GENERATOR_ALPHANUMERIC;
198
199	1	return $this;
200		}
201
202		/**
203		* Generates a sha1 filename for the file.
204		*
205		* @return Uploadable
206		*/
207	1	public function sha1Filename()
208		{
209	1	$this->filenameGenerator = Validator::FILENAME_GENERATOR_SHA1;
210
211	1	return $this;
212		}
213
214		/**
215		* Set a custom FilenameGenerator class. This class must implement
216		* `Gedmo\Uploadable\FilenameGenerator\FilenameGeneratorInterface`.
217		*
218		* @param string $className
219		*
220		* @return Uploadable
221		*/
222	1	public function customFilename($className)
223		{
224	1	$this->filenameGenerator = $className;
225
226	1	return $this;
227		}
228
229		/**
230		* Set a maximum size for the file, in bytes. If file size exceeds the value set in this
231		* configuration, `UploadableMaxSizeException` will be thrown.
232		*
233		* Default value: 0, meaning that no size validation will occur.
234		*
235		* @param float $bytes
236		*
237		* @return Uploadable
238		*/
239	2	public function maxSize($bytes)
240		{
241	2	$this->maxSize = $bytes;
		0 ignored issues – show Documentation Bug introduced 2016-02-23 12:26 UTC by Report Bug Copy Issue Report The property `$maxSize` was declared of type `integer`, but `$bytes` is of type `double`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
242
243	2	return $this;
244		}
245
246		/**
247		* Allow only specific types.
248		*
249		* @param array\|string ...$type can be an array or multiple string parameters
250		*
251		* @return Uploadable
252		*/
253	4	public function allow($type)
254		{
255	4	if (!is_array($type)) {
256	3	$type = func_get_args();
257	3	}
258	4	$this->allowedTypes = implode(',', $type);
259
260	4	return $this;
261		}
262
263		/**
264		* Disallow specific types
265		*
266		* @param array\|string ...$type can be an array or multiple string parameters
267		*
268		* @return Uploadable
269		*/
270	4	public function disallow($type)
271		{
272	4	if (!is_array($type)) {
273	3	$type = func_get_args();
274	3	}
275	4	$this->disallowedTypes = implode(',', $type);
276
277	4	return $this;
278		}
279
280		/**
281		* Execute the build process
282		*/
283	94	public function build()
284		{
285	94	$config = $this->getConfiguration();
286
287	94	Validator::validateConfiguration($this->classMetadata, $config);
288
289	17	$this->classMetadata->addExtension(UploadableDriver::EXTENSION_NAME, $config);
290	17	}
291
292		/**
293		* Build the configuration, based on defaults, current extension configuration and accumulated parameters.
294		*
295		* @return array
296		*/
297	94	private function getConfiguration()
298		{
299	94	return array_merge(
300		[
301	94	'fileMimeTypeField' => false,
302	94	'fileNameField' => false,
303	94	'filePathField' => false,
304	94	'fileSizeField' => false,
305	94	],
306	94	$this->classMetadata->getExtension(UploadableDriver::EXTENSION_NAME),
307		[
308	94	'uploadable' => true,
309	94	'allowOverwrite' => $this->allowOverwrite,
310	94	'appendNumber' => $this->appendNumber,
311	94	'path' => $this->path,
312	94	'pathMethod' => $this->pathMethod,
313	94	'callback' => $this->callback,
314	94	'filenameGenerator' => $this->filenameGenerator,
315	94	'maxSize' => (double)$this->maxSize,
316	94	'allowedTypes' => $this->allowedTypes,
317	94	'disallowedTypes' => $this->disallowedTypes,
318		]
319	94	);
320		}
321		}
322

laravel-doctrine / fluent

Push — extensions-support ( 9e9e57...39a83b )

Uploadable::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like