Burzum\Cake\Generator\Task\ServiceTask

Complexity

Total Complexity

14

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	clearBuffer()	0	3	1
A	collect()	0	15	3
B	collectServices()	0	24	5
B	addServices()	0	23	5

<?php
namespace Burzum\Cake\Generator\Task;

use Cake\Core\App;
use Cake\Core\Plugin;
use Cake\Filesystem\Folder;
use IdeHelper\Generator\Task\TaskInterface;

class ServiceTask implements TaskInterface {

	/**
	 * @var array
	 */
	protected $aliases = [
		'\Burzum\Cake\Service\ServiceAwareTrait::loadService(0)',
		'\ServiceAwareTrait::loadService(0)',
	];

	/**
	 * Buffer
	 *
	 * @var array|null
	 */
	protected static $services;

	/**
	 * @return void
	 */
	public static function clearBuffer() {
		static::$services = null;
	}

	/**
	 * @return array
	 */
	public function collect() {
		$map = [];

		$services = $this->collectServices();
		foreach ($services as $service => $className) {
			$map[$service] = '\\' . $className . '::class';
		}

		$result = [];
		foreach ($this->aliases as $alias) {
			$result[$alias] = $map;
		}

		return $result;
	}

	/**
	 * @return string[]
	 */
	protected function collectServices() {
		if (static::$services !== null) {
			return static::$services;
		}

		$services = [];

		$folders = App::path('Service');
		foreach ($folders as $folder) {
			$services = $this->addServices($services, $folder);
		}

		$plugins = Plugin::loaded();
		foreach ($plugins as $plugin) {

The expression $plugins of type boolean|array is not guaranteed to be traversable. How about adding an additional type check?

			$folders = App::path('Service', $plugin);
			foreach ($folders as $folder) {
				$services = $this->addServices($services, $folder, $plugin);
			}
		}

		static::$services = $services;

		return $services;
	}

	/**
	 * @param array $services
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return string[]
	 */
	protected function addServices(array $services, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Service\.php$/', $file, $matches);
			if (!$matches) {

The expression $matches of type string[] 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.

				continue;
			}
			$service = $matches[1];
			if ($plugin) {

The expression $plugin of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

				$service = $plugin . '.' . $service;
			}

			$className = App::className($service, 'Service', 'Service');
			if (!$className) {

The expression $className of type string|false is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === false instead.

				continue;
			}

			$services[$service] = $className;
		}

		return $services;
	}

}