MagiumConfigurationFactory::getLocalCache() - Code Metrics - Inspection of "Added some static factory methods for some framewo..." - magium/configuration-manager - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#56)

by Kevin

created 2017-04-07 20:04 UTC

MagiumConfigurationFactory::getLocalCache() A

↳ Parent: MagiumConfigurationFactory

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	6
cts	6
cp	1
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	6
nc	2
nop	0
crap	2

<?php

namespace Magium\Configuration;

use Magium\Configuration\Config\BuilderFactory;
use Magium\Configuration\Config\BuilderFactoryInterface;
use Magium\Configuration\Config\BuilderInterface;
use Magium\Configuration\Config\Repository\ConfigurationRepository;
use Magium\Configuration\Config\Context;
use Magium\Configuration\Config\MissingConfigurationException;
use Magium\Configuration\File\Context\AbstractContextConfigurationFile;
use Magium\Configuration\Manager\CacheFactory;
use Magium\Configuration\Manager\Manager;
use Magium\Configuration\Manager\ManagerInterface;

class MagiumConfigurationFactory implements MagiumConfigurationFactoryInterface
{

    protected $file;
    protected $xml;

    protected $manager;
    protected $builder;
    protected $baseDir;
    protected $contextFile;
    protected $builderFactory;
    protected $context = ConfigurationRepository::CONTEXT_DEFAULT;

    protected static $me;

    public function __construct($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
    {
        self::$me = $this;
        if ($context instanceof Context) {
            $context = $context->getContext();
        }
        $this->context = $context;
        if (!$magiumConfigurationFile) {
            $cwd = __DIR__;
            $baseDir = realpath(DIRECTORY_SEPARATOR);
            while ($cwd && $cwd != $baseDir && file_exists($cwd)) {
                $checkFile = $cwd . DIRECTORY_SEPARATOR . 'magium-configuration.xml';
                if (file_exists($checkFile)) {
                    $magiumConfigurationFile = $checkFile;
                    break;
                }
                $lastPos = strrpos($cwd, DIRECTORY_SEPARATOR);
                $cwd = substr($cwd, 0, $lastPos);
            }
        }

        if (file_exists($magiumConfigurationFile)) {
            $this->file = realpath($magiumConfigurationFile);
        } else {
            throw new InvalidConfigurationFileException('Unable to file configuration file: ' . $magiumConfigurationFile);
        }
        $this->baseDir = dirname($this->file);
        chdir($this->baseDir);
        $this->xml = simplexml_load_file($magiumConfigurationFile);
    }

    protected static function getInstance($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)

    {
        if (!self::$me instanceof self) {
            new self($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT);
        }
        return self::$me;
    }

    public static function configurationFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
    {
        $me = self::getInstance($magiumConfigurationFile, $context);
        return $me->getConfiguration($context);
    }

    public static function builderFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
    {
        $me = self::getInstance($magiumConfigurationFile, $context);
        return $me->getBuilder();
    }

    public static function managerFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
    {
        $me = self::getInstance($magiumConfigurationFile, $context);
        return $me->getManager();
    }

    public function getConfiguration($context = ConfigurationRepository::CONTEXT_DEFAULT)
    {
        return $this->getManager()->getConfiguration($context);
    }

    public function setContext($context)
    {
        $this->context = $context;
    }

    protected function buildContextFile()
    {
        chdir($this->baseDir);
        $contextFileCheck = (string)$this->xml->contextConfigurationFile['file'];
        $contextFileType = (string)$this->xml->contextConfigurationFile['type'];
        $contextFile = realpath($contextFileCheck);
        if (!$contextFile) {
            throw new MissingConfigurationException('Unable to find context file: ' . $contextFileCheck);
        }
        $class = 'Magium\Configuration\File\Context\\' . ucfirst($contextFileType) . 'File';
        $reflectionClass = new \ReflectionClass($class);
        if ($reflectionClass->isSubclassOf(AbstractContextConfigurationFile::class)) {
            $instance = $reflectionClass->newInstance($contextFile);
            if ($instance instanceof AbstractContextConfigurationFile) {
                return $instance;
            }
        }
        throw new InvalidConfigurationException('Unable to load context configuration file: ' . $contextFileCheck);
    }

    public function getContextFile()
    {
        if (!$this->contextFile instanceof AbstractContextConfigurationFile) {
            $this->contextFile = $this->buildContextFile();
        }
        return $this->contextFile;
    }

    public function validateConfigurationFile()
    {
        $result = false;
        try {
            $doc = new \DOMDocument();
            $doc->load($this->file);
            $result = $doc->schemaValidate(__DIR__ . '/../assets/magium-configuration.xsd');
        } catch (\Exception $e) {
            // $result value is already set
        }
        return $result;
    }

    /**
     * Retrieves an instance of the cache based off of the XML cache configuration
     *
     * @param \SimpleXMLElement $element
     * @return \Zend\Cache\Storage\StorageInterface
     */

    protected function getCache(\SimpleXMLElement $element)
    {
        $cacheFactory = new CacheFactory();
        return $cacheFactory->getCache($element);
    }

    public function getBuilderFactory()
    {
        if (!$this->builderFactory instanceof BuilderFactoryInterface) {
            $builderFactoryConfig = $this->xml->builderFactory;
            $class = (string)$builderFactoryConfig['class'];
            if (!$class) {
                $class = BuilderFactory::class; // das default
            }
            $reflection = new \ReflectionClass($class);
            if (!$reflection->implementsInterface(BuilderFactoryInterface::class)) {
                throw new InvalidConfigurationException($class . ' must implement ' . BuilderFactoryInterface::class);
            }
            $this->builderFactory = $reflection->newInstance(new \SplFileInfo($this->baseDir), $this->xml, $this->getContextFile());
        }
        return $this->builderFactory;
    }

    /**
     * @return BuilderInterface
     */

    public function getBuilder()
    {
        if (!$this->builder instanceof BuilderInterface) {
            $this->builder = $this->getBuilderFactory()->getBuilder();
        }
        return $this->builder;
    }

    protected function getRemoteCache()
    {
        $cacheConfig = $this->xml->cache;
        $globalAdapter = $this->getCache($cacheConfig);
        return $globalAdapter;
    }

    protected function getLocalCache()
    {
        $localCache = null;
        $localCacheConfig = $this->xml->localCache;
        if ($localCacheConfig) {
            $localCache = $this->getCache($localCacheConfig);
        }
        return $localCache;
    }

    public function getManager()
    {
        if (!$this->manager instanceof ManagerInterface) {
            $managerClass = Manager::class;
            if (isset($this->xml->manager['class'])) {
                $managerClass = (string)$this->xml->manager['class'];
            }
            $reflectionClass = new \ReflectionClass($managerClass);
            if ($managerClass == Manager::class) {
                // just a shortcut so I don't have to rewrite some complicated unit tests.  I'm just lazy.
                $this->manager = new Manager($this->getRemoteCache(), $this->getBuilder(), $this->getLocalCache());
                return $this->manager;
            }
            if (!$reflectionClass->implementsInterface(ManagerInterface::class)) {
                throw new InvalidConfigurationException('Manager class must implement ' . ManagerInterface::class);
            }
            $manager = $reflectionClass->newInstance();
            /* @var $manager ManagerInterface */
            $manager->setBuilder($this->getBuilder());
            $manager->setLocalCache($this->getLocalCache());
            $manager->setRemoteCache($this->getRemoteCache());
            $this->manager = $manager;
        }
        return $this->manager;
    }

}


1		<?php
2
3		namespace Magium\Configuration;
4
5		use Magium\Configuration\Config\BuilderFactory;
6		use Magium\Configuration\Config\BuilderFactoryInterface;
7		use Magium\Configuration\Config\BuilderInterface;
8		use Magium\Configuration\Config\Repository\ConfigurationRepository;
9		use Magium\Configuration\Config\Context;
10		use Magium\Configuration\Config\MissingConfigurationException;
11		use Magium\Configuration\File\Context\AbstractContextConfigurationFile;
12		use Magium\Configuration\Manager\CacheFactory;
13		use Magium\Configuration\Manager\Manager;
14		use Magium\Configuration\Manager\ManagerInterface;
15
16		class MagiumConfigurationFactory implements MagiumConfigurationFactoryInterface
17		{
18
19		protected $file;
20		protected $xml;
21
22		protected $manager;
23		protected $builder;
24		protected $baseDir;
25		protected $contextFile;
26		protected $builderFactory;
27		protected $context = ConfigurationRepository::CONTEXT_DEFAULT;
28
29		protected static $me;
30
31	16	public function __construct($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
32		{
33	16	self::$me = $this;
34	16	if ($context instanceof Context) {
35	1	$context = $context->getContext();
36		}
37	16	$this->context = $context;
38	16	if (!$magiumConfigurationFile) {
39	7	$cwd = __DIR__;
40	7	$baseDir = realpath(DIRECTORY_SEPARATOR);
41	7	while ($cwd && $cwd != $baseDir && file_exists($cwd)) {
42	7	$checkFile = $cwd . DIRECTORY_SEPARATOR . 'magium-configuration.xml';
43	7	if (file_exists($checkFile)) {
44	6	$magiumConfigurationFile = $checkFile;
45	6	break;
46		}
47	7	$lastPos = strrpos($cwd, DIRECTORY_SEPARATOR);
48	7	$cwd = substr($cwd, 0, $lastPos);
49		}
50		}
51
52	16	if (file_exists($magiumConfigurationFile)) {
53	15	$this->file = realpath($magiumConfigurationFile);
54		} else {
55	1	throw new InvalidConfigurationFileException('Unable to file configuration file: ' . $magiumConfigurationFile);
56		}
57	15	$this->baseDir = dirname($this->file);
58	15	chdir($this->baseDir);
59	15	$this->xml = simplexml_load_file($magiumConfigurationFile);
60	15	}
61
62	2	protected static function getInstance($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
		0 ignored issues – show Unused Code introduced 2017-04-07 19:58 UTC by Report Bug Copy Issue Report The parameter `$magiumConfigurationFile` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-04-07 19:58 UTC by Report Bug Copy Issue Report The parameter `$context` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
63		{
64	2	if (!self::$me instanceof self) {
65		new self($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT);
66		}
67	2	return self::$me;
68		}
69
70		public static function configurationFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
71		{
72		$me = self::getInstance($magiumConfigurationFile, $context);
73		return $me->getConfiguration($context);
74		}
75
76	1	public static function builderFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
77		{
78	1	$me = self::getInstance($magiumConfigurationFile, $context);
79	1	return $me->getBuilder();
80		}
81
82	1	public static function managerFactory($magiumConfigurationFile = null, $context = ConfigurationRepository::CONTEXT_DEFAULT)
83		{
84	1	$me = self::getInstance($magiumConfigurationFile, $context);
85	1	return $me->getManager();
86		}
87
88		public function getConfiguration($context = ConfigurationRepository::CONTEXT_DEFAULT)
89		{
90		return $this->getManager()->getConfiguration($context);
91		}
92
93		public function setContext($context)
94		{
95		$this->context = $context;
96		}
97
98	5	protected function buildContextFile()
99		{
100	5	chdir($this->baseDir);
101	5	$contextFileCheck = (string)$this->xml->contextConfigurationFile['file'];
102	5	$contextFileType = (string)$this->xml->contextConfigurationFile['type'];
103	5	$contextFile = realpath($contextFileCheck);
104	5	if (!$contextFile) {
105	1	throw new MissingConfigurationException('Unable to find context file: ' . $contextFileCheck);
106		}
107	4	$class = 'Magium\Configuration\File\Context\\' . ucfirst($contextFileType) . 'File';
108	4	$reflectionClass = new \ReflectionClass($class);
109	4	if ($reflectionClass->isSubclassOf(AbstractContextConfigurationFile::class)) {
110	3	$instance = $reflectionClass->newInstance($contextFile);
111	3	if ($instance instanceof AbstractContextConfigurationFile) {
112	3	return $instance;
113		}
114		}
115	1	throw new InvalidConfigurationException('Unable to load context configuration file: ' . $contextFileCheck);
116		}
117
118	5	public function getContextFile()
119		{
120	5	if (!$this->contextFile instanceof AbstractContextConfigurationFile) {
121	5	$this->contextFile = $this->buildContextFile();
122		}
123	3	return $this->contextFile;
124		}
125
126	2	public function validateConfigurationFile()
127		{
128	2	$result = false;
129		try {
130	2	$doc = new \DOMDocument();
131	2	$doc->load($this->file);
132	2	$result = $doc->schemaValidate(__DIR__ . '/../assets/magium-configuration.xsd');
133	1	} catch (\Exception $e) {
134		// $result value is already set
135		}
136	2	return $result;
137		}
138
139		/**
140		* Retrieves an instance of the cache based off of the XML cache configuration
141		*
142		* @param \SimpleXMLElement $element
143		* @return \Zend\Cache\Storage\StorageInterface
144		*/
145
146	3	protected function getCache(\SimpleXMLElement $element)
147		{
148	3	$cacheFactory = new CacheFactory();
149	3	return $cacheFactory->getCache($element);
150		}
151
152	4	public function getBuilderFactory()
153		{
154	4	if (!$this->builderFactory instanceof BuilderFactoryInterface) {
155	4	$builderFactoryConfig = $this->xml->builderFactory;
156	4	$class = (string)$builderFactoryConfig['class'];
157	4	if (!$class) {
158	3	$class = BuilderFactory::class; // das default
159		}
160	4	$reflection = new \ReflectionClass($class);
161	4	if (!$reflection->implementsInterface(BuilderFactoryInterface::class)) {
162	1	throw new InvalidConfigurationException($class . ' must implement ' . BuilderFactoryInterface::class);
163		}
164	3	$this->builderFactory = $reflection->newInstance(new \SplFileInfo($this->baseDir), $this->xml, $this->getContextFile());
165		}
166	3	return $this->builderFactory;
167		}
168
169		/**
170		* @return BuilderInterface
171		*/
172
173	4	public function getBuilder()
174		{
175	4	if (!$this->builder instanceof BuilderInterface) {
176	3	$this->builder = $this->getBuilderFactory()->getBuilder();
177		}
178	3	return $this->builder;
179		}
180
181	5	protected function getRemoteCache()
182		{
183	5	$cacheConfig = $this->xml->cache;
184	5	$globalAdapter = $this->getCache($cacheConfig);
185	5	return $globalAdapter;
186		}
187
188	4	protected function getLocalCache()
189		{
190	4	$localCache = null;
191	4	$localCacheConfig = $this->xml->localCache;
192	4	if ($localCacheConfig) {
193	2	$localCache = $this->getCache($localCacheConfig);
194		}
195	4	return $localCache;
196		}
197
198	7	public function getManager()
199		{
200	7	if (!$this->manager instanceof ManagerInterface) {
201	6	$managerClass = Manager::class;
202	6	if (isset($this->xml->manager['class'])) {
203	2	$managerClass = (string)$this->xml->manager['class'];
204		}
205	6	$reflectionClass = new \ReflectionClass($managerClass);
206	6	if ($managerClass == Manager::class) {
207		// just a shortcut so I don't have to rewrite some complicated unit tests. I'm just lazy.
208	4	$this->manager = new Manager($this->getRemoteCache(), $this->getBuilder(), $this->getLocalCache());
209	3	return $this->manager;
210		}
211	2	if (!$reflectionClass->implementsInterface(ManagerInterface::class)) {
212	1	throw new InvalidConfigurationException('Manager class must implement ' . ManagerInterface::class);
213		}
214	1	$manager = $reflectionClass->newInstance();
215		/* @var $manager ManagerInterface */
216	1	$manager->setBuilder($this->getBuilder());
217	1	$manager->setLocalCache($this->getLocalCache());
218	1	$manager->setRemoteCache($this->getRemoteCache());
219	1	$this->manager = $manager;
220		}
221	2	return $this->manager;
222		}
223
224		}
225

magium / configuration-manager

Pull Request — develop (#56)

MagiumConfigurationFactory::getLocalCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like