Argument::longPrefix() - Code Metrics - Inspection of "Merge pull request #111 from bwoebi/allow_array_ar..." - thephpleague/climate - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 062416...0a3b5a )

by Craig

created 2018-07-10 17:44 UTC

Argument::longPrefix() A

↳ Parent: Argument

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace League\CLImate\Argument;

class Argument
{
    /**
     * An argument's name.
     *
     * Use this name when internally referring to the argument.
     *
     * @var string
     */
    protected $name;

    /**
     * An argument's short representation.
     *
     * @var string
     */
    protected $prefix;

    /**
     * An argument's long representation.
     *
     * @var string
     */
    protected $longPrefix;

    /**
     * An argument's description.
     *
     * @var string
     */
    protected $description;

    /**
     * Whether or not an argument is required.
     *
     * @var bool
     */
    protected $required = false;

    /**
     * Whether or not an argument only needs to be defined to have a value.
     *
     * These arguments have the value true when they are defined on the command
     * line.
     *
     * @var bool
     */
    protected $noValue = false;

    /**
     * Which data type to cast an argument's value to.
     *
     * Valid data types are "string", "int", "float", and "bool".
     *
     * @var string
     */
    protected $castTo = 'string';

    /**
     * An argument's default value.
     *
     * @var string
     */
    protected $defaultValue = [];

    /**
     * An argument's value, after type casting.
     *
     * @var string[]|int[]|float[]|bool[]
     */
    protected $values = [];

    /**
     * Build a new command argument.
     *
     * @param string $name
     */
    public function __construct($name)
    {
        $this->setName($name);
    }

    /**
     * Build a new command argument from an array.
     *
     * @param string $name
     * @param array $params
     *
     * @return Argument
     */
    public static function createFromArray($name, array $params)
    {
        $argument = new Argument($name);
        $params   = self::getSettableArgumentParams($params);

        foreach ($params as $key => $value) {
            $method = 'set' . ucwords($key);
            $argument->{$method}($value);
        }

        return $argument;
    }

    /**
     * Get argument params based on settable properties
     *
     * @param array $params
     *
     * @return array
     */
    protected static function getSettableArgumentParams(array $params)
    {
        $allowed = [
                    'prefix',
                    'longPrefix',
                    'description',
                    'required',
                    'noValue',
                    'castTo',
                    'defaultValue',
                ];

        return array_intersect_key($params, array_flip($allowed));
    }

    /**
     * Retrieve an argument's name.
     *
     * Use this name when internally referring to the argument.
     *
     * @return string
     */
    public function name()
    {
        return $this->name;
    }

    /**
     * Set an argument's name.
     *
     * Use this name when internally referring to the argument.
     *
     * @param string $name
     */
    protected function setName($name)
    {
        $this->name = trim($name);
    }

    /**
     * Retrieve an argument's short form.
     *
     * @return string
     */
    public function prefix()
    {
        return $this->prefix;
    }

    /**
     * Set an argument's short form.
     *
     * @param string $prefix
     */
    protected function setPrefix($prefix)
    {
        $this->prefix = trim($prefix);
    }

    /**
     * Retrieve an argument's long form.
     *
     * @return string
     */
    public function longPrefix()
    {
        return $this->longPrefix;
    }

    /**
     * Set an argument's short form.
     *
     * @param string $longPrefix
     */
    protected function setLongPrefix($longPrefix)
    {
        $this->longPrefix = trim($longPrefix);
    }

    /**
     * Determine if an argument has a prefix.
     *
     * @return bool
     */
    public function hasPrefix()
    {
        return $this->prefix() || $this->longPrefix();
    }

    /**
     * Retrieve an argument's description.
     *
     * @return string
     */
    public function description()
    {
        return $this->description;
    }

    /**
     * Set an argument's description.
     *
     * @param string $description
     */
    protected function setDescription($description)
    {
        $this->description = trim($description);
    }

    /**
     * Determine whether or not an argument is required.
     *
     * @return bool
     */
    public function isRequired()
    {
        return $this->required;
    }

    /**
     * Set whether an argument is required or not.
     *
     * @param bool $required
     */
    protected function setRequired($required)
    {
        $this->required = (bool) $required;
    }

    /**
     * Determine whether or not an argument only needs to be defined to have a
     * value.
     *
     * @return bool
     */
    public function noValue()
    {
        return $this->noValue;
    }

    /**
     * Set whether or not an argument only needs to be defined to have a value.
     *
     * @param bool $noValue
     */
    protected function setNoValue($noValue)
    {
        $this->setCastTo('bool');
        $this->noValue = (bool) $noValue;
    }

    /**
     * Retrieve the data type to cast an argument's value to.
     *
     * @return string
     */
    public function castTo()
    {
        return $this->castTo;
    }

    /**
     * Set the data type to cast an argument's value to.
     *
     * Valid data types are "string", "int", "float", and "bool".
     *
     * @throws \Exception if $castTo is not a valid data type.
     * @param string $castTo
     */
    protected function setCastTo($castTo)
    {
        if (!in_array($castTo, ['string', 'int', 'float', 'bool'])) {
            throw new \Exception(
                "An argument may only be cast to the data type "
                . "'string', 'int', 'float', or 'bool'."
            );
        }

        $this->castTo = $this->noValue() ? 'bool' : $castTo;
    }

    /**
     * Retrieve an argument's default values.
     *
     * @return string
     */
    public function defaultValue()
    {
        return $this->defaultValue;
    }

    /**
     * Set an argument's default value.
     *
     * @param string $defaultValue
     */
    public function setDefaultValue($defaultValue)
    {
        $this->defaultValue = (array) $defaultValue;

    }

    /**
     * Retrieve an argument's value.
     *
     * Argument values are type cast based on the value of $castTo.
     *
     * @return string|int|float|bool
     */
    public function value()
    {
        if ($this->values) {

            return end($this->values);
        }
        $cast_method = 'castTo' . ucwords($this->castTo);
        return $this->{$cast_method}(current($this->defaultValue()));
    }

    /**
     * Retrieve an argument's value.
     *
     * Argument values are type cast based on the value of $castTo.
     *
     * @return string[]|int[]|float[]|bool[]
     */
    public function valueArray()
    {
        if ($this->values) {

            return $this->values;
        }
        $cast_method = 'castTo' . ucwords($this->castTo);
        return array_map([$this, $cast_method], $this->defaultValue());
    }

    /**
     * Set an argument's value based on its command line entry.
     *
     * Argument values are type cast based on the value of $castTo.
     *
     * @param string|bool $value
     */
    public function setValue($value)
    {
        $cast_method = 'castTo' . ucwords($this->castTo);
        $this->values[] = $this->{$cast_method}($value);
    }

    /**
     * @param string $value
     *
     * @return string
     */
    protected function castToString($value)
    {
        return (string) $value;
    }

    /**
     * @param string $value
     *
     * @return int
     */
    protected function castToInt($value)
    {
        return (int) $value;
    }

    /**
     * @param string $value
     *
     * @return float
     */
    protected function castToFloat($value)
    {
        return (float) $value;
    }

    /**
     * @param string $value
     *
     * @return bool
     */
    protected function castToBool($value)
    {
        return (bool) $value;
    }
}


1		<?php
2
3		namespace League\CLImate\Argument;
4
5		class Argument
6		{
7		/**
8		* An argument's name.
9		*
10		* Use this name when internally referring to the argument.
11		*
12		* @var string
13		*/
14		protected $name;
15
16		/**
17		* An argument's short representation.
18		*
19		* @var string
20		*/
21		protected $prefix;
22
23		/**
24		* An argument's long representation.
25		*
26		* @var string
27		*/
28		protected $longPrefix;
29
30		/**
31		* An argument's description.
32		*
33		* @var string
34		*/
35		protected $description;
36
37		/**
38		* Whether or not an argument is required.
39		*
40		* @var bool
41		*/
42		protected $required = false;
43
44		/**
45		* Whether or not an argument only needs to be defined to have a value.
46		*
47		* These arguments have the value true when they are defined on the command
48		* line.
49		*
50		* @var bool
51		*/
52		protected $noValue = false;
53
54		/**
55		* Which data type to cast an argument's value to.
56		*
57		* Valid data types are "string", "int", "float", and "bool".
58		*
59		* @var string
60		*/
61		protected $castTo = 'string';
62
63		/**
64		* An argument's default value.
65		*
66		* @var string
67		*/
68		protected $defaultValue = [];
69
70		/**
71		* An argument's value, after type casting.
72		*
73		* @var string[]\|int[]\|float[]\|bool[]
74		*/
75		protected $values = [];
76
77		/**
78		* Build a new command argument.
79		*
80		* @param string $name
81		*/
82	48	public function __construct($name)
83		{
84	48	$this->setName($name);
85	48	}
86
87		/**
88		* Build a new command argument from an array.
89		*
90		* @param string $name
91		* @param array $params
92		*
93		* @return Argument
94		*/
95	48	public static function createFromArray($name, array $params)
96		{
97	48	$argument = new Argument($name);
98	48	$params = self::getSettableArgumentParams($params);
99
100	48	foreach ($params as $key => $value) {
101	48	$method = 'set' . ucwords($key);
102	48	$argument->{$method}($value);
103	44	}
104
105	44	return $argument;
106	8	}
107	8
108		/**
109	44	* Get argument params based on settable properties
110		*
111		* @param array $params
112		*
113		* @return array
114		*/
115		protected static function getSettableArgumentParams(array $params)
116		{
117		$allowed = [
118		'prefix',
119	48	'longPrefix',
120		'description',
121		'required',
122	48	'noValue',
123	48	'castTo',
124	48	'defaultValue',
125	48	];
126	48
127	48	return array_intersect_key($params, array_flip($allowed));
128	48	}
129	48
130		/**
131	48	* Retrieve an argument's name.
132		*
133		* Use this name when internally referring to the argument.
134		*
135		* @return string
136		*/
137		public function name()
138		{
139		return $this->name;
140		}
141	24
142		/**
143	24	* Set an argument's name.
144		*
145		* Use this name when internally referring to the argument.
146		*
147		* @param string $name
148		*/
149		protected function setName($name)
150		{
151		$this->name = trim($name);
152		}
153	48
154		/**
155	48	* Retrieve an argument's short form.
156	48	*
157		* @return string
158		*/
159		public function prefix()
160		{
161		return $this->prefix;
162		}
163	24
164		/**
165	24	* Set an argument's short form.
166		*
167		* @param string $prefix
168		*/
169		protected function setPrefix($prefix)
170		{
171		$this->prefix = trim($prefix);
172		}
173	20
174		/**
175	20	* Retrieve an argument's long form.
176	20	*
177		* @return string
178		*/
179		public function longPrefix()
180		{
181		return $this->longPrefix;
182		}
183	24
184		/**
185	24	* Set an argument's short form.
186		*
187		* @param string $longPrefix
188		*/
189		protected function setLongPrefix($longPrefix)
190		{
191		$this->longPrefix = trim($longPrefix);
192		}
193	20
194		/**
195	20	* Determine if an argument has a prefix.
196	20	*
197		* @return bool
198		*/
199		public function hasPrefix()
200		{
201		return $this->prefix() \|\| $this->longPrefix();
202		}
203	20
204		/**
205	20	* Retrieve an argument's description.
206		*
207		* @return string
208		*/
209		public function description()
210		{
211		return $this->description;
212		}
213	4
214		/**
215	4	* Set an argument's description.
216		*
217		* @param string $description
218		*/
219		protected function setDescription($description)
220		{
221		$this->description = trim($description);
222		}
223	4
224		/**
225	4	* Determine whether or not an argument is required.
226	4	*
227		* @return bool
228		*/
229		public function isRequired()
230		{
231		return $this->required;
232		}
233	20
234		/**
235	20	* Set whether an argument is required or not.
236		*
237		* @param bool $required
238		*/
239		protected function setRequired($required)
240		{
241		$this->required = (bool) $required;
242		}
243	8
244		/**
245	8	* Determine whether or not an argument only needs to be defined to have a
246	8	* value.
247		*
248		* @return bool
249		*/
250		public function noValue()
251		{
252		return $this->noValue;
253		}
254	40
255		/**
256	40	* Set whether or not an argument only needs to be defined to have a value.
257		*
258		* @param bool $noValue
259		*/
260		protected function setNoValue($noValue)
261		{
262		$this->setCastTo('bool');
263		$this->noValue = (bool) $noValue;
264	12	}
265
266	12	/**
267	12	* Retrieve the data type to cast an argument's value to.
268	12	*
269		* @return string
270		*/
271		public function castTo()
272		{
273		return $this->castTo;
274		}
275	4
276		/**
277	4	* Set the data type to cast an argument's value to.
278		*
279		* Valid data types are "string", "int", "float", and "bool".
280		*
281		* @throws \Exception if $castTo is not a valid data type.
282		* @param string $castTo
283		*/
284		protected function setCastTo($castTo)
285		{
286		if (!in_array($castTo, ['string', 'int', 'float', 'bool'])) {
287		throw new \Exception(
288	32	"An argument may only be cast to the data type "
289		. "'string', 'int', 'float', or 'bool'."
290	32	);
291	4	}
292
293		$this->castTo = $this->noValue() ? 'bool' : $castTo;
294	4	}
295
296		/**
297	28	* Retrieve an argument's default values.
298	28	*
299		* @return string
300		*/
301		public function defaultValue()
302		{
303		return $this->defaultValue;
304		}
305	44
306		/**
307	44	* Set an argument's default value.
308		*
309		* @param string $defaultValue
310		*/
311		public function setDefaultValue($defaultValue)
312		{
313		$this->defaultValue = (array) $defaultValue;
		0 ignored issues – show Documentation Bug introduced 2017-07-03 20:40 UTC by Report Bug Copy Issue Report It seems like `(array) $defaultValue` of type `array` is incompatible with the declared type `string` of property `$defaultValue`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
314		}
315	8
316		/**
317	8	* Retrieve an argument's value.
318	8	*
319		* Argument values are type cast based on the value of $castTo.
320		*
321		* @return string\|int\|float\|bool
322		*/
323		public function value()
324		{
325		if ($this->values) {
		0 ignored issues – show Bug Best Practice introduced 2017-07-03 20:40 UTC by Report Bug Copy Issue Report The expression `$this->values` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
326		return end($this->values);
327	28	}
328		$cast_method = 'castTo' . ucwords($this->castTo);
329	28	return $this->{$cast_method}(current($this->defaultValue()));
330		}
331
332		/**
333		* Retrieve an argument's value.
334		*
335		* Argument values are type cast based on the value of $castTo.
336		*
337		* @return string[]\|int[]\|float[]\|bool[]
338		*/
339	36	public function valueArray()
340		{
341	36	if ($this->values) {
		0 ignored issues – show Bug Best Practice introduced 2017-07-03 20:40 UTC by Report Bug Copy Issue Report The expression `$this->values` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
342	36	return $this->values;
343	36	}
344		$cast_method = 'castTo' . ucwords($this->castTo);
345		return array_map([$this, $cast_method], $this->defaultValue());
346		}
347
348		/**
349		* Set an argument's value based on its command line entry.
350	24	*
351		* Argument values are type cast based on the value of $castTo.
352	24	*
353		* @param string\|bool $value
354		*/
355		public function setValue($value)
356		{
357		$cast_method = 'castTo' . ucwords($this->castTo);
358		$this->values[] = $this->{$cast_method}($value);
359		}
360	4
361		/**
362	4	* @param string $value
363		*
364		* @return string
365		*/
366		protected function castToString($value)
367		{
368		return (string) $value;
369		}
370	4
371		/**
372	4	* @param string $value
373		*
374		* @return int
375		*/
376		protected function castToInt($value)
377		{
378		return (int) $value;
379		}
380	8
381		/**
382	8	* @param string $value
383		*
384		* @return float
385		*/
386		protected function castToFloat($value)
387		{
388		return (float) $value;
389		}
390
391		/**
392		* @param string $value
393		*
394		* @return bool
395		*/
396		protected function castToBool($value)
397		{
398		return (bool) $value;
399		}
400		}
401

thephpleague / climate

Push — master ( 062416...0a3b5a )

Argument::longPrefix() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like