SimpleTypeBase::setWhiteSpaceHandle() - Code Metrics - Inspection of "Apply fixes from StyleCI" - Algo-Web/xsdTypes - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Christopher

created 2017-05-31 17:14 UTC

SimpleTypeBase::setWhiteSpaceHandle() A

↳ Parent: SimpleTypeBase

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	4
nc	2
nop	1

<?php
namespace AlgoWeb\xsdTypes;

/**
 * Base Class representing xsd anySimpleTypes
 * @property-write array $enumeration Defines a list of acceptable values
 * @property-write integer $fractionDigits Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero
 * @property-write integer $length Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero
 * @property-write integer $maxExclusive Specifies the upper bounds for numeric values (the value must be less than this value)
 * @property-write integer $maxInclusive Specifies the upper bounds for numeric values (the value must be less than or equal to this value)
 * @property-write integer $maxLength Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
 * @property-write integer $minExclusive Specifies the lower bounds for numeric values (the value must be greater than this value)
 * @property-write integer $minInclusive Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
 * @property-write integer $minLength Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
 * @property-write string $pattern Defines the exact sequence of characters that are acceptable
 * @property-write integer $totalDigits Specifies the exact number of digits allowed. Must be greater than zero
 * @property-write string $whiteSpace Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled
 */
abstract class SimpleTypeBase
{
    /**
     * @Exclude
     * @var array Defines a list of acceptable values
     */
    private $enumeration = array();
    /**
     * @Exclude
     * @var integer Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
     */
    private $maxLength = null;
    /**
     * @Exclude
     * @var integer Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero
     */
    private $minLength = null;
    /**
     * @Exclude
     * @var string Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled
     */
    private $whiteSpace = "preserve";
    /**
     * @Exclude
     * @var string Defines the exact sequence of characters that are acceptable
     */
    private $pattern = null;
    /**
     * @Exclude
     * @var string Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero
     */
    private $fractionDigits = null;
    /**
     * @Exclude
     * @var integer Specifies the lower bounds for numeric values (the value must be greater than this value)
     */
    private $minExclusive = null;
    /**
     * @Exclude
     * @var integer Specifies the upper bounds for numeric values (the value must be less than this value)
     */
    private $maxExclusive = null;

    /**
     * @property mixed $__value
     */
    private $__value = null;

    /**
     * Construct
     *
     * @param mixed $value
     */
    public function __construct($value)
    {
        $this->value($value);
    }

    /**
     * Gets or sets the inner value
     *
     * @param mixed ...$value
     * @return mixed
     * @throws \Exception
     */
    public function value(...$value)
    {
        if (0 >= count($value)) {
            return $this->__value;
        }
        $v = $this->fixValue($value[0]);
        $this->isBaseValid($v);
        $this->__value = $v;
        return $v;
    }

    protected function fixValue($v)
    {
        return $this->fixWhitespace($v, $this->whiteSpace);
    }

    protected function fixWhitespace($val, $handle = "preserve")
    {
        switch ($handle) {
            case "preserve":
                return $val;
            case "replace":
                return preg_replace('/\s/', ' ', $val);
            case "collapse":
                return preg_replace('/\s+/', ' ', $val);
            default:
                throw new \InvalidArgumentException(__CLASS__ . " Called Fix whitespace with invalid handle operation");
        }
    }

    private function isBaseValid($v)
    {
        $this->checkMinLength($v);
        $this->checkMaxLength($v);
        $this->checkEnumeration($v);
        $this->checkPattern($v);
        $this->isValid($v);
    }

    private function checkMinLength($v)

    {
        $stringLen = strlen($v);
        if ($this->minLength != null) {
            if ($stringLen > $this->minLength) {
                throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is to long minLength: "
                    . $this->minLength);
            }
        }
    }

    private function checkMaxLength($v)

    {
        $stringLen = strlen($v);
        if ($this->maxLength != null) {
            if ($stringLen < $this->maxLength) {
                throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is to short MaxLength: "
                    . $this->maxLength);
            }
        }
    }

    private function checkEnumeration($v)
    {
        if (is_array($this->enumeration) && !in_array($v, $this->enumeration)) {
            throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is not " .
                implode(" || ", $this->enumeration));
        }
    }

    private function checkPattern($v)
    {
        if ($this->pattern != null) {
            if (!$this->matchesRegexPattern($this->pattern, $v)) {
                throw new \InvalidArgumentException("assigned value that dose not match pattern " . __CLASS__);
            }
        }
    }

    /**
     * Checks a pattern against a string
     * @param string $pattern the regex pattern
     * @param string $string the string to check
     * @return bool true if string matches pattern
     */
    private function matchesRegexPattern($pattern, $string)
    {
        $matches = null;
        return (1 == preg_match($pattern, $string, $matches) && $string == $matches[0]);
    }

    abstract protected function isValid($v);

    public function __set($name, $value)
    {
        switch ($name) {
            case "enumeration":
                $this->setEnumoration($value);
                return;
            case "totalDigits":
            case "length":
                $this->setMaxLength($value);
                $this->setMinLength($value);
                return;
            case "maxLength":
                $this->setMaxLength($value);
                return;
            case "minLength":
                $this->setMinLength($value);
                return;
            case "whiteSpaceHandle":
                $this->setWhiteSpaceHandle($value);
                return;
            case "pattern":
                $this->setPattern($value);
                return;
            default:
                $this->handleSetNumeric($name, $value);
        }
    }

    private function setEnumoration($value)
    {
        if (!is_array($value)) {
            throw new \InvalidArgumentException("enumoration values MUST be an array " . __CLASS__);
        }
        if (0 == count($value)) {
            throw new \InvalidArgumentException("enumoration values MUST have at least one value " . __CLASS__);
        }
        $this->enumeration = $value;
    }

    private function setMaxLength($value)
    {
        $this->checkLength($value);
        $this->maxLength = $value;
    }

    private function checkLength($value, $min = 0)
    {
        if (((int)$value) != $value) {
            throw new \InvalidArgumentException("length values MUST be castable to int " . __CLASS__);
        }
        if ($min >= $value) {
            throw new \InvalidArgumentException("length values MUST be greater then 0 " . __CLASS__);
        }
    }

    private function setMinLength($value)
    {
        $this->checkLength($value);
        $this->minLength = $value;
    }

    private function setWhiteSpaceHandle($value)
    {
        if (!in_array($value, ["preserve", "replace", "collapse"])) {
            throw new \InvalidArgumentException("Invalid white space handleing method " . __CLASS__);
        }
        $this->whiteSpace = $value;
    }

    private function setPattern($value)
    {
        if (!$this->checkRegexValidPattern($value)) {
            $value = "/" . $value . "/";
            if (!$this->checkRegexValidPattern($value)) {
                throw new \InvalidArgumentException("Invalid regex Pattern provided: " . __CLASS__);
            }
        }
        $this->pattern = $value;
    }

    private function checkRegexValidPattern($pattern)
    {
        return (@preg_match($pattern, null) === false);
    }

    private function handleSetNumeric($name, $value)
    {
        switch ($name) {

            case "fractionDigits":
                $this->setFractionDigits($value);
                return;
            case "minInclusive":
                $value--;
            // bump down by one to become MinExclusive
            case "minExclusive":
                $this->setMinExclusive($value);
                return;
            case "maxInclusive":
                $value++;
            // bump up by one to become MaxExclusive
            case "maxExclusive":
                $this->setMaxExclusive($value);
                return;
            default:
                throw new \InvalidArgumentException("Invalid parameters (facets) assignment for: " . __CLASS__);
        }
    }

    private function setFractionDigits($value)
    {
        $this->checkLength($value);
        $this->fractionDigits = $value;
    }

    private function setMinExclusive($value)
    {
        $this->checkLength($value, -1);
        $this->minExclusive = $value;
    }

    private function setMaxExclusive($value)
    {
        $this->checkLength($value);
        $this->maxExclusive = $value;
    }

    /**
     * Gets a string value
     *
     * @return string
     */
    public function __toString()
    {
        return strval($this->__value);
    }
}


1		<?php
2		namespace AlgoWeb\xsdTypes;
3
4		/**
5		* Base Class representing xsd anySimpleTypes
6		* @property-write array $enumeration Defines a list of acceptable values
7		* @property-write integer $fractionDigits Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero
8		* @property-write integer $length Specifies the exact number of characters or list items allowed. Must be equal to or greater than zero
9		* @property-write integer $maxExclusive Specifies the upper bounds for numeric values (the value must be less than this value)
10		* @property-write integer $maxInclusive Specifies the upper bounds for numeric values (the value must be less than or equal to this value)
11		* @property-write integer $maxLength Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
12		* @property-write integer $minExclusive Specifies the lower bounds for numeric values (the value must be greater than this value)
13		* @property-write integer $minInclusive Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
14		* @property-write integer $minLength Specifies the lower bounds for numeric values (the value must be greater than or equal to this value)
15		* @property-write string $pattern Defines the exact sequence of characters that are acceptable
16		* @property-write integer $totalDigits Specifies the exact number of digits allowed. Must be greater than zero
17		* @property-write string $whiteSpace Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled
18		*/
19		abstract class SimpleTypeBase
20		{
21		/**
22		* @Exclude
23		* @var array Defines a list of acceptable values
24		*/
25		private $enumeration = array();
26		/**
27		* @Exclude
28		* @var integer Specifies the maximum number of characters or list items allowed. Must be equal to or greater than zero
29		*/
30		private $maxLength = null;
31		/**
32		* @Exclude
33		* @var integer Specifies the minimum number of characters or list items allowed. Must be equal to or greater than zero
34		*/
35		private $minLength = null;
36		/**
37		* @Exclude
38		* @var string Specifies how white space (line feeds, tabs, spaces, and carriage returns) is handled
39		*/
40		private $whiteSpace = "preserve";
41		/**
42		* @Exclude
43		* @var string Defines the exact sequence of characters that are acceptable
44		*/
45		private $pattern = null;
46		/**
47		* @Exclude
48		* @var string Specifies the maximum number of decimal places allowed. Must be equal to or greater than zero
49		*/
50		private $fractionDigits = null;
51		/**
52		* @Exclude
53		* @var integer Specifies the lower bounds for numeric values (the value must be greater than this value)
54		*/
55		private $minExclusive = null;
56		/**
57		* @Exclude
58		* @var integer Specifies the upper bounds for numeric values (the value must be less than this value)
59		*/
60		private $maxExclusive = null;
61
62		/**
63		* @property mixed $__value
64		*/
65		private $__value = null;
66
67		/**
68		* Construct
69		*
70		* @param mixed $value
71		*/
72		public function __construct($value)
73		{
74		$this->value($value);
75		}
76
77		/**
78		* Gets or sets the inner value
79		*
80		* @param mixed ...$value
81		* @return mixed
82		* @throws \Exception
83		*/
84		public function value(...$value)
85		{
86		if (0 >= count($value)) {
87		return $this->__value;
88		}
89		$v = $this->fixValue($value[0]);
90		$this->isBaseValid($v);
91		$this->__value = $v;
92		return $v;
93		}
94
95		protected function fixValue($v)
96		{
97		return $this->fixWhitespace($v, $this->whiteSpace);
98		}
99
100		protected function fixWhitespace($val, $handle = "preserve")
101		{
102		switch ($handle) {
103		case "preserve":
104		return $val;
105		case "replace":
106		return preg_replace('/\s/', ' ', $val);
107		case "collapse":
108		return preg_replace('/\s+/', ' ', $val);
109		default:
110		throw new \InvalidArgumentException(__CLASS__ . " Called Fix whitespace with invalid handle operation");
111		}
112		}
113
114		private function isBaseValid($v)
115		{
116		$this->checkMinLength($v);
117		$this->checkMaxLength($v);
118		$this->checkEnumeration($v);
119		$this->checkPattern($v);
120		$this->isValid($v);
121		}
122
123	View Code Duplication	private function checkMinLength($v)
		1 ignored issue – show Duplication introduced 2017-05-31 17:00 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
124		{
125		$stringLen = strlen($v);
126		if ($this->minLength != null) {
127		if ($stringLen > $this->minLength) {
128		throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is to long minLength: "
129		. $this->minLength);
130		}
131		}
132		}
133
134	View Code Duplication	private function checkMaxLength($v)
		1 ignored issue – show Duplication introduced 2017-05-31 17:00 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
135		{
136		$stringLen = strlen($v);
137		if ($this->maxLength != null) {
138		if ($stringLen < $this->maxLength) {
139		throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is to short MaxLength: "
140		. $this->maxLength);
141		}
142		}
143		}
144
145		private function checkEnumeration($v)
146		{
147		if (is_array($this->enumeration) && !in_array($v, $this->enumeration)) {
148		throw new \InvalidArgumentException("the provided value for " . __CLASS__ . " is not " .
149		implode(" \|\| ", $this->enumeration));
150		}
151		}
152
153		private function checkPattern($v)
154		{
155		if ($this->pattern != null) {
156		if (!$this->matchesRegexPattern($this->pattern, $v)) {
157		throw new \InvalidArgumentException("assigned value that dose not match pattern " . __CLASS__);
158		}
159		}
160		}
161
162		/**
163		* Checks a pattern against a string
164		* @param string $pattern the regex pattern
165		* @param string $string the string to check
166		* @return bool true if string matches pattern
167		*/
168		private function matchesRegexPattern($pattern, $string)
169		{
170		$matches = null;
171		return (1 == preg_match($pattern, $string, $matches) && $string == $matches[0]);
172		}
173
174		abstract protected function isValid($v);
175
176		public function __set($name, $value)
177		{
178		switch ($name) {
179		case "enumeration":
180		$this->setEnumoration($value);
181		return;
182		case "totalDigits":
183		case "length":
184		$this->setMaxLength($value);
185		$this->setMinLength($value);
186		return;
187		case "maxLength":
188		$this->setMaxLength($value);
189		return;
190		case "minLength":
191		$this->setMinLength($value);
192		return;
193		case "whiteSpaceHandle":
194		$this->setWhiteSpaceHandle($value);
195		return;
196		case "pattern":
197		$this->setPattern($value);
198		return;
199		default:
200		$this->handleSetNumeric($name, $value);
201		}
202		}
203
204		private function setEnumoration($value)
205		{
206		if (!is_array($value)) {
207		throw new \InvalidArgumentException("enumoration values MUST be an array " . __CLASS__);
208		}
209		if (0 == count($value)) {
210		throw new \InvalidArgumentException("enumoration values MUST have at least one value " . __CLASS__);
211		}
212		$this->enumeration = $value;
213		}
214
215		private function setMaxLength($value)
216		{
217		$this->checkLength($value);
218		$this->maxLength = $value;
219		}
220
221		private function checkLength($value, $min = 0)
222		{
223		if (((int)$value) != $value) {
224		throw new \InvalidArgumentException("length values MUST be castable to int " . __CLASS__);
225		}
226		if ($min >= $value) {
227		throw new \InvalidArgumentException("length values MUST be greater then 0 " . __CLASS__);
228		}
229		}
230
231		private function setMinLength($value)
232		{
233		$this->checkLength($value);
234		$this->minLength = $value;
235		}
236
237		private function setWhiteSpaceHandle($value)
238		{
239		if (!in_array($value, ["preserve", "replace", "collapse"])) {
240		throw new \InvalidArgumentException("Invalid white space handleing method " . __CLASS__);
241		}
242		$this->whiteSpace = $value;
243		}
244
245		private function setPattern($value)
246		{
247		if (!$this->checkRegexValidPattern($value)) {
248		$value = "/" . $value . "/";
249		if (!$this->checkRegexValidPattern($value)) {
250		throw new \InvalidArgumentException("Invalid regex Pattern provided: " . __CLASS__);
251		}
252		}
253		$this->pattern = $value;
254		}
255
256		private function checkRegexValidPattern($pattern)
257		{
258		return (@preg_match($pattern, null) === false);
259		}
260
261		private function handleSetNumeric($name, $value)
262		{
263		switch ($name) {
264
265		case "fractionDigits":
266		$this->setFractionDigits($value);
267		return;
268		case "minInclusive":
269		$value--;
270		// bump down by one to become MinExclusive
271		case "minExclusive":
272		$this->setMinExclusive($value);
273		return;
274		case "maxInclusive":
275		$value++;
276		// bump up by one to become MaxExclusive
277		case "maxExclusive":
278		$this->setMaxExclusive($value);
279		return;
280		default:
281		throw new \InvalidArgumentException("Invalid parameters (facets) assignment for: " . __CLASS__);
282		}
283		}
284
285		private function setFractionDigits($value)
286		{
287		$this->checkLength($value);
288		$this->fractionDigits = $value;
289		}
290
291		private function setMinExclusive($value)
292		{
293		$this->checkLength($value, -1);
294		$this->minExclusive = $value;
295		}
296
297		private function setMaxExclusive($value)
298		{
299		$this->checkLength($value);
300		$this->maxExclusive = $value;
301		}
302
303		/**
304		* Gets a string value
305		*
306		* @return string
307		*/
308		public function __toString()
309		{
310		return strval($this->__value);
311		}
312		}
313

Algo-Web / xsdTypes

Pull Request — master (#2)

SimpleTypeBase::setWhiteSpaceHandle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like