Rules::applyUnionRules() - Code Metrics - Inspection of "issue #84 - add unit test for union" - WsdlToPhp/PackageGenerator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/issue-84 ( 44128e...1e0a90 )

by Mikaël

created 2017-04-04 20:20 UTC

Rules::applyUnionRules() A

↳ Parent: Rules

Complexity

Conditions	3
Paths	3

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	7
cts	7
cp	1
rs	9.6666
c	0
b	0
f	0
cc	3
eloc	5
nc	3
nop	3
crap	3

<?php

namespace WsdlToPhp\PackageGenerator\File\Validation;

use WsdlToPhp\PackageGenerator\Model\StructAttribute;
use WsdlToPhp\PhpGenerator\Element\PhpMethod;
use WsdlToPhp\PackageGenerator\File\AbstractModelFile;
use WsdlToPhp\PackageGenerator\Model\Struct;
use WsdlToPhp\PackageGenerator\Model\AbstractModel;

class Rules
{
    /**
     * @var StructAttribute
     */
    private $attribute;
    /**
     * @var AbstractModelFile
     */
    private $file;
    /**
     * @var PhpMethod
     */
    private $method;
    /**
     * @param AbstractModelFile $file
     * @param PhpMethod $method
     * @param StructAttribute $attribute
     */
    public function __construct(AbstractModelFile $file, PhpMethod $method, StructAttribute $attribute)
    {
        $this->setFile($file)->setMethod($method)->setAttribute($attribute);
    }
    /**
     * @param string $parameterName
     * @param bool $itemType
     */
    public function applyRules($parameterName, $itemType = false)
    {
        $this->applyRulesFromModel($this->attribute, $parameterName, $itemType);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        if ($this->getAttribute()->isArray() && !$itemType) {
            $this->getArrayRule()->applyRule($parameterName, null, $itemType);
        } elseif ($this->getFile()->getRestrictionFromStructAttribute($this->getAttribute())) {
            $this->getEnumerationRule()->applyRule($parameterName, null, $itemType);
        } elseif ($itemType) {
            $this->getItemTypeRule()->applyRule($parameterName, null, $itemType);
        } elseif (($rule = $this->getRule($this->getFile()->getStructAttributeTypeAsPhpType($this->getAttribute()))) instanceof AbstractRule) {
            $rule->applyRule($parameterName, null, $itemType);
        }
    }
    /**
     * This method is called when an attribute has a union meta which means the attribute is of several types.
     * In this case, the types are currently only of type string (normally) so we add the rules according to each type
     * @param string $parameterName
     * @param string $itemType
     * @param array $unionTypes
     */
    protected function applyUnionRules($parameterName, $itemType, array $unionTypes)
    {
        foreach ($unionTypes as $type) {
            $struct = $this->getAttribute()->getGenerator()->getStruct($type);
            if ($struct instanceof Struct) {
                $this->applyRulesFromModel($struct, $parameterName, $itemType);
            }
        }
    }
    /**
     * Generic method to apply rules from current model
     * @param AbstractModel $model
     * @param string $parameterName
     * @param string $itemType
     */
    protected function applyRulesFromModel(AbstractModel $model, $parameterName, $itemType = false)
    {
        foreach ($model->getMeta() as $metaName => $metaValue) {
            $rule = $this->getRule($metaName);
            if ($rule instanceof AbstractRule) {
                $rule->applyRule($parameterName, $metaValue, $itemType);

            } elseif ($metaName === 'union' && count($metaValue) > 0) {

                $this->applyUnionRules($parameterName, $itemType, $metaValue);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
        }
    }
    /**
     * @param string $metaName
     * @return AbstractRule
     */
    protected function getRule($metaName)
    {
        if (is_string($metaName)) {
            $className = sprintf('%s\%sRule', __NAMESPACE__, ucfirst($metaName));
            if (class_exists($className)) {
                return new $className($this);
            }
        }
        return null;
    }
    /**
     * @return ArrayRule
     */
    public function getArrayRule()
    {
        return $this->getRule('array');
    }
    /**
     * @return EnumerationRule
     */
    public function getEnumerationRule()
    {
        return $this->getRule('enumeration');
    }
    /**
     * @return ItemTypeRule
     */
    public function getItemTypeRule()
    {
        return $this->getRule('itemType');
    }
    /**
     * @return StructAttribute
     */
    public function getAttribute()
    {
        return $this->attribute;
    }
    /**
     * @param StructAttribute $attribute
     * @return Rules
     */
    public function setAttribute(StructAttribute $attribute)
    {
        $this->attribute = $attribute;
        return $this;
    }
    /**
     * @return AbstractModelFile
     */
    public function getFile()
    {
        return $this->file;
    }
    /**
     * @param AbstractModelFile $file
     * @return Rules
     */
    public function setFile(AbstractModelFile $file)
    {
        $this->file = $file;
        return $this;
    }
    /**
     * @return PhpMethod
     */
    public function getMethod()
    {
        return $this->method;
    }
    /**
     * @param PhpMethod $method
     * @return Rules
     */
    public function setMethod(PhpMethod $method)
    {
        $this->method = $method;
        return $this;
    }
}


1		<?php
2
3		namespace WsdlToPhp\PackageGenerator\File\Validation;
4
5		use WsdlToPhp\PackageGenerator\Model\StructAttribute;
6		use WsdlToPhp\PhpGenerator\Element\PhpMethod;
7		use WsdlToPhp\PackageGenerator\File\AbstractModelFile;
8		use WsdlToPhp\PackageGenerator\Model\Struct;
9		use WsdlToPhp\PackageGenerator\Model\AbstractModel;
10
11		class Rules
12		{
13		/**
14		* @var StructAttribute
15		*/
16		private $attribute;
17		/**
18		* @var AbstractModelFile
19		*/
20		private $file;
21		/**
22		* @var PhpMethod
23		*/
24		private $method;
25		/**
26		* @param AbstractModelFile $file
27		* @param PhpMethod $method
28	104	* @param StructAttribute $attribute
29		*/
30	104	public function __construct(AbstractModelFile $file, PhpMethod $method, StructAttribute $attribute)
31	104	{
32		$this->setFile($file)->setMethod($method)->setAttribute($attribute);
33		}
34		/**
35		* @param string $parameterName
36	104	* @param bool $itemType
37		*/
38	104	public function applyRules($parameterName, $itemType = false)
39	104	{
40	104	$this->applyRulesFromModel($this->attribute, $parameterName, $itemType);
		0 ignored issues – show Documentation introduced 2017-04-04 20:55 UTC by Report Bug Copy Issue Report `$itemType` is of type `boolean`, but the function expects a `false\|string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
41	16	if ($this->getAttribute()->isArray() && !$itemType) {
42	16	$this->getArrayRule()->applyRule($parameterName, null, $itemType);
43	104	} elseif ($this->getFile()->getRestrictionFromStructAttribute($this->getAttribute())) {
44	104	$this->getEnumerationRule()->applyRule($parameterName, null, $itemType);
45	64	} elseif ($itemType) {
46	104	$this->getItemTypeRule()->applyRule($parameterName, null, $itemType);
47	52	} elseif (($rule = $this->getRule($this->getFile()->getStructAttributeTypeAsPhpType($this->getAttribute()))) instanceof AbstractRule) {
48	104	$rule->applyRule($parameterName, null, $itemType);
49	60	}
50	100	}
51	76	/**
52	76	* This method is called when an attribute has a union meta which means the attribute is of several types.
53	104	* In this case, the types are currently only of type string (normally) so we add the rules according to each type
54		* @param string $parameterName
55		* @param string $itemType
56		* @param array $unionTypes
57		*/
58	104	protected function applyUnionRules($parameterName, $itemType, array $unionTypes)
59		{
60	104	foreach ($unionTypes as $type) {
61	104	$struct = $this->getAttribute()->getGenerator()->getStruct($type);
62	104	if ($struct instanceof Struct) {
63	104	$this->applyRulesFromModel($struct, $parameterName, $itemType);
64		}
65	104	}
66	104	}
67		/**
68		* Generic method to apply rules from current model
69		* @param AbstractModel $model
70		* @param string $parameterName
71	64	* @param string $itemType
72		*/
73	64	protected function applyRulesFromModel(AbstractModel $model, $parameterName, $itemType = false)
74		{
75		foreach ($model->getMeta() as $metaName => $metaValue) {
76		$rule = $this->getRule($metaName);
77		if ($rule instanceof AbstractRule) {
78	52	$rule->applyRule($parameterName, $metaValue, $itemType);
		0 ignored issues – show Bug introduced 2017-04-04 20:55 UTC by Report Bug Copy Issue Report It seems like `$itemType` defined by parameter `$itemType` on line 73 can also be of type `string`; however, `WsdlToPhp\PackageGenerat...stractRule::applyRule()` does only seem to accept `boolean`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
79		} elseif ($metaName === 'union' && count($metaValue) > 0) {
		0 ignored issues – show Unused Code Bug introduced 2017-04-04 20:55 UTC by Report Bug Copy Issue Report The strict comparison `===` seems to always evaluate to `false` as the types of `$metaName` (`integer`) and `'union'` (`string`) can never be identical. Maybe you want to use a loose comparison `==` instead? Loading history...
80	52	$this->applyUnionRules($parameterName, $itemType, $metaValue);
		0 ignored issues – show Bug introduced 2017-04-04 20:55 UTC by Report Bug Copy Issue Report It seems like `$itemType` defined by parameter `$itemType` on line 73 can also be of type `false`; however, `WsdlToPhp\PackageGenerat...ules::applyUnionRules()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history... Documentation introduced 2017-04-04 20:55 UTC by Report Bug Copy Issue Report `$metaValue` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
81		}
82		}
83		}
84		/**
85	60	* @param string $metaName
86		* @return AbstractRule
87	60	*/
88		protected function getRule($metaName)
89		{
90		if (is_string($metaName)) {
91		$className = sprintf('%s\%sRule', __NAMESPACE__, ucfirst($metaName));
92	104	if (class_exists($className)) {
93		return new $className($this);
94	104	}
95		}
96		return null;
97		}
98		/**
99		* @return ArrayRule
100	104	*/
101		public function getArrayRule()
102	104	{
103	104	return $this->getRule('array');
104		}
105		/**
106		* @return EnumerationRule
107		*/
108	104	public function getEnumerationRule()
109		{
110	104	return $this->getRule('enumeration');
111		}
112		/**
113		* @return ItemTypeRule
114		*/
115		public function getItemTypeRule()
116	104	{
117		return $this->getRule('itemType');
118	104	}
119	104	/**
120		* @return StructAttribute
121		*/
122		public function getAttribute()
123		{
124	104	return $this->attribute;
125		}
126	104	/**
127		* @param StructAttribute $attribute
128		* @return Rules
129		*/
130		public function setAttribute(StructAttribute $attribute)
131		{
132	104	$this->attribute = $attribute;
133		return $this;
134	104	}
135	104	/**
136		* @return AbstractModelFile
137		*/
138		public function getFile()
139		{
140		return $this->file;
141		}
142		/**
143		* @param AbstractModelFile $file
144		* @return Rules
145		*/
146		public function setFile(AbstractModelFile $file)
147		{
148		$this->file = $file;
149		return $this;
150		}
151		/**
152		* @return PhpMethod
153		*/
154		public function getMethod()
155		{
156		return $this->method;
157		}
158		/**
159		* @param PhpMethod $method
160		* @return Rules
161		*/
162		public function setMethod(PhpMethod $method)
163		{
164		$this->method = $method;
165		return $this;
166		}
167		}
168

WsdlToPhp / PackageGenerator

Push — feature/issue-84 ( 44128e...1e0a90 )

Rules::applyUnionRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like