Issues in AutowiringCompilerPass.php (master) - Issues in master - skrz/autowiring-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Issues (39)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

Compiler/AutowiringCompilerPass.php (17 issues)

Labels

Severity

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 Skrz\Bundle\AutowiringBundle\DependencyInjection\Compiler;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\PhpParser;
use ReflectionClass;
use ReflectionMethod;
use RuntimeException;
use Skrz\Bundle\AutowiringBundle\Annotation\Autowired;
use Skrz\Bundle\AutowiringBundle\Annotation\Value;
use Skrz\Bundle\AutowiringBundle\DependencyInjection\ClassMultiMap;
use Skrz\Bundle\AutowiringBundle\Exception\AutowiringException;
use Skrz\Bundle\AutowiringBundle\Exception\MultipleValuesException;
use Skrz\Bundle\AutowiringBundle\Exception\NoValueException;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Component\DependencyInjection\Reference;

/**
 * @author Jakub Kulhan <[email protected]>
 */
class AutowiringCompilerPass implements CompilerPassInterface
{

	/** @var ClassMultiMap */
	private $classMap;

	/** @var AnnotationReader */
	private $annotationReader;

	/** @var PhpParser */
	private $phpParser;

	/** @var string[][] */
	private $cachedUseStatements = [];

	/** @var ParameterBagInterface */
	private $parameterBag;

	public function __construct(ClassMultiMap $classMap, AnnotationReader $annotationReader, PhpParser $phpParser)
	{
		$this->classMap = $classMap;
		$this->annotationReader = $annotationReader;
		$this->phpParser = $phpParser;
		AnnotationRegistry::registerFile(__DIR__ . "/../../Annotation/Autowired.php");

	}

	public function process(ContainerBuilder $container)
	{
		$this->parameterBag = $parameterBag = $container->getParameterBag();

		try {
			$preferredServices = (array)$parameterBag->resolveValue("%autowiring.preferred_services%");
		} catch (ParameterNotFoundException $exception) {
			$preferredServices = [];
		}

		try {
			$fastAnnotationChecksRegex = "/" . implode("|", array_map(function ($s) {
					return preg_quote($s);
				}, (array)$parameterBag->resolveValue("%autowiring.fast_annotation_checks%"))) . "/";
		} catch (ParameterNotFoundException $exception) {
			$fastAnnotationChecksRegex = null;
		}

		foreach ($container->getDefinitions() as $serviceId => $definition) {
			if ($this->canDefinitionBeAutowired($serviceId, $definition) === false) {
				continue;
			}

			try {
				$className = $parameterBag->resolveValue($definition->getClass());
				$reflectionClass = $container->getReflectionClass($className, false);
				if ($reflectionClass === null) {
					continue;
				}

				$this->autowireClass(
					$className,
					$reflectionClass,
					$definition,
					$fastAnnotationChecksRegex,
					$preferredServices,
					$parameterBag
				);

				// add files to cache
				$container->addObjectResource($reflectionClass);

			} catch (AutowiringException $exception) {
				throw new AutowiringException(
					sprintf("%s (service: %s)", $exception->getMessage(), $serviceId),
					$exception->getCode(),
					$exception
				);
			}
		}
	}

	/**
	 * @param string $className
	 * @param ReflectionClass $reflectionClass
	 * @param Definition $definition
	 * @param string $fastAnnotationChecksRegex
	 * @param string[] $preferredServices
	 * @param ParameterBagInterface $parameterBag
	 */
	private function autowireClass(
		string $className,
		ReflectionClass $reflectionClass,
		Definition $definition,
		?string $fastAnnotationChecksRegex,
		array $preferredServices,
		ParameterBagInterface $parameterBag
	) {
		// constructor - autowire always
		if ($reflectionClass->getConstructor()) {
			$definition->setArguments(
				$this->autowireMethod(
					$className,
					$reflectionClass->getConstructor(),
					$definition->getArguments(),
					$preferredServices
				)
			);
		}

		if ($fastAnnotationChecksRegex === null ||
			($reflectionClass->getDocComment() &&
				preg_match($fastAnnotationChecksRegex, $reflectionClass->getDocComment()))
		) {
			// method calls @Autowired
			foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
				if ($reflectionMethod->getName() === "__construct") {

					continue;
				}

				if ($definition->hasMethodCall($reflectionMethod->getName())) {

					continue;
				}

				if (strpos($reflectionMethod->getDocComment(), "@Autowired") === false) {
					continue;
				}

				/** @var Autowired $annotation */
				$annotation = $this->annotationReader->getMethodAnnotation($reflectionMethod, Autowired::class);

				if ($annotation === null) {
					continue;
				}

				if ($annotation->name !== null) {
					throw new AutowiringException(
						sprintf(
							"@Autowired parameter can be used only on properties. %s::%s(...)",
							$className,
							$reflectionMethod->getName()

						)
					);
				}

				$definition->addMethodCall(
					$reflectionMethod->getName(),

					$this->autowireMethod(
						$className,
						$reflectionMethod,
						[],
						$preferredServices
					)
				);
			}

			// properties @Autowired, @Value
			$manualProperties = $definition->getProperties();
			foreach ($reflectionClass->getProperties() as $reflectionProperty) {
				if (isset($manualProperties[$reflectionProperty->getName()])) {
					continue;
				}

				if (strpos($reflectionProperty->getDocComment(), "@Autowired") === false &&
					strpos($reflectionProperty->getDocComment(), "@Value") === false
				) {
					continue;
				}

				$annotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty);

				$autowiredAnnotation = false;
				$valueAnnotation = false;
				$incorrectUsage = false;

				foreach ($annotations as $annotation) {
					if ($annotation instanceof Autowired) {
						if ($valueAnnotation) {
							$incorrectUsage = true;
							break;
						}

						$autowiredAnnotation = true;

						try {
							if ($annotation->name !== null) {
								$definition->setProperty(
									$reflectionProperty->getName(),
									new Reference($annotation->name)
								);
							} else {
								$definition->setProperty(
									$reflectionProperty->getName(),
									$this->getValue(
										$reflectionProperty->getDeclaringClass(),
										$reflectionProperty->getDocComment(),
										null,
										null,
										false,
										null,
										$preferredServices
									)
								);
							}

						} catch (AutowiringException $exception) {
							throw new AutowiringException(
								sprintf(
									"%s (Property %s::$%s)",
									$exception->getMessage(),
									$className,
									$reflectionProperty->getName()
								),
								$exception->getCode(),
								$exception
							);
						}

					} elseif ($annotation instanceof Value) {
						if ($autowiredAnnotation) {
							$incorrectUsage = true;
							break;
						}

						try {
							$definition->setProperty(
								$reflectionProperty->getName(),
								$parameterBag->resolveValue($annotation->value)
							);
						} catch (RuntimeException $exception) {
							throw new AutowiringException(
								sprintf(
									"%s (Property %s::$%s)",
									$exception->getMessage(),
									$className,
									$reflectionProperty->getName()
								),
								$exception->getCode(),
								$exception
							);
						}
					}
				}

				if ($incorrectUsage) {
					throw new AutowiringException(
						sprintf(
							"Property can have either @Autowired, or @Value annotation, not both. (Property %s::$%s)",
							$className,
							$reflectionProperty->getName()
						)
					);
				}
			}

		}
	}

	/**
	 * @param string $className
	 * @param ReflectionMethod $reflectionMethod
	 * @param array $arguments
	 * @param string[] $preferredServices
	 * @return array
	 */
	private function autowireMethod(
		string $className,
		ReflectionMethod $reflectionMethod,
		array $arguments,
		array $preferredServices
	): array {
		$outputArguments = [];

		foreach ($reflectionMethod->getParameters() as $i => $reflectionProperty) {
			// intentionally array_key_exists() instead of isset(), isset() would return false if argument is null

			if (array_key_exists($i, $arguments)) {
				$outputArguments[$i] = $arguments[$i];
			} else if (array_key_exists($reflectionProperty->getName(), $arguments)) {

				$outputArguments[$i] = $arguments[$reflectionProperty->getName()];

			} else {
				try {
					$outputArguments[$i] = $this->getValue(
						$reflectionProperty->getDeclaringClass(),
						$reflectionMethod->getDocComment(),
						$reflectionProperty->getName(),

						$reflectionProperty->getClass(),
						$reflectionProperty->isDefaultValueAvailable(),
						$reflectionProperty->isDefaultValueAvailable() ? $reflectionProperty->getDefaultValue() : null,
						$preferredServices
					);

				} catch (AutowiringException $exception) {
					throw new AutowiringException(
						sprintf(
							"%s (%s::%s(%s$%s%s))",
							$exception->getMessage(),
							$className,
							$reflectionMethod->getName(),

							$reflectionProperty->getPosition() !== 0 ? "..., " : "",
							$reflectionProperty->getName(),

							$reflectionProperty->getPosition() < $reflectionMethod->getNumberOfParameters() - 1
								? ", ..."
								: ""
						),
						$exception->getCode(),
						$exception
					);
				}
			}
		}

		return $outputArguments;
	}

	/**
	 * @param ReflectionClass $reflectionClass
	 * @param string $docComment
	 * @param string $parameterName
	 * @param ReflectionClass $parameterReflectionClass
	 * @param mixed $defaultValueAvailable
	 * @param mixed $defaultValue
	 * @param $preferredServices
	 * @return mixed
	 */
	private function getValue(
		ReflectionClass $reflectionClass,
		$docComment,
		$parameterName,
		ReflectionClass $parameterReflectionClass = null,
		$defaultValueAvailable,
		$defaultValue,
		$preferredServices
	) {
		$className = null;
		$isArray = false;

		// resolve class name, whether value is array
		if ($parameterName !== null) { // parse parameter class
			if ($parameterReflectionClass) {
				$className = $parameterReflectionClass->getName();


			} elseif (preg_match(
				"/@param\\s+([a-zA-Z0-9\\\\_]+)(\\[\\])?(\\|[^\\s]+)*\\s+\\\$" . preg_quote($parameterName) . "/",
				$docComment,
				$m
			)) {
				$className = $m[1];
				$isArray = isset($m[2]) && $m[2] === "[]";

			} elseif (!$defaultValueAvailable) {
				throw new AutowiringException(sprintf(
					"Could not parse parameter type of class %s - neither type hint, nor @param annotation available.",
					$reflectionClass->getName()

				));
			}

		} else { // parse property class
			if (preg_match("/@var\\s+([a-zA-Z0-9\\\\_]+)(\\[\\])?/", $docComment, $m)) {
				$className = $m[1];
				$isArray = isset($m[2]) && $m[2] === "[]";

			} elseif (!$defaultValueAvailable) {
				throw new AutowiringException(
					"Could not parse property type - no @var annotation."
				);
			}
		}

		// resolve class name to FQN
		$lowerClassName = trim(strtolower($className), "\\ \t\n");
		$useStatements = $this->getUseStatements($reflectionClass);
		if (isset($useStatements[$lowerClassName])) {
			$className = $useStatements[$lowerClassName];
		} elseif (strpos($className, "\\") === false) {
			$className = $reflectionClass->getNamespaceName() . "\\" . $className;
		}

		$className = trim($className, "\\");

		// autowire from class map
		if ($isArray) {
			return array_map(function ($serviceId) {
				return new Reference($serviceId);
			}, $this->classMap->getMulti($className));

		} elseif ($className !== null) {
			try {
				return new Reference($this->classMap->getSingle($className));

			} catch (NoValueException $exception) {
				if ($defaultValueAvailable) {
					return $defaultValue;
				} else {
					throw new AutowiringException(sprintf("Missing service of type '%s'.", $className));
				}

			} catch (MultipleValuesException $exception) {
				if (isset($preferredServices[$className])) {
					return new Reference($preferredServices[$className]);
				} else {
					throw new AutowiringException(sprintf("Multiple services of type '%s': %s", $className, $exception->getMessage()));
				}
			}

		} elseif ($defaultValueAvailable) {
			return $defaultValue;

		} else {
			throw new AutowiringException("Could not autowire.");
		}
	}

	/**
	 * @param ReflectionClass $reflectionClass
	 * @return string[]
	 */
	public function getUseStatements(ReflectionClass $reflectionClass): array
	{
		if (!isset($this->cachedUseStatements[$reflectionClass->getName()])) {

			$this->cachedUseStatements[$reflectionClass->getName()] = $this->phpParser->parseClass($reflectionClass);

		}

		return $this->cachedUseStatements[$reflectionClass->getName()];

	}

	/**
	 * @return array
	 */
	private function getIgnoredServicePatterns(): array
	{
		try {
			return (array)$this->parameterBag->resolveValue("%autowiring.ignored_services%");
		} catch (ParameterNotFoundException $exception) {
			return [];
		}
	}

	/**
	 * @param string $serviceId
	 * @param Definition $definition
	 * @return bool
	 */
	private function canDefinitionBeAutowired($serviceId, Definition $definition): bool
	{
		if (preg_match('/^\d+_[^~]++~[._a-zA-Z\d]{7}$/', $serviceId)) {
			return false;
		}

		foreach ($this->getIgnoredServicePatterns() as $pattern) {
			if (($pattern[0] === "/" && preg_match($pattern, $serviceId)) ||
				strcasecmp($serviceId, $pattern) == 0
			) {
				return false;
			}
		}

		if ($definition->isAbstract() ||
			$definition->isSynthetic() ||
			!$definition->getClass() ||
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			$definition->getFactory()
		) {
			return false;
		}

		return true;
	}

}


1		<?php
2		namespace Skrz\Bundle\AutowiringBundle\DependencyInjection\Compiler;
3
4		use Doctrine\Common\Annotations\AnnotationReader;
5		use Doctrine\Common\Annotations\AnnotationRegistry;
6		use Doctrine\Common\Annotations\PhpParser;
7		use ReflectionClass;
8		use ReflectionMethod;
9		use RuntimeException;
10		use Skrz\Bundle\AutowiringBundle\Annotation\Autowired;
11		use Skrz\Bundle\AutowiringBundle\Annotation\Value;
12		use Skrz\Bundle\AutowiringBundle\DependencyInjection\ClassMultiMap;
13		use Skrz\Bundle\AutowiringBundle\Exception\AutowiringException;
14		use Skrz\Bundle\AutowiringBundle\Exception\MultipleValuesException;
15		use Skrz\Bundle\AutowiringBundle\Exception\NoValueException;
16		use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
17		use Symfony\Component\DependencyInjection\ContainerBuilder;
18		use Symfony\Component\DependencyInjection\Definition;
19		use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
20		use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
21		use Symfony\Component\DependencyInjection\Reference;
22
23		/**
24		* @author Jakub Kulhan <[email protected]>
25		*/
26		class AutowiringCompilerPass implements CompilerPassInterface
27		{
28
29		/** @var ClassMultiMap */
30		private $classMap;
31
32		/** @var AnnotationReader */
33		private $annotationReader;
34
35		/** @var PhpParser */
36		private $phpParser;
37
38		/** @var string[][] */
39		private $cachedUseStatements = [];
40
41		/** @var ParameterBagInterface */
42		private $parameterBag;
43
44	6	public function __construct(ClassMultiMap $classMap, AnnotationReader $annotationReader, PhpParser $phpParser)
45		{
46	6	$this->classMap = $classMap;
47	6	$this->annotationReader = $annotationReader;
48	6	$this->phpParser = $phpParser;
49	6	AnnotationRegistry::registerFile(__DIR__ . "/../../Annotation/Autowired.php");
		0 ignored issues – show Deprecated Code introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `Doctrine\Common\Annotati...egistry::registerFile()` has been deprecated with message: this method is deprecated and will be removed in doctrine/annotations 2.0 autoloading should be deferred to the globally registered autoloader by then. For now, use @example AnnotationRegistry::registerLoader('class_exists') 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...
50	6	}
51
52	5	public function process(ContainerBuilder $container)
53		{
54	5	$this->parameterBag = $parameterBag = $container->getParameterBag();
55
56		try {
57	5	$preferredServices = (array)$parameterBag->resolveValue("%autowiring.preferred_services%");
58	4	} catch (ParameterNotFoundException $exception) {
59	4	$preferredServices = [];
60		}
61
62		try {
63	5	$fastAnnotationChecksRegex = "/" . implode("\|", array_map(function ($s) {
64		return preg_quote($s);
65	5	}, (array)$parameterBag->resolveValue("%autowiring.fast_annotation_checks%"))) . "/";
66	5	} catch (ParameterNotFoundException $exception) {
67	5	$fastAnnotationChecksRegex = null;
68		}
69
70	5	foreach ($container->getDefinitions() as $serviceId => $definition) {
71	5	if ($this->canDefinitionBeAutowired($serviceId, $definition) === false) {
72	5	continue;
73		}
74
75		try {
76	5	$className = $parameterBag->resolveValue($definition->getClass());
77	5	$reflectionClass = $container->getReflectionClass($className, false);
78	5	if ($reflectionClass === null) {
79		continue;
80		}
81
82	5	$this->autowireClass(
83	5	$className,
84	5	$reflectionClass,
85	5	$definition,
86	5	$fastAnnotationChecksRegex,
87	5	$preferredServices,
88	5	$parameterBag
89		);
90
91		// add files to cache
92	4	$container->addObjectResource($reflectionClass);
93
94	1	} catch (AutowiringException $exception) {
95	1	throw new AutowiringException(
96	1	sprintf("%s (service: %s)", $exception->getMessage(), $serviceId),
97	1	$exception->getCode(),
98	5	$exception
99		);
100		}
101		}
102	4	}
103
104		/**
105		* @param string $className
106		* @param ReflectionClass $reflectionClass
107		* @param Definition $definition
108		* @param string $fastAnnotationChecksRegex
109		* @param string[] $preferredServices
110		* @param ParameterBagInterface $parameterBag
111		*/
112	5	private function autowireClass(
113		string $className,
114		ReflectionClass $reflectionClass,
115		Definition $definition,
116		?string $fastAnnotationChecksRegex,
117		array $preferredServices,
118		ParameterBagInterface $parameterBag
119		) {
120		// constructor - autowire always
121	5	if ($reflectionClass->getConstructor()) {
122	4	$definition->setArguments(
123	4	$this->autowireMethod(
124	4	$className,
125	4	$reflectionClass->getConstructor(),
126	4	$definition->getArguments(),
127	4	$preferredServices
128		)
129		);
130		}
131
132	4	if ($fastAnnotationChecksRegex === null \|\|
133		($reflectionClass->getDocComment() &&
134	4	preg_match($fastAnnotationChecksRegex, $reflectionClass->getDocComment()))
135		) {
136		// method calls @Autowired
137	4	foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
138	3	if ($reflectionMethod->getName() === "__construct") {
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
139	3	continue;
140		}
141
142		if ($definition->hasMethodCall($reflectionMethod->getName())) {
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
143		continue;
144		}
145
146		if (strpos($reflectionMethod->getDocComment(), "@Autowired") === false) {
147		continue;
148		}
149
150		/** @var Autowired $annotation */
151		$annotation = $this->annotationReader->getMethodAnnotation($reflectionMethod, Autowired::class);
152
153		if ($annotation === null) {
154		continue;
155		}
156
157		if ($annotation->name !== null) {
158		throw new AutowiringException(
159		sprintf(
160		"@Autowired parameter can be used only on properties. %s::%s(...)",
161		$className,
162		$reflectionMethod->getName()
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
163		)
164		);
165		}
166
167		$definition->addMethodCall(
168		$reflectionMethod->getName(),
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
169		$this->autowireMethod(
170		$className,
171		$reflectionMethod,
172		[],
173		$preferredServices
174		)
175		);
176		}
177
178		// properties @Autowired, @Value
179	4	$manualProperties = $definition->getProperties();
180	4	foreach ($reflectionClass->getProperties() as $reflectionProperty) {
181	1	if (isset($manualProperties[$reflectionProperty->getName()])) {
182		continue;
183		}
184
185	1	if (strpos($reflectionProperty->getDocComment(), "@Autowired") === false &&
186	1	strpos($reflectionProperty->getDocComment(), "@Value") === false
187		) {
188		continue;
189		}
190
191	1	$annotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty);
192
193	1	$autowiredAnnotation = false;
194	1	$valueAnnotation = false;
195	1	$incorrectUsage = false;
196
197	1	foreach ($annotations as $annotation) {
198	1	if ($annotation instanceof Autowired) {
199	1	if ($valueAnnotation) {
200		$incorrectUsage = true;
201		break;
202		}
203
204	1	$autowiredAnnotation = true;
205
206		try {
207	1	if ($annotation->name !== null) {
208		$definition->setProperty(
209		$reflectionProperty->getName(),
210		new Reference($annotation->name)
211		);
212		} else {
213	1	$definition->setProperty(
214	1	$reflectionProperty->getName(),
215	1	$this->getValue(
216	1	$reflectionProperty->getDeclaringClass(),
217	1	$reflectionProperty->getDocComment(),
218	1	null,
219	1	null,
220	1	false,
221	1	null,
222	1	$preferredServices
223		)
224		);
225		}
226
227		} catch (AutowiringException $exception) {
228		throw new AutowiringException(
229		sprintf(
230		"%s (Property %s::$%s)",
231		$exception->getMessage(),
232		$className,
233		$reflectionProperty->getName()
234		),
235		$exception->getCode(),
236	1	$exception
237		);
238		}
239
240		} elseif ($annotation instanceof Value) {
241		if ($autowiredAnnotation) {
242		$incorrectUsage = true;
243		break;
244		}
245
246		try {
247		$definition->setProperty(
248		$reflectionProperty->getName(),
249		$parameterBag->resolveValue($annotation->value)
250		);
251		} catch (RuntimeException $exception) {
252		throw new AutowiringException(
253		sprintf(
254		"%s (Property %s::$%s)",
255		$exception->getMessage(),
256		$className,
257		$reflectionProperty->getName()
258		),
259		$exception->getCode(),
260	1	$exception
261		);
262		}
263		}
264		}
265
266	1	if ($incorrectUsage) {
267		throw new AutowiringException(
268		sprintf(
269		"Property can have either @Autowired, or @Value annotation, not both. (Property %s::$%s)",
270		$className,
271	1	$reflectionProperty->getName()
272		)
273		);
274		}
275		}
276
277		}
278	4	}
279
280		/**
281		* @param string $className
282		* @param ReflectionMethod $reflectionMethod
283		* @param array $arguments
284		* @param string[] $preferredServices
285		* @return array
286		*/
287	4	private function autowireMethod(
288		string $className,
289		ReflectionMethod $reflectionMethod,
290		array $arguments,
291		array $preferredServices
292		): array {
293	4	$outputArguments = [];
294
295	4	foreach ($reflectionMethod->getParameters() as $i => $reflectionProperty) {
296		// intentionally array_key_exists() instead of isset(), isset() would return false if argument is null
		0 ignored issues – show Unused Code Comprehensibility introduced 2016-02-07 15:14 UTC by Report Bug Copy Issue Report Show Similar Issues like this `40%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
297	4	if (array_key_exists($i, $arguments)) {
298		$outputArguments[$i] = $arguments[$i];
299	4	} else if (array_key_exists($reflectionProperty->getName(), $arguments)) {
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionProperty->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
300	1	$outputArguments[$i] = $arguments[$reflectionProperty->getName()];
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionProperty->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
301		} else {
302		try {
303	4	$outputArguments[$i] = $this->getValue(
304	4	$reflectionProperty->getDeclaringClass(),
305	4	$reflectionMethod->getDocComment(),
306	4	$reflectionProperty->getName(),
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionProperty->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
307	4	$reflectionProperty->getClass(),
308	4	$reflectionProperty->isDefaultValueAvailable(),
309	4	$reflectionProperty->isDefaultValueAvailable() ? $reflectionProperty->getDefaultValue() : null,
310	4	$preferredServices
311		);
312
313	1	} catch (AutowiringException $exception) {
314	1	throw new AutowiringException(
315	1	sprintf(
316	1	"%s (%s::%s(%s$%s%s))",
317	1	$exception->getMessage(),
318	1	$className,
319	1	$reflectionMethod->getName(),
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
320	1	$reflectionProperty->getPosition() !== 0 ? "..., " : "",
321	1	$reflectionProperty->getName(),
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionProperty->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
322	1	$reflectionProperty->getPosition() < $reflectionMethod->getNumberOfParameters() - 1
323		? ", ..."
324	1	: ""
325		),
326	1	$exception->getCode(),
327	4	$exception
328		);
329		}
330		}
331		}
332
333	3	return $outputArguments;
334		}
335
336		/**
337		* @param ReflectionClass $reflectionClass
338		* @param string $docComment
339		* @param string $parameterName
340		* @param ReflectionClass $parameterReflectionClass
341		* @param mixed $defaultValueAvailable
342		* @param mixed $defaultValue
343		* @param $preferredServices
344		* @return mixed
345		*/
346	5	private function getValue(
347		ReflectionClass $reflectionClass,
348		$docComment,
349		$parameterName,
350		ReflectionClass $parameterReflectionClass = null,
351		$defaultValueAvailable,
352		$defaultValue,
353		$preferredServices
354		) {
355	5	$className = null;
356	5	$isArray = false;
357
358		// resolve class name, whether value is array
359	5	if ($parameterName !== null) { // parse parameter class
360	4	if ($parameterReflectionClass) {
361	4	$className = $parameterReflectionClass->getName();
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$parameterReflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
362
363		} elseif (preg_match(
364		"/@param\\s+([a-zA-Z0-9\\\\_]+)(\\[\\])?(\\\|[^\\s]+)*\\s+\\\$" . preg_quote($parameterName) . "/",
365		$docComment,
366		$m
367		)) {
368		$className = $m[1];
369		$isArray = isset($m[2]) && $m[2] === "[]";
370
371		} elseif (!$defaultValueAvailable) {
372		throw new AutowiringException(sprintf(
373		"Could not parse parameter type of class %s - neither type hint, nor @param annotation available.",
374	4	$reflectionClass->getName()
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
375		));
376		}
377
378		} else { // parse property class
379	1	if (preg_match("/@var\\s+([a-zA-Z0-9\\\\_]+)(\\[\\])?/", $docComment, $m)) {
380	1	$className = $m[1];
381	1	$isArray = isset($m[2]) && $m[2] === "[]";
382
383		} elseif (!$defaultValueAvailable) {
384		throw new AutowiringException(
385		"Could not parse property type - no @var annotation."
386		);
387		}
388		}
389
390		// resolve class name to FQN
391	5	$lowerClassName = trim(strtolower($className), "\\ \t\n");
392	5	$useStatements = $this->getUseStatements($reflectionClass);
393	5	if (isset($useStatements[$lowerClassName])) {
394		$className = $useStatements[$lowerClassName];
395	5	} elseif (strpos($className, "\\") === false) {
396	1	$className = $reflectionClass->getNamespaceName() . "\\" . $className;
397		}
398
399	5	$className = trim($className, "\\");
400
401		// autowire from class map
402	5	if ($isArray) {
403		return array_map(function ($serviceId) {
404		return new Reference($serviceId);
405		}, $this->classMap->getMulti($className));
406
407	5	} elseif ($className !== null) {
408		try {
409	5	return new Reference($this->classMap->getSingle($className));
410
411	2	} catch (NoValueException $exception) {
412	1	if ($defaultValueAvailable) {
413		return $defaultValue;
414		} else {
415	1	throw new AutowiringException(sprintf("Missing service of type '%s'.", $className));
416		}
417
418	1	} catch (MultipleValuesException $exception) {
419	1	if (isset($preferredServices[$className])) {
420	1	return new Reference($preferredServices[$className]);
421		} else {
422		throw new AutowiringException(sprintf("Multiple services of type '%s': %s", $className, $exception->getMessage()));
423		}
424		}
425
426		} elseif ($defaultValueAvailable) {
427		return $defaultValue;
428
429		} else {
430		throw new AutowiringException("Could not autowire.");
431		}
432		}
433
434		/**
435		* @param ReflectionClass $reflectionClass
436		* @return string[]
437		*/
438	5	public function getUseStatements(ReflectionClass $reflectionClass): array
439		{
440	5	if (!isset($this->cachedUseStatements[$reflectionClass->getName()])) {
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
441	5	$this->cachedUseStatements[$reflectionClass->getName()] = $this->phpParser->parseClass($reflectionClass);
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
442		}
443
444	5	return $this->cachedUseStatements[$reflectionClass->getName()];
		0 ignored issues – show Bug introduced 2018-02-16 07:37 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
445		}
446
447		/**
448		* @return array
449		*/
450	5	private function getIgnoredServicePatterns(): array
451		{
452		try {
453	5	return (array)$this->parameterBag->resolveValue("%autowiring.ignored_services%");
454	5	} catch (ParameterNotFoundException $exception) {
455	5	return [];
456		}
457		}
458
459		/**
460		* @param string $serviceId
461		* @param Definition $definition
462		* @return bool
463		*/
464	5	private function canDefinitionBeAutowired($serviceId, Definition $definition): bool
465		{
466	5	if (preg_match('/^\d+_[^~]++~[._a-zA-Z\d]{7}$/', $serviceId)) {
467		return false;
468		}
469
470	5	foreach ($this->getIgnoredServicePatterns() as $pattern) {
471		if (($pattern[0] === "/" && preg_match($pattern, $serviceId)) \|\|
472		strcasecmp($serviceId, $pattern) == 0
473		) {
474		return false;
475		}
476		}
477
478	5	if ($definition->isAbstract() \|\|
479	5	$definition->isSynthetic() \|\|
480	5	!$definition->getClass() \|\|
		0 ignored issues – show Bug Best Practice introduced 2016-02-07 15:14 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$definition->getClass()` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
481	5	$definition->getFactory()
482		) {
483	5	return false;
484		}
485
486	5	return true;
487		}
488
489		}
490

skrz / autowiring-bundle

Issues (39)

Security Analysis no request data

Compiler/AutowiringCompilerPass.php (17 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like