Addendum::setSignal() - Code Metrics - Inspection of "^ dep" - Maslosoft/Signals - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c632d0...4a7120 )

by Peter

created 2016-08-23 14:51 UTC

Addendum::setSignal() A

↳ Parent: Addendum

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/**
 * This software package is licensed under `AGPL, Commercial` license[s].
 *
 * @package maslosoft/signals
 * @license AGPL, Commercial
 *
 * @copyright Copyright (c) Peter Maselkowski <[email protected]>
 *
 */

namespace Maslosoft\Signals\Builder;

use Maslosoft\Addendum\Exceptions\ParseException;
use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
use Maslosoft\Addendum\Utilities\AnnotationUtility;
use Maslosoft\Addendum\Utilities\FileWalker;
use Maslosoft\Signals\Helpers\DataSorter;
use Maslosoft\Signals\Helpers\NameNormalizer;
use Maslosoft\Signals\Interfaces\ExtractorInterface;
use Maslosoft\Signals\Meta\DocumentMethodMeta;
use Maslosoft\Signals\Meta\DocumentPropertyMeta;
use Maslosoft\Signals\Meta\DocumentTypeMeta;
use Maslosoft\Signals\Meta\SignalsMeta;
use Maslosoft\Signals\Signal;
use ReflectionClass;
use ReflectionException;
use UnexpectedValueException;
use Exception;

/**
 * Addendum extractor
 *
 * @author Piotr Maselkowski <pmaselkowski at gmail.com>
 */
class Addendum implements ExtractorInterface
{

	// Data keys for annotations extraction
	const SlotFor = 'SlotFor';
	const SignalFor = 'SignalFor';
	// Default annotation names
	const SlotName = 'SlotFor';
	const SignalName = 'SignalFor';

	/**
	 * Signal instance
	 * @var Signal
	 */
	private $signal = null;

	/**
	 * Signals and slots data
	 * @var mixed
	 */
	private $data = [
		Signal::Slots => [
		],
		Signal::Signals => [
		]
	];

	/**
	 * Scanned file paths
	 * @var string[]
	 */
	private $paths = [];

	/**
	 * Annotations mathing patterns
	 * @var string[]
	 */
	private $patterns = [];

	public function __construct()
	{
		$annotations = [
			self::SlotFor,
			self::SignalFor
		];
		foreach ($annotations as $annotation)
		{
			$annotation = preg_replace('~^@~', '', $annotation);
			$this->patterns[] = sprintf('~@%s~', $annotation);
		}
	}

	/**
	 * Get signals and slots data
	 * @return mixed
	 */
	public function getData()
	{
		(new FileWalker([], [$this, 'processFile'], $this->signal->paths, $this->signal->ignoreDirs))->walk();
		DataSorter::sort($this->data);
		return $this->data;
	}

	/**
	 * Get scanned paths. This is available only after getData call.
	 * @return string[]
	 */
	public function getPaths()
	{
		return $this->paths;
	}

	/**
	 * Set signal instance
	 * @param Signal $signal
	 */
	public function setSignal(Signal $signal)
	{
		$this->signal = $signal;
	}

	/**
	 * @param string $file
	 */
	public function processFile($file, $contents)
	{
		$file = realpath($file);
		$this->paths[] = $file;
		// Remove initial `\` from namespace
		try
		{
			$annotated = AnnotationUtility::rawAnnotate($file);
		}
		catch (ParseException $e)
		{
			$this->log($e, $file);
			return;
		}
		catch (UnexpectedValueException $e)
		{
			$this->log($e, $file);
			return;
		}
		$namespace = preg_replace('~^\\\\+~', '', $annotated['namespace']);
		$className = $annotated['className'];


		// Use fully qualified name, class must autoload
		$fqn = $namespace . '\\' . $className;
		NameNormalizer::normalize($fqn);

		try
		{
			$info = new ReflectionClass($fqn);
		}
		catch (ReflectionException $e)
		{
			$this->log($e, $file);
			return;
		}
		$isAnnotated = $info->implementsInterface(AnnotatedInterface::class);
		$hasSignals = $this->hasSignals($contents);
		$isAbstract = $info->isAbstract() || $info->isInterface();

		// Old classes must now implement interface
		// Brake BC!
		if ($hasSignals && !$isAnnotated && !$isAbstract)
		{
			throw new UnexpectedValueException(sprintf('Class %s must implement %s to use signals', $fqn, AnnotatedInterface::class));
		}

		// Skip not annotated class
		if (!$isAnnotated)
		{
			return;
		}

		// Skip abstract classes
		if ($isAbstract)
		{
			return;
		}
		$meta = @SignalsMeta::create($fqn);
		/* @var $typeMeta DocumentTypeMeta */
		$typeMeta = $meta->type();

		// Signals
		foreach ($typeMeta->signalFor as $slot)
		{
			$this->data[Signal::Slots][$slot][$fqn] = true;
		}

		// Slots
		// For constructor injection
		foreach ($typeMeta->slotFor as $slot)
		{
			$key = implode('@', [$fqn, '__construct', '()']);
			$this->data[Signal::Signals][$slot][$fqn][$key] = true;
		}

		// For method injection
		foreach ($meta->methods() as $methodName => $method)
		{
			/* @var $method DocumentMethodMeta */
			foreach ($method->slotFor as $slot)
			{
				$key = implode('@', [$fqn, $methodName, '()']);
				$this->data[Signal::Signals][$slot][$fqn][$key] = sprintf('%s()', $methodName);
			}
		}

		// For property injection
		foreach ($meta->fields() as $fieldName => $field)
		{
			/* @var $field DocumentPropertyMeta */
			foreach ($field->slotFor as $slot)
			{
				$key = implode('@', [$fqn, $fieldName]);
				$this->data[Signal::Signals][$slot][$fqn][$key] = sprintf('%s', $fieldName);
			}
		}
	}

	private function hasSignals($contents)
	{
		foreach ($this->patterns as $pattern)
		{
			if (preg_match($pattern, $contents))
			{
				return true;
			}
		}
		return false;
	}

	private function log(Exception $e, $file)
	{
		$msg = sprintf('Exception: "%s" while scanning file `%s`', $e->getMessage(), $file);
		$this->signal->getLogger()->warning($msg);
	}

}


1		<?php
2
3		/**
4		* This software package is licensed under `AGPL, Commercial` license[s].
5		*
6		* @package maslosoft/signals
7		* @license AGPL, Commercial
8		*
9		* @copyright Copyright (c) Peter Maselkowski <[email protected]>
10		*
11		*/
12
13		namespace Maslosoft\Signals\Builder;
14
15		use Maslosoft\Addendum\Exceptions\ParseException;
16		use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
17		use Maslosoft\Addendum\Utilities\AnnotationUtility;
18		use Maslosoft\Addendum\Utilities\FileWalker;
19		use Maslosoft\Signals\Helpers\DataSorter;
20		use Maslosoft\Signals\Helpers\NameNormalizer;
21		use Maslosoft\Signals\Interfaces\ExtractorInterface;
22		use Maslosoft\Signals\Meta\DocumentMethodMeta;
23		use Maslosoft\Signals\Meta\DocumentPropertyMeta;
24		use Maslosoft\Signals\Meta\DocumentTypeMeta;
25		use Maslosoft\Signals\Meta\SignalsMeta;
26		use Maslosoft\Signals\Signal;
27		use ReflectionClass;
28		use ReflectionException;
29		use UnexpectedValueException;
30		use Exception;
31
32		/**
33		* Addendum extractor
34		*
35		* @author Piotr Maselkowski <pmaselkowski at gmail.com>
36		*/
37		class Addendum implements ExtractorInterface
38		{
39
40		// Data keys for annotations extraction
41		const SlotFor = 'SlotFor';
42		const SignalFor = 'SignalFor';
43		// Default annotation names
44		const SlotName = 'SlotFor';
45		const SignalName = 'SignalFor';
46
47		/**
48		* Signal instance
49		* @var Signal
50		*/
51		private $signal = null;
52
53		/**
54		* Signals and slots data
55		* @var mixed
56		*/
57		private $data = [
58		Signal::Slots => [
59		],
60		Signal::Signals => [
61		]
62		];
63
64		/**
65		* Scanned file paths
66		* @var string[]
67		*/
68		private $paths = [];
69
70		/**
71		* Annotations mathing patterns
72		* @var string[]
73		*/
74		private $patterns = [];
75
76	15	public function __construct()
77		{
78		$annotations = [
79	15	self::SlotFor,
80	15	self::SignalFor
81		];
82	15	foreach ($annotations as $annotation)
83		{
84	15	$annotation = preg_replace('~^@~', '', $annotation);
85	15	$this->patterns[] = sprintf('~@%s~', $annotation);
86		}
87	15	}
88
89		/**
90		* Get signals and slots data
91		* @return mixed
92		*/
93		public function getData()
94		{
95		(new FileWalker([], [$this, 'processFile'], $this->signal->paths, $this->signal->ignoreDirs))->walk();
96		DataSorter::sort($this->data);
97		return $this->data;
98		}
99
100		/**
101		* Get scanned paths. This is available only after getData call.
102		* @return string[]
103		*/
104		public function getPaths()
105		{
106		return $this->paths;
107		}
108
109		/**
110		* Set signal instance
111		* @param Signal $signal
112		*/
113		public function setSignal(Signal $signal)
114		{
115		$this->signal = $signal;
116		}
117
118		/**
119		* @param string $file
120		*/
121		public function processFile($file, $contents)
122		{
123		$file = realpath($file);
124		$this->paths[] = $file;
125		// Remove initial `\` from namespace
126		try
127		{
128		$annotated = AnnotationUtility::rawAnnotate($file);
129		}
130		catch (ParseException $e)
131		{
132		$this->log($e, $file);
133		return;
134		}
135		catch (UnexpectedValueException $e)
136		{
137		$this->log($e, $file);
138		return;
139		}
140		$namespace = preg_replace('~^\\\\+~', '', $annotated['namespace']);
141		$className = $annotated['className'];
142
143
144		// Use fully qualified name, class must autoload
145		$fqn = $namespace . '\\' . $className;
146		NameNormalizer::normalize($fqn);
147
148		try
149		{
150		$info = new ReflectionClass($fqn);
151		}
152		catch (ReflectionException $e)
153		{
154		$this->log($e, $file);
155		return;
156		}
157		$isAnnotated = $info->implementsInterface(AnnotatedInterface::class);
158		$hasSignals = $this->hasSignals($contents);
159		$isAbstract = $info->isAbstract() \|\| $info->isInterface();
160
161		// Old classes must now implement interface
162		// Brake BC!
163		if ($hasSignals && !$isAnnotated && !$isAbstract)
164		{
165		throw new UnexpectedValueException(sprintf('Class %s must implement %s to use signals', $fqn, AnnotatedInterface::class));
166		}
167
168		// Skip not annotated class
169		if (!$isAnnotated)
170		{
171		return;
172		}
173
174		// Skip abstract classes
175		if ($isAbstract)
176		{
177		return;
178		}
179		$meta = @SignalsMeta::create($fqn);
180		/* @var $typeMeta DocumentTypeMeta */
181		$typeMeta = $meta->type();
182
183		// Signals
184		foreach ($typeMeta->signalFor as $slot)
185		{
186		$this->data[Signal::Slots][$slot][$fqn] = true;
187		}
188
189		// Slots
190		// For constructor injection
191		foreach ($typeMeta->slotFor as $slot)
192		{
193		$key = implode('@', [$fqn, '__construct', '()']);
194		$this->data[Signal::Signals][$slot][$fqn][$key] = true;
195		}
196
197		// For method injection
198		foreach ($meta->methods() as $methodName => $method)
199		{
200		/* @var $method DocumentMethodMeta */
201		foreach ($method->slotFor as $slot)
202		{
203		$key = implode('@', [$fqn, $methodName, '()']);
204		$this->data[Signal::Signals][$slot][$fqn][$key] = sprintf('%s()', $methodName);
205		}
206		}
207
208		// For property injection
209		foreach ($meta->fields() as $fieldName => $field)
210		{
211		/* @var $field DocumentPropertyMeta */
212		foreach ($field->slotFor as $slot)
213		{
214		$key = implode('@', [$fqn, $fieldName]);
215		$this->data[Signal::Signals][$slot][$fqn][$key] = sprintf('%s', $fieldName);
216		}
217		}
218		}
219
220		private function hasSignals($contents)
221		{
222		foreach ($this->patterns as $pattern)
223		{
224		if (preg_match($pattern, $contents))
225		{
226		return true;
227		}
228		}
229		return false;
230		}
231
232		private function log(Exception $e, $file)
233		{
234		$msg = sprintf('Exception: "%s" while scanning file `%s`', $e->getMessage(), $file);
235		$this->signal->getLogger()->warning($msg);
236		}
237
238		}
239

Maslosoft / Signals

Push — master ( c632d0...4a7120 )

Addendum::setSignal() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like