MagiumConfigurationFactory::getRemoteCache() - Code Metrics - Inspection of "Configuration Build Console command working" - magium/configuration-manager - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — develop (#19)

by Kevin

created 2017-02-16 17:56 UTC

MagiumConfigurationFactory::getRemoteCache() A

↳ Parent: MagiumConfigurationFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	4
cts	4
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	0
crap	1

<?php

namespace Magium\Configuration;

use Magium\Configuration\Config\BuilderFactory;
use Magium\Configuration\Config\BuilderFactoryInterface;
use Magium\Configuration\Config\BuilderInterface;
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;

    public function __construct($magiumConfigurationFile = null)
    {
        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 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($this->xml);
        }
        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 = $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->getLocalCache(), $this->getBuilder(), $this->getRemoteCache());
                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());
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $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\MissingConfigurationException;
9		use Magium\Configuration\File\Context\AbstractContextConfigurationFile;
10		use Magium\Configuration\Manager\CacheFactory;
11		use Magium\Configuration\Manager\Manager;
12		use Magium\Configuration\Manager\ManagerInterface;
13
14		class MagiumConfigurationFactory implements MagiumConfigurationFactoryInterface
15		{
16		protected $file;
17		protected $xml;
18
19		protected $manager;
20		protected $builder;
21		protected $baseDir;
22		protected $contextFile;
23		protected $builderFactory;
24	9
25		public function __construct($magiumConfigurationFile = null)
26	9	{
27	4	if (!$magiumConfigurationFile) {
28	4	$cwd = __DIR__;
29	4	$baseDir = realpath(DIRECTORY_SEPARATOR);
30	4	while ($cwd && $cwd != $baseDir && file_exists($cwd)) {
31	4	$checkFile = $cwd . DIRECTORY_SEPARATOR . 'magium-configuration.xml';
32	3	if (file_exists($checkFile)) {
33	3	$magiumConfigurationFile = $checkFile;
34		break;
35	4	}
36	4	$lastPos = strrpos($cwd, DIRECTORY_SEPARATOR);
37		$cwd = substr($cwd, 0, $lastPos);
38		}
39		}
40	9
41	8	if (file_exists($magiumConfigurationFile)) {
42		$this->file = realpath($magiumConfigurationFile);
43	1	} else {
44		throw new InvalidConfigurationFileException('Unable to file configuration file: ' . $magiumConfigurationFile);
45	8	}
46	8	$this->baseDir = dirname($this->file);
47	8	chdir($this->baseDir);
48	8	$this->xml = simplexml_load_file($magiumConfigurationFile);
49		}
50
51		protected function buildContextFile()
52		{
53		chdir($this->baseDir);
54		$contextFileCheck = (string)$this->xml->contextConfigurationFile['file'];
55		$contextFileType = (string)$this->xml->contextConfigurationFile['type'];
56		$contextFile = realpath($contextFileCheck);
57		if (!$contextFile) {
58		throw new MissingConfigurationException('Unable to find context file: ' . $contextFileCheck);
59		}
60		$class = 'Magium\Configuration\File\Context\\' . ucfirst($contextFileType) . 'File';
61		$reflectionClass = new \ReflectionClass($class);
62		if ($reflectionClass->isSubclassOf(AbstractContextConfigurationFile::class)) {
63		$instance = $reflectionClass->newInstance($contextFile);
64		if ($instance instanceof AbstractContextConfigurationFile) {
65		return $instance;
66		}
67		}
68		throw new InvalidConfigurationException('Unable to load context configuration file: ' . $contextFileCheck);
69		}
70
71		public function getContextFile()
72		{
73		if (!$this->contextFile instanceof AbstractContextConfigurationFile) {
74		$this->contextFile = $this->buildContextFile();
75		}
76		return $this->contextFile;
77		}
78	2
79		public function validateConfigurationFile()
80	2	{
81		$result = false;
82	2	try {
83	2	$doc = new \DOMDocument();
84	2	$doc->load($this->file);
85	1	$result = $doc->schemaValidate(__DIR__ . '/../assets/magium-configuration.xsd');
86		} catch (\Exception $e) {
87		// $result value is already set
88	2	}
89		return $result;
90		}
91
92		/**
93		* Retrieves an instance of the cache based off of the XML cache configuration
94		*
95		* @param \SimpleXMLElement $element
96		* @return \Zend\Cache\Storage\StorageInterface
97		*/
98	2
99		protected function getCache(\SimpleXMLElement $element)
100	2	{
101	2	$cacheFactory = new CacheFactory();
102		return $cacheFactory->getCache($element);
103		}
104
105		public function getBuilderFactory()
106		{
107	2	if (!$this->builderFactory instanceof BuilderFactoryInterface) {
108		$builderFactoryConfig = $this->xml->builderFactory;
109	2	$class = (string)$builderFactoryConfig['class'];
110	2	if (!$class) {
111	2	$class = BuilderFactory::class; // das default
112	2	}
113	2	$reflection = new \ReflectionClass($class);
114		if (!$reflection->implementsInterface(BuilderFactoryInterface::class)) {
115	2	throw new InvalidConfigurationException($class . ' must implement ' . BuilderFactoryInterface::class);
116	2	}
117		$this->builderFactory = $reflection->newInstance($this->xml);
118		}
119	2	return $this->builderFactory;
120	2	}
121
122		/**
123		* @return BuilderInterface
124		*/
125
126		public function getBuilder()
127		{
128		if (!$this->builder instanceof BuilderInterface) {
129	2	$this->builder = $this->getBuilderFactory()->getBuilder();
130		}
131	1	return $this->builder;
132		}
133
134	4	protected function getRemoteCache()
135		{
136	4	$cacheConfig = $this->xml->cache;
137	4	$globalAdapter = $this->getCache($cacheConfig);
138	4	return $globalAdapter;
139		}
140
141	3	protected function getLocalCache()
142		{
143	3	$localCache = null;
144	3	$localCacheConfig = $this->xml->localCache;
145	3	if ($localCacheConfig) {
146	1	$localCache = $this->getCache($localCacheConfig);
147		}
148	3	return $localCache;
149		}
150
151	4	public function getManager()
152		{
153	4	if (!$this->manager instanceof ManagerInterface) {
154	4	$managerClass = Manager::class;
155		if (isset($this->xml->manager['class'])) {
156	3	$managerClass = $this->xml->manager['class'];
157		}
158		$reflectionClass = new \ReflectionClass($managerClass);
159		if ($managerClass == Manager::class) {
160		// just a shortcut so I don't have to rewrite some complicated unit tests. I'm just lazy.
161		$this->manager = new Manager($this->getLocalCache(), $this->getBuilder(), $this->getRemoteCache());
162		return $this->manager;
163		}
164		if (!$reflectionClass->implementsInterface(ManagerInterface::class)) {
165		throw new InvalidConfigurationException('Manager class must implement ' . ManagerInterface::class);
166		}
167		$manager = $reflectionClass->newInstance();
168		/* @var $manager ManagerInterface */
169		$manager->setBuilder($this->getBuilder());
170		$manager->setLocalCache($this->getLocalCache());
		0 ignored issues – show Bug introduced 2017-02-16 17:55 UTC by Report Bug Copy Issue Report It seems like `$this->getLocalCache()` can be `null`; however, `setLocalCache()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
171		$manager->setRemoteCache($this->getRemoteCache());
172		$this->manager = $manager;
173		}
174		return $this->manager;
175		}
176
177		}
178

magium / configuration-manager

Pull Request — develop (#19)

MagiumConfigurationFactory::getRemoteCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like