Maslosoft\Addendum\Cache\MetaCache

Complexity

Total Complexity

30

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

85.71%

Importance

Changes	3
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	setComponent()	0	4	1
A	setOptions()	0	4	1
A	__construct()	0	19	3
C	prepare()	0	30	8
B	get()	0	25	4
A	set()	0	14	1
A	remove()	0	10	2
A	clear()	0	4	1
A	_clearCurrent()	0	4	1
B	_clear()	0	12	5
A	_getFilename()	0	4	1
A	_classToFile()	0	4	1
A	mkdir()	0	6	1

<?php

/**
 * This software package is licensed under AGPL, Commercial license.
 *
 * @package maslosoft/addendum
 * @licence AGPL, Commercial
 * @copyright Copyright (c) Piotr Masełkowski <pmaselkowski@gmail.com> (Meta container, further improvements, bugfixes)
 * @copyright Copyright (c) Maslosoft (Meta container, further improvements, bugfixes)
 * @copyright Copyright (c) Jan Suchal (Original version, builder, parser)
 * @link http://maslosoft.com/addendum/ - maslosoft addendum
 * @link https://code.google.com/p/addendum/ - original addendum project
 */

namespace Maslosoft\Addendum\Cache;

use FilesystemIterator;
use Maslosoft\Addendum\Addendum;
use Maslosoft\Addendum\Collections\Meta;
use Maslosoft\Addendum\Helpers\SoftIncluder;
use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
use Maslosoft\Addendum\Options\MetaOptions;
use Maslosoft\Cli\Shared\ConfigDetector;
use Maslosoft\Cli\Shared\Helpers\PhpExporter;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RuntimeException;

class MetaCache
{

	private $_metaClass = null;
	private $_component = null;

	/**
	 * Options
	 * @var string
	 */
	private $_instanceId = null;

	/**
	 * Addendum runtime path
	 * @var string
	 */
	private $_path = '';

	/**
	 *
	 * @var NsCache
	 */
	private $_nsCache = null;

	/**
	 * Runtime path
	 * @var string
	 */
	private static $_runtimePath = null;

	/**
	 * Local cacheq
	 * @var type
	 */
	private static $_cache = [];

	public function __construct($metaClass = null, AnnotatedInterface $component = null, MetaOptions $options = null)
	{
		if (null === self::$_runtimePath)
		{
			self::$_runtimePath = (new ConfigDetector)->getRuntimePath();
		}
		$this->_path = self::$_runtimePath . '/addendum';
		$this->_metaClass = $metaClass;
		$this->_component = $component;
		if (empty($options))
		{
			$this->_instanceId = Addendum::DefaultInstanceId;
		}
		else
		{
			$this->_instanceId = $options->instanceId;
		}
		$this->_nsCache = new NsCache(dirname($this->_getFilename()), Addendum::fly($this->_instanceId));
	}

	public function setComponent(AnnotatedInterface $component = null)
	{
		$this->_component = $component;
	}

	public function setOptions(MetaOptions $options = null)
	{
		$this->_nsCache->setOptions($options);
	}

	public function prepare()
	{
		if (!file_exists($this->_path))
		{
			if (!file_exists(self::$_runtimePath))
			{

				if (is_writable(dirname(self::$_runtimePath)))
				{
					$this->mkdir(self::$_runtimePath);
				}
				if (!is_writable(self::$_runtimePath))
				{
					throw new RuntimeException(sprintf("Runtime path `%s` must exists and be writable", self:: $_runtimePath));

Expected 0 spaces after double colon; 1 found

				}
			}
			if (is_writable(self::$_runtimePath))
			{
				$this->mkdir($this->_path);
			}
			if (!is_writable($this->_path))
			{
				throw new RuntimeException(sprintf("Addendum runtime path `%s` must exists and be writable", $this->_path));
			}
		}
		if (!file_exists(dirname($this->_getFilename())))
		{
			$this->mkdir(dirname($this->_getFilename()));
		}
	}

	public function get()
	{
		$this->prepare();
		$filename = $this->_getFilename();

		if (!$this->_nsCache->valid())
		{
			$this->_clearCurrent();
			return false;
		}

		if (isset(self::$_cache[$filename]))
		{
			return self::$_cache[$filename];
		}

		$data = SoftIncluder::includeFile($filename);

		if (empty($data))
		{
			return false;
		}
		self::$_cache[$filename] = $data;
		return $data;
	}

	public function set(Meta $meta)
	{



		$filename = $this->_getFilename();

		self::$_cache[$filename] = $meta;

		file_put_contents($filename, PhpExporter ::export($meta));

Expected 0 spaces before double colon; 1 found

		chmod($filename, 0666);
		$this->_nsCache->set();
		return $meta;
	}

	public function remove()
	{
		$filename = $this->_getFilename();
		unset(self::$_cache[$filename]);
		if (file_exists($filename))
		{
			return unlink($filename);
		}
		return false;
	}

	/**
	 * Clear entire cache
	 * @return boolean
	 */
	public function clear()
	{
		return $this->_clear($this->_path);
	}

	private function _clearCurrent()
	{
		return $this->_classToFile(dirname($this->_getFilename()));
	}

	private function _clear($path)
	{
		if (!file_exists($path))
		{
			return false;
		}
		foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::CHILD_FIRST) as $dir)
		{
			$dir->isDir() && !$dir->isLink() ? rmdir($dir->getPathname()) : unlink($dir->getPathname());
		}
		return rmdir($path);
	}

	private function _getFilename()
	{
		return sprintf('%s/%s@%s/%s.php', $this->_path, $this->_classToFile($this->_metaClass), $this->_instanceId, str_replace('\\', '/', $this->_classToFile(get_class($this->_component))));
	}

	private function _classToFile($className)
	{
		return str_replace('\\', '.', $className);
	}

	/**
	 * Recursively create dir with proper permissions.
	 * FIXME Apply chmod recursively
	 * @param string $path
	 */
	private function mkdir($path)
	{
		$mask = umask(0000);
		mkdir($path, 0777, true);
		umask($mask);
	}

}