Issues in ParamDefinition.php - New Issues - Inspection of "Deprecate parameter dependencies" - JeroenDeDauw/ParamProcessor - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 761e95...f1e6ba )

by Jeroen De

created 2019-07-29 18:35 UTC

src/ParamDefinition.php (1 issue)

Labels

Deprecated Code 1

Severity

Minor 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace ParamProcessor;

use Exception;
use ParamProcessor\PackagePrivate\Param;
use ValueParsers\NullParser;
use ValueParsers\ValueParser;
use ValueValidators\NullValidator;
use ValueValidators\ValueValidator;

/**
 * Specifies what kind of values are accepted, how they should be validated,
 * how they should be formatted, what their dependencies are and how they should be described.
 *
 * Try to avoid using this interface outside of ParamProcessor for anything else than defining parameters.
 * In particular, do not derive from this class to implement methods such as formatValue.
 *
 * @since 1.0
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 */
/* final */ class ParamDefinition implements IParamDefinition {

	/**
	 * Indicates whether parameters that are provided more then once  should be accepted,
	 * and use the first provided value, or not, and generate an error.
	 *
	 * @deprected since 1.7
	 *
	 * @var boolean
	 */
	public static $acceptOverriding = false;

	/**
	 * Indicates whether parameters not found in the criteria list
	 * should be stored in case they are not accepted. The default is false.
	 *
	 * @deprected since 1.7
	 *
	 * @var boolean
	 */
	public static $accumulateParameterErrors = false;

	protected $type;
	protected $name;
	protected $default;
	protected $isList;

	/**
	 * A message that acts as description for the parameter or false when there is none.
	 * Can be obtained via getMessage and set via setMessage.
	 *
	 * @var string
	 */
	protected $message;

	/**
	 * Indicates if the parameter value should trimmed during the clean process.
	 * @var boolean|null
	 */
	protected $trimValue = null;

	/**
	 * Indicates if the parameter manipulations should be applied to the default value.
	 * @var boolean
	 */
	protected $applyManipulationsToDefault = true;

	/**
	 * Dependency list containing parameters that need to be handled before this one.
	 * @var string[]
	 */
	protected $dependencies = [];

	/**
	 * @var string
	 */
	protected $delimiter = ',';

	/**
	 * List of aliases for the parameter name.
	 *
	 * @var string[]
	 */
	protected $aliases = [];

	/**
	 * Original array definition of the parameter
	 * @var array
	 */
	protected $options = [];

	/**
	 * @var ValueParser|null
	 */
	protected $parser = null;

	/**
	 * @var ValueValidator|null
	 */
	protected $validator = null;

	/**
	 * @var callable|null
	 */
	protected $validationFunction = null;

	/**
	 * @param string $type
	 * @param string $name
	 * @param mixed $default Use null for no default (which makes the parameter required)
	 * @param string $message
	 * @param boolean $isList
	 */
	public function __construct( string $type, string $name, $default = null, string $message = null, bool $isList = false ) {
		$this->type = $type;
		$this->name = $name;
		$this->default = $default;
		$this->message = $message ?? 'validator-message-nodesc';
		$this->isList = $isList;

		$this->postConstruct();
	}

	/**
	 * Allows deriving classed to do additional stuff on instance construction
	 * without having to get and pass all the constructor arguments.
	 *
	 * @since 1.0
	 */
	protected function postConstruct() {

	}

	/**
	 * Returns if the value should be trimmed before validation and any further processing.
	 * - true: always trim
	 * - false: never trim
	 * - null: trim based on context settings
	 */
	public function trimDuringClean(): ?bool {
		return $this->trimValue;
	}

	/**
	 * Returns the parameter name aliases.
	 * @return string[]
	 */
	public function getAliases(): array {
		return $this->aliases;
	}

	public function hasAlias( string $alias ): bool {
		return in_array( $alias, $this->getAliases() );
	}

	/**
	 * @deprecated since 1.7
	 * Returns if the parameter has a certain dependency.
	 */
	public function hasDependency( string $dependency ): bool {
		return in_array( $dependency, $this->getDependencies() );

	}

	/**
	 * Returns the list of allowed values, or an empty array if there is no such restriction.
	 */
	public function getAllowedValues(): array {
		$allowedValues = [];

		if ( $this->validator !== null && method_exists( $this->validator, 'getWhitelistedValues' ) ) {
			if ( method_exists( $this->validator, 'setOptions' ) ) {
				$this->validator->setOptions( $this->options );
			}

			$allowedValues = $this->validator->getWhitelistedValues();

			if ( $allowedValues === false ) {
				$allowedValues = [];
			}
		}

		return $allowedValues;
	}

	/**
	 * @deprecated since 1.7
	 *
	 * @param mixed $default
	 * @param boolean $manipulate Should the default be manipulated or not? Since 0.4.6.
	 */
	public function setDefault( $default, $manipulate = true ) {
		$this->default = $default;
		$this->setDoManipulationOfDefault( $manipulate );
	}

	/**
	 * Returns the default value.
	 * @return mixed
	 */
	public function getDefault() {
		return $this->default;
	}

	/**
	 * Returns a message describing the parameter.
	 */
	public function getMessage(): string {
		return $this->message;
	}

	/**
	 * This should be a message key, ie something that can be passed
	 * to wfMsg. Not an actual text.
	 */
	public function setMessage( string $message ) {
		$this->message = $message;
	}

	/**
	 * Set if the parameter manipulations should be applied to the default value.
	 */
	public function setDoManipulationOfDefault( bool $doOrDoNotThereIsNoTry ) {
		$this->applyManipulationsToDefault = $doOrDoNotThereIsNoTry;
	}

	public function shouldManipulateDefault(): bool {
		return $this->applyManipulationsToDefault;
	}

	/**
	 * Adds one or more aliases for the parameter name.
	 *
	 * @param string|string[] $aliases
	 */
	public function addAliases( $aliases ) {
		$args = func_get_args();
		$this->aliases = array_merge( $this->aliases, is_array( $args[0] ) ? $args[0] : $args );
	}

	/**
	 * Adds one or more dependencies. There are the names of parameters
	 * that need to be validated and formatted before this one.
	 *
	 * @param string|string[] $dependencies
	 */
	public function addDependencies( $dependencies ) {
		$args = func_get_args();
		$this->dependencies = array_merge( $this->dependencies, is_array( $args[0] ) ? $args[0] : $args );
	}

	public function getName(): string {
		return $this->name;
	}

	/**
	 * Returns a message key for a message describing the parameter type.
	 */
	public function getTypeMessage(): string {
		$message = 'validator-type-' . $this->getType();

		if ( $this->isList() ) {
			$message .= '-list';
		}

		return $message;
	}

	/**
	 * @deprecated since 1.7
	 * Returns a list of dependencies the parameter has, in the form of
	 * other parameter names.
	 *
	 * @return string[]
	 */
	public function getDependencies(): array {
		return $this->dependencies;
	}

	public function isRequired(): bool {
		return is_null( $this->default );
	}

	public function isList(): bool {
		return $this->isList;
	}

	/**
	 * Returns the delimiter to use to split the raw value in case the
	 * parameter is a list.
	 */
	public function getDelimiter(): string {
		return $this->delimiter;
	}

	/**
	 * Sets the delimiter to use to split the raw value in case the
	 * parameter is a list.
	 */
	public function setDelimiter( string $delimiter ) {
		$this->delimiter = $delimiter;
	}

	/**
	 * Sets the parameter definition values contained in the provided array.
	 *
	 * @deprecated since 1.7
	 * TODO: provide alternative in ParamDefinitionFactory
	 */
	public function setArrayValues( array $param ) {
		if ( array_key_exists( 'aliases', $param ) ) {
			$this->addAliases( $param['aliases'] );
		}

		if ( array_key_exists( 'dependencies', $param ) ) {
			$this->addDependencies( $param['dependencies'] );
		}

		if ( array_key_exists( 'trim', $param ) ) {
			$this->trimValue = $param['trim'];
		}

		if ( array_key_exists( 'delimiter', $param ) ) {
			$this->delimiter = $param['delimiter'];
		}

		if ( array_key_exists( 'manipulatedefault', $param ) ) {
			$this->setDoManipulationOfDefault( $param['manipulatedefault'] );
		}

		$this->options = $param;
	}

	/**
	 * @see IParamDefinition::format
	 *
	 * @deprecated
	 *
	 * @param IParam $param
	 * @param IParamDefinition[] $definitions
	 * @param IParam[] $params
	 */
	public function format( IParam $param, array &$definitions, array $params ) {
		/**
		 * @var Param $param
		 */

		if ( $this->isList() && is_array( $param->getValue() ) ) {
			// TODO: if isList returns true, the value should be an array.
			// The second check here is to avoid a mysterious error.
			// Should have logging that writes down the value whenever this occurs.

			$values = $param->getValue();

			foreach ( $values as &$value ) {
				$value = $this->formatValue( $value, $param, $definitions, $params );
			}

			$param->setValue( $values );
			$this->formatList( $param, $definitions, $params );
		}
		else {
			$param->setValue( $this->formatValue( $param->getValue(), $param, $definitions, $params ) );
		}

		// deprecated, deriving classes should not add array-definitions to the list
		$definitions = self::getCleanDefinitions( $definitions );

		if ( array_key_exists( 'post-format', $this->options ) ) {
			$param->setValue( call_user_func( $this->options['post-format'], $param->getValue() ) );
		}
	}

	/**
	 * Formats the parameters values to their final result.
	 *
	 * @since 1.0
	 * @deprecated
	 *
	 * @param $param IParam
	 * @param $definitions array of IParamDefinition
	 * @param $params array of IParam
	 */
	protected function formatList( IParam $param, array &$definitions, array $params ) {
	}

	/**
	 * Formats the parameter value to it's final result.
	 *
	 * @since 1.0
	 * @deprecated
	 *
	 * @param mixed $value
	 * @param IParam $param
	 * @param IParamDefinition[] $definitions
	 * @param IParam[] $params
	 *
	 * @return mixed
	 */
	protected function formatValue( $value, IParam $param, array &$definitions, array $params ) {
		return $value;
	}

	/**
	 * Returns a cleaned version of the list of parameter definitions.
	 * This includes having converted all supported definition types to
	 * ParamDefinition classes and having all keys set to the names of the
	 * corresponding parameters.
	 *
	 * @deprecated since 1.7 - use ParamDefinitionFactory
	 *
	 * @param ParamDefinition[] $definitions
	 *
	 * @return ParamDefinition[]
	 * @throws Exception
	 */
	public static function getCleanDefinitions( array $definitions ): array {
		$cleanList = [];

		foreach ( $definitions as $key => $definition ) {
			if ( is_array( $definition ) ) {
				if ( !array_key_exists( 'name', $definition ) && is_string( $key ) ) {
					$definition['name'] = $key;
				}

				$definition = ParamDefinitionFactory::singleton()->newDefinitionFromArray( $definition );
			}

			if ( !( $definition instanceof IParamDefinition ) ) {
				throw new Exception( '$definition not an instance of IParamDefinition' );
			}

			$cleanList[$definition->getName()] = $definition;
		}

		return $cleanList;
	}

	/**
	 * Returns an identifier for the type of the parameter.
	 */
	public function getType(): string {
		return $this->type;
	}

	/**
	 * Returns a ValueParser object to parse the parameters value.
	 */
	public function getValueParser(): ValueParser {
		if ( $this->parser === null ) {
			$this->parser = new NullParser();
		}

		return $this->parser;
	}

	/**
	 * Returns a ValueValidator that can be used to validate the parameters value.
	 */
	public function getValueValidator(): ValueValidator {
		if ( $this->validator === null ) {
			$this->validator = new NullValidator();
		}

		return $this->validator;
	}

	public function setValueParser( ValueParser $parser ) {
		$this->parser = $parser;
	}

	public function setValueValidator( ValueValidator $validator ) {
		$this->validator = $validator;
	}

	/**
	 * Sets a validation function that will be run before the ValueValidator.
	 *
	 * This can be used instead of a ValueValidator where validation is very
	 * trivial, ie checking if something is a boolean can be done with is_bool.
	 */
	public function setValidationCallback( ?callable $validationFunction ) {
		$this->validationFunction = $validationFunction;
	}

	/**
	 * @see setValidationCallback
	 */
	public function getValidationCallback(): ?callable {
		return $this->validationFunction;
	}

	public function getOptions(): array {
		return $this->options;
	}

}


1		<?php
2
3		namespace ParamProcessor;
4
5		use Exception;
6		use ParamProcessor\PackagePrivate\Param;
7		use ValueParsers\NullParser;
8		use ValueParsers\ValueParser;
9		use ValueValidators\NullValidator;
10		use ValueValidators\ValueValidator;
11
12		/**
13		* Specifies what kind of values are accepted, how they should be validated,
14		* how they should be formatted, what their dependencies are and how they should be described.
15		*
16		* Try to avoid using this interface outside of ParamProcessor for anything else than defining parameters.
17		* In particular, do not derive from this class to implement methods such as formatValue.
18		*
19		* @since 1.0
20		*
21		* @licence GNU GPL v2+
22		* @author Jeroen De Dauw < [email protected] >
23		*/
24		/* final */ class ParamDefinition implements IParamDefinition {
25
26		/**
27		* Indicates whether parameters that are provided more then once should be accepted,
28		* and use the first provided value, or not, and generate an error.
29		*
30		* @deprected since 1.7
31		*
32		* @var boolean
33		*/
34		public static $acceptOverriding = false;
35
36		/**
37		* Indicates whether parameters not found in the criteria list
38		* should be stored in case they are not accepted. The default is false.
39		*
40		* @deprected since 1.7
41		*
42		* @var boolean
43		*/
44		public static $accumulateParameterErrors = false;
45
46		protected $type;
47		protected $name;
48		protected $default;
49		protected $isList;
50
51		/**
52		* A message that acts as description for the parameter or false when there is none.
53		* Can be obtained via getMessage and set via setMessage.
54		*
55		* @var string
56		*/
57		protected $message;
58
59		/**
60		* Indicates if the parameter value should trimmed during the clean process.
61		* @var boolean\|null
62		*/
63		protected $trimValue = null;
64
65		/**
66		* Indicates if the parameter manipulations should be applied to the default value.
67		* @var boolean
68		*/
69		protected $applyManipulationsToDefault = true;
70
71		/**
72		* Dependency list containing parameters that need to be handled before this one.
73		* @var string[]
74		*/
75		protected $dependencies = [];
76
77		/**
78		* @var string
79		*/
80		protected $delimiter = ',';
81
82		/**
83		* List of aliases for the parameter name.
84		*
85		* @var string[]
86		*/
87		protected $aliases = [];
88
89		/**
90		* Original array definition of the parameter
91		* @var array
92		*/
93		protected $options = [];
94
95		/**
96		* @var ValueParser\|null
97		*/
98		protected $parser = null;
99
100		/**
101		* @var ValueValidator\|null
102		*/
103		protected $validator = null;
104
105		/**
106		* @var callable\|null
107		*/
108		protected $validationFunction = null;
109
110		/**
111		* @param string $type
112		* @param string $name
113		* @param mixed $default Use null for no default (which makes the parameter required)
114		* @param string $message
115		* @param boolean $isList
116		*/
117		public function __construct( string $type, string $name, $default = null, string $message = null, bool $isList = false ) {
118	42	$this->type = $type;
119	42	$this->name = $name;
120	42	$this->default = $default;
121	42	$this->message = $message ?? 'validator-message-nodesc';
122	42	$this->isList = $isList;
123	42
124		$this->postConstruct();
125	42	}
126	42
127		/**
128		* Allows deriving classed to do additional stuff on instance construction
129		* without having to get and pass all the constructor arguments.
130		*
131		* @since 1.0
132		*/
133		protected function postConstruct() {
134	42
135		}
136	42
137		/**
138		* Returns if the value should be trimmed before validation and any further processing.
139		* - true: always trim
140		* - false: never trim
141		* - null: trim based on context settings
142		*/
143		public function trimDuringClean(): ?bool {
144	64	return $this->trimValue;
145	64	}
146
147		/**
148		* Returns the parameter name aliases.
149		* @return string[]
150		*/
151		public function getAliases(): array {
152		return $this->aliases;
153		}
154
155		public function hasAlias( string $alias ): bool {
156		return in_array( $alias, $this->getAliases() );
157		}
158
159		/**
160		* @deprecated since 1.7
161		* Returns if the parameter has a certain dependency.
162		*/
163		public function hasDependency( string $dependency ): bool {
164		return in_array( $dependency, $this->getDependencies() );
		0 ignored issues – show Deprecated Code introduced 2019-07-29 18:40 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `ParamProcessor\ParamDefinition::getDependencies()` has been deprecated with message: since 1.7 Returns a list of dependencies the parameter has, in the form of other parameter names. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
165		}
166
167		/**
168		* Returns the list of allowed values, or an empty array if there is no such restriction.
169		*/
170		public function getAllowedValues(): array {
171		$allowedValues = [];
172
173		if ( $this->validator !== null && method_exists( $this->validator, 'getWhitelistedValues' ) ) {
174		if ( method_exists( $this->validator, 'setOptions' ) ) {
175		$this->validator->setOptions( $this->options );
176		}
177
178		$allowedValues = $this->validator->getWhitelistedValues();
179
180		if ( $allowedValues === false ) {
181		$allowedValues = [];
182		}
183		}
184
185		return $allowedValues;
186		}
187
188		/**
189		* @deprecated since 1.7
190		*
191		* @param mixed $default
192		* @param boolean $manipulate Should the default be manipulated or not? Since 0.4.6.
193		*/
194		public function setDefault( $default, $manipulate = true ) {
195		$this->default = $default;
196		$this->setDoManipulationOfDefault( $manipulate );
197		}
198
199		/**
200		* Returns the default value.
201		* @return mixed
202		*/
203	1	public function getDefault() {
204	1	return $this->default;
205		}
206
207		/**
208		* Returns a message describing the parameter.
209		*/
210	5	public function getMessage(): string {
211	5	return $this->message;
212		}
213
214		/**
215		* This should be a message key, ie something that can be passed
216		* to wfMsg. Not an actual text.
217		*/
218		public function setMessage( string $message ) {
219		$this->message = $message;
220		}
221
222		/**
223		* Set if the parameter manipulations should be applied to the default value.
224		*/
225		public function setDoManipulationOfDefault( bool $doOrDoNotThereIsNoTry ) {
226		$this->applyManipulationsToDefault = $doOrDoNotThereIsNoTry;
227		}
228
229	56	public function shouldManipulateDefault(): bool {
230	56	return $this->applyManipulationsToDefault;
231		}
232
233		/**
234		* Adds one or more aliases for the parameter name.
235		*
236		* @param string\|string[] $aliases
237		*/
238		public function addAliases( $aliases ) {
239		$args = func_get_args();
240		$this->aliases = array_merge( $this->aliases, is_array( $args[0] ) ? $args[0] : $args );
241		}
242
243		/**
244		* Adds one or more dependencies. There are the names of parameters
245		* that need to be validated and formatted before this one.
246		*
247		* @param string\|string[] $dependencies
248		*/
249		public function addDependencies( $dependencies ) {
250		$args = func_get_args();
251		$this->dependencies = array_merge( $this->dependencies, is_array( $args[0] ) ? $args[0] : $args );
252		}
253
254	68	public function getName(): string {
255	68	return $this->name;
256		}
257
258		/**
259		* Returns a message key for a message describing the parameter type.
260		*/
261		public function getTypeMessage(): string {
262		$message = 'validator-type-' . $this->getType();
263
264		if ( $this->isList() ) {
265		$message .= '-list';
266		}
267
268		return $message;
269		}
270
271		/**
272		* @deprecated since 1.7
273		* Returns a list of dependencies the parameter has, in the form of
274		* other parameter names.
275		*
276		* @return string[]
277		*/
278		public function getDependencies(): array {
279		return $this->dependencies;
280		}
281	22
282	22	public function isRequired(): bool {
283		return is_null( $this->default );
284		}
285	64
286	64	public function isList(): bool {
287		return $this->isList;
288		}
289
290		/**
291		* Returns the delimiter to use to split the raw value in case the
292		* parameter is a list.
293		*/
294		public function getDelimiter(): string {
295		return $this->delimiter;
296		}
297
298		/**
299		* Sets the delimiter to use to split the raw value in case the
300		* parameter is a list.
301		*/
302		public function setDelimiter( string $delimiter ) {
303		$this->delimiter = $delimiter;
304		}
305
306		/**
307		* Sets the parameter definition values contained in the provided array.
308		*
309		* @deprecated since 1.7
310	36	* TODO: provide alternative in ParamDefinitionFactory
311	36	*/
312		public function setArrayValues( array $param ) {
313		if ( array_key_exists( 'aliases', $param ) ) {
314		$this->addAliases( $param['aliases'] );
315	36	}
316
317		if ( array_key_exists( 'dependencies', $param ) ) {
318		$this->addDependencies( $param['dependencies'] );
319	36	}
320
321		if ( array_key_exists( 'trim', $param ) ) {
322		$this->trimValue = $param['trim'];
323	36	}
324
325		if ( array_key_exists( 'delimiter', $param ) ) {
326		$this->delimiter = $param['delimiter'];
327	36	}
328
329		if ( array_key_exists( 'manipulatedefault', $param ) ) {
330		$this->setDoManipulationOfDefault( $param['manipulatedefault'] );
331	36	}
332	36
333		$this->options = $param;
334		}
335
336		/**
337		* @see IParamDefinition::format
338		*
339		* @deprecated
340		*
341		* @param IParam $param
342		* @param IParamDefinition[] $definitions
343	56	* @param IParam[] $params
344		*/
345		public function format( IParam $param, array &$definitions, array $params ) {
346		/**
347		* @var Param $param
348	56	*/
349
350		if ( $this->isList() && is_array( $param->getValue() ) ) {
351		// TODO: if isList returns true, the value should be an array.
352		// The second check here is to avoid a mysterious error.
353		// Should have logging that writes down the value whenever this occurs.
354
355		$values = $param->getValue();
356
357		foreach ( $values as &$value ) {
358		$value = $this->formatValue( $value, $param, $definitions, $params );
359		}
360
361		$param->setValue( $values );
362		$this->formatList( $param, $definitions, $params );
363	56	}
364		else {
365		$param->setValue( $this->formatValue( $param->getValue(), $param, $definitions, $params ) );
366		}
367	56
368		// deprecated, deriving classes should not add array-definitions to the list
369	56	$definitions = self::getCleanDefinitions( $definitions );
370
371		if ( array_key_exists( 'post-format', $this->options ) ) {
372	56	$param->setValue( call_user_func( $this->options['post-format'], $param->getValue() ) );
373		}
374		}
375
376		/**
377		* Formats the parameters values to their final result.
378		*
379		* @since 1.0
380		* @deprecated
381		*
382		* @param $param IParam
383		* @param $definitions array of IParamDefinition
384		* @param $params array of IParam
385		*/
386		protected function formatList( IParam $param, array &$definitions, array $params ) {
387		}
388
389		/**
390		* Formats the parameter value to it's final result.
391		*
392		* @since 1.0
393		* @deprecated
394		*
395		* @param mixed $value
396		* @param IParam $param
397		* @param IParamDefinition[] $definitions
398		* @param IParam[] $params
399		*
400	42	* @return mixed
401	42	*/
402		protected function formatValue( $value, IParam $param, array &$definitions, array $params ) {
403		return $value;
404		}
405
406		/**
407		* Returns a cleaned version of the list of parameter definitions.
408		* This includes having converted all supported definition types to
409		* ParamDefinition classes and having all keys set to the names of the
410		* corresponding parameters.
411		*
412		* @deprecated since 1.7 - use ParamDefinitionFactory
413		*
414		* @param ParamDefinition[] $definitions
415		*
416		* @return ParamDefinition[]
417	56	* @throws Exception
418	56	*/
419		public static function getCleanDefinitions( array $definitions ): array {
420	56	$cleanList = [];
421
422		foreach ( $definitions as $key => $definition ) {
423		if ( is_array( $definition ) ) {
424		if ( !array_key_exists( 'name', $definition ) && is_string( $key ) ) {
425		$definition['name'] = $key;
426		}
427
428		$definition = ParamDefinitionFactory::singleton()->newDefinitionFromArray( $definition );
429		}
430
431		if ( !( $definition instanceof IParamDefinition ) ) {
432		throw new Exception( '$definition not an instance of IParamDefinition' );
433		}
434
435		$cleanList[$definition->getName()] = $definition;
436	56	}
437
438		return $cleanList;
439		}
440
441		/**
442	80	* Returns an identifier for the type of the parameter.
443	80	*/
444		public function getType(): string {
445		return $this->type;
446		}
447
448		/**
449	64	* Returns a ValueParser object to parse the parameters value.
450	64	*/
451	64	public function getValueParser(): ValueParser {
452		if ( $this->parser === null ) {
453		$this->parser = new NullParser();
454	64	}
455
456		return $this->parser;
457		}
458
459		/**
460	64	* Returns a ValueValidator that can be used to validate the parameters value.
461	64	*/
462	2	public function getValueValidator(): ValueValidator {
463		if ( $this->validator === null ) {
464		$this->validator = new NullValidator();
465	64	}
466
467		return $this->validator;
468		}
469
470		public function setValueParser( ValueParser $parser ) {
471		$this->parser = $parser;
472	36	}
473	36
474	36	public function setValueValidator( ValueValidator $validator ) {
475		$this->validator = $validator;
476		}
477
478		/**
479		* Sets a validation function that will be run before the ValueValidator.
480		*
481		* This can be used instead of a ValueValidator where validation is very
482	36	* trivial, ie checking if something is a boolean can be done with is_bool.
483	36	*/
484	36	public function setValidationCallback( ?callable $validationFunction ) {
485		$this->validationFunction = $validationFunction;
486		}
487
488		/**
489	64	* @see setValidationCallback
490	64	*/
491		public function getValidationCallback(): ?callable {
492		return $this->validationFunction;
493	64	}
494	64
495		public function getOptions(): array {
496		return $this->options;
497		}
498
499		}
500

JeroenDeDauw / ParamProcessor

Push — master ( 761e95...f1e6ba )

src/ParamDefinition.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like