Maslosoft\Signals\Signal

Complexity

Total Complexity

48

Size/Duplication

Total Lines	423
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

48.89%

Importance

Changes	40
Bugs	4	Features	6

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	__get()	0	4	1
A	__set()	0	4	1
A	getVersion()	0	8	2
A	init()	0	11	3
A	filter()	0	14	4
C	emit()	0	48	11
C	gather()	0	40	8
A	getFilters()	0	13	3
A	getLogger()	0	4	1
A	setLogger()	0	5	1
A	getDi()	0	4	1
A	setDi()	0	5	1
A	getIO()	0	4	1
A	setIO()	0	4	1
A	getExtractor()	0	4	1
A	setExtractor()	0	4	1
A	resetCache()	0	4	1
A	reload()	0	4	1
A	getConfigured()	0	16	3
A	setConfigured()	0	6	1

<?php

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

namespace Maslosoft\Signals;

use Maslosoft\Addendum\Utilities\ClassChecker;
use Maslosoft\Addendum\Utilities\NameNormalizer;
use Maslosoft\Cli\Shared\ConfigReader;
use Maslosoft\EmbeDi\EmbeDi;
use Maslosoft\Signals\Builder\Addendum;
use Maslosoft\Signals\Builder\IO\PhpFile;
use Maslosoft\Signals\Factories\FilterFactory;
use Maslosoft\Signals\Factories\SlotFactory;
use Maslosoft\Signals\Helpers\PostFilter;
use Maslosoft\Signals\Helpers\PreFilter;
use Maslosoft\Signals\Interfaces\BuilderIOInterface;
use Maslosoft\Signals\Interfaces\ExtractorInterface;
use Maslosoft\Signals\Interfaces\FilterInterface;
use Maslosoft\Signals\Interfaces\PostFilterInterface;
use Maslosoft\Signals\Interfaces\PreFilterInterface;
use Maslosoft\Signals\Interfaces\SignalAwareInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use UnexpectedValueException;

/**
 * Main signals components
 *
 * @author Piotr
 * @property LoggerInterface $logger Logger, set this to log warnings, notices errors. This is shorthand for `get/setLogger`.
 */
class Signal implements LoggerAwareInterface
{

	const Slots = 'slots';
	const Signals = 'signals';

	/**
	 * Generated signals name.
	 * Name of this constant is confusing.
	 * @internal description
	 */
	const ConfigFilename = 'signals-definition.php';

	/**
	 * Config file name
	 */
	const ConfigName = "signals";

	/**
	 * Runtime path.
	 * This is path where config from yml will be stored.
	 * Path is relative to project root.
	 * @var string
	 */
	public $runtimePath = 'runtime';

	/**
	 * This aliases will be searched for SlotFor and SignalFor annotations
	 * TODO Autodetect based on composer autoload
	 * @var string[]
	 */
	public $paths = [
		'vendor',
	];

	/**
	 * Filters configuration.
	 * This filters will be applied to every emit.
	 * @var string[]|object[]
	 */
	public $filters = [];

	/**
	 * Sorters configuration.
	 * @var string[]|object[]
	 */
	public $sorters = [];

	/**
	 * Extractor configuration
	 * @var string|[]|object
	 */
	public $extractor = Addendum::class;

	/**
	 * Input/Output configuration
	 * @var string|[]|object
	 */
	public $io = PhpFile::class;

	/**
	 * Whenever component is initialized
	 * @var bool
	 */
	public $isInitialized = false;

	/**
	 * Configuration of signals and slots
	 * @var string[][]
	 */
	private static $config = [];

	/**
	 * Logger
	 * @var LoggerInterface
	 */
	private $logger = null;

	/**
	 *
	 * @var EmbeDi
	 */
	private $di = null;

	/**
	 * Version
	 * @var string
	 */
	private $version = null;

	/**
	 * Current filters
	 * @var PreFilterInterface[]|PostFilterInterface[]
	 */
	private $currentFilters = [];

	public function __construct($configName = self::ConfigName)
	{
		$this->logger = new NullLogger;

		/**
		 * TODO This should be made as embedi adapter, currently unsupported
		 */
		$config = new ConfigReader($configName);
		$this->di = EmbeDi::fly($configName);
		$this->di->apply($config->toArray(), $this);
		$this->di->configure($this);
	}

	/**
	 * Getter
	 * @param string $name
	 * @return mixed
	 */
	public function __get($name)
	{
		return $this->{'get' . ucfirst($name)}();
	}

	/**
	 * Setter
	 * @param string $name
	 * @param mixed $value
	 * @return mixed
	 */
	public function __set($name, $value)
	{
		return $this->{'set' . ucfirst($name)}($value);
	}

	/**
	 * Get current signals version
	 *
	 * @codeCoverageIgnore
	 * @return string
	 */
	public function getVersion()
	{
		if (null === $this->version)
		{
			$this->version = require __DIR__ . '/version.php';
		}
		return $this->version;
	}

	public function init()
	{
		if (!$this->isInitialized)
		{
			$this->reload();
		}
		if (!$this->di->isStored($this))
		{
			$this->di->store($this);
		}
	}

	/**
	 * Apply filter to current emit.
	 * @param FilterInterface|string|mixed $filter
	 * @return Signal
	 * @throws UnexpectedValueException
	 */
	public function filter($filter)
	{
		// Instantiate from string or array
		if (!is_object($filter))
		{
			$filter = $this->di->apply($filter);
		}
		if (!$filter instanceof PreFilterInterface && !$filter instanceof PostFilterInterface)
		{
			throw new UnexpectedValueException(sprintf('$filter must implement either `%s` or `%s` interface', PreFilterInterface::class, PostFilterInterface::class));
		}
		$this->currentFilters[] = $filter;
		return $this;
	}

	/**
	 * Emit signal to inform slots
	 * @param object|string $signal
	 * @return object[]
	 */
	public function emit($signal)
	{
		$result = [];
		if (is_string($signal))
		{
			$signal = new $signal;
		}
		$name = get_class($signal);
		NameNormalizer::normalize($name);
		if (empty(self::$config))
		{
			$this->init();
		}
		if (!isset(self::$config[self::Signals][$name]))
		{
			self::$config[self::Signals][$name] = [];
			$this->logger->debug('No slots found for signal `{name}`, skipping', ['name' => $name]);
			return $result;
		}

		foreach (self::$config[self::Signals][$name] as $fqn => $injections)

The expression self::$config[self::Signals][$name] of type string is not traversable.

		{
			// Skip
			if (false === $injections || count($injections) == 0)
			{
				continue;
			}
			if (!PreFilter::filter($this, $fqn, $signal))
			{
				continue;
			}
			foreach ($injections as $injection)
			{
				$injected = SlotFactory::create($this, $signal, $fqn, $injection);
				if (false === $injected)
				{
					continue;
				}
				if (!PostFilter::filter($this, $injected, $signal))
				{
					continue;
				}
				$result[] = $injected;
			}
		}
		$this->currentFilters = [];
		return $result;
	}

	/**
	 * Call for signals from slot
	 * @param object $slot
	 * @param string $interface Interface, which must be implemented to get into slot
	 */
	public function gather($slot, $interface = null)
	{
		$name = get_class($slot);
		NameNormalizer::normalize($name);
		if (empty(self::$config))
		{
			$this->init();
		}
		if (!isset(self::$config[self::Slots][$name]))
		{
			self::$config[self::Slots][$name] = [];
			$this->logger->debug('No signals found for slot `{name}`, skipping', ['name' => $name]);
		}
		$result = [];
		foreach ((array) self::$config[self::Slots][$name] as $fqn => $emit)
		{
			if (false === $emit)
			{
				continue;
			}
			// Check if class exists and log if doesn't
			if (!ClassChecker::exists($fqn))
			{
				$this->logger->debug(sprintf("Class `%s` not found while gathering slot `%s`", $fqn, get_class($slot)));
				continue;
			}
			if (null === $interface)
			{
				$result[] = new $fqn;
				continue;
			}

			// Check if class implements interface
			if (isset(class_implements($fqn)[$interface]))
			{
				$result[] = new $fqn;
			}
		}
		return $result;
	}

	/**
	 * Get filters
	 * @param string $interface
	 * @return PreFilterInterface[]|PostFilterInterface[]
	 */
	public function getFilters($interface)
	{
		$filters = FilterFactory::create($this, $interface);
		foreach ($this->currentFilters as $filter)
		{
			if (!$filter instanceof $interface)
			{
				continue;
			}
			$filters[] = $filter;
		}
		return $filters;
	}

	/**
	 * Get logger
	 * @codeCoverageIgnore
	 * @return LoggerInterface
	 */
	public function getLogger()
	{
		return $this->logger;
	}

	/**
	 * Set logger
	 * @codeCoverageIgnore
	 * @param LoggerInterface $logger
	 * @return Signal
	 */
	public function setLogger(LoggerInterface $logger)
	{
		$this->logger = $logger;
		return $this;
	}

	/**
	 * Get dependency injection container
	 * @return EmbeDi
	 */
	public function getDi()
	{
		return $this->di;
	}

	public function setDi(EmbeDi $di)
	{
		$this->di = $di;
		return $this;
	}

	/**
	 * Get Input/Output adapter
	 * @codeCoverageIgnore
	 * @return BuilderIOInterface I/O Adapter
	 */
	public function getIO()
	{
		return $this->getConfigured('io');
	}

	/**
	 * Set Input/Output interface
	 * @codeCoverageIgnore
	 * @param BuilderIOInterface $io
	 * @return Signal
	 */
	public function setIO(BuilderIOInterface $io)
	{
		return $this->setConfigured($io, 'io');
	}

	/**
	 * @codeCoverageIgnore
	 * @return ExtractorInterface
	 */
	public function getExtractor()
	{
		return $this->getConfigured('extractor');
	}

	/**
	 * @codeCoverageIgnore
	 * @param ExtractorInterface $extractor
	 * @return Signal
	 */
	public function setExtractor(ExtractorInterface $extractor)
	{
		return $this->setConfigured($extractor, 'extractor');
	}

	/**
	 * Reloads signals cache and reinitializes component.
	 */
	public function resetCache()
	{
		$this->reload();
	}

	private function reload()
	{
		self::$config = $this->getIO()->read();
	}

	/**
	 * Get configured property
	 * @param string $property
	 * @return SignalAwareInterface
	 */
	private function getConfigured($property)
	{
		if (is_object($this->$property))
		{
			$object = $this->$property;
		}
		else
		{
			$object = $this->di->apply($this->$property);
		}
		if ($object instanceof SignalAwareInterface)
		{
			$object->setSignal($this);
		}
		return $object;
	}

	/**
	 * Set signal aware property
	 * @param SignalAwareInterface $object
	 * @param string $property
	 * @return Signal
	 */
	private function setConfigured(SignalAwareInterface $object, $property)
	{
		$object->setSignal($this);
		$this->$property = $object;
		return $this;
	}

}