MetadataManager::getCache() - Code Metrics - Inspection of "Minor bugfix for Scrutinizer configuration" - FlyingDR/struct - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4cc6c2...176af1 )

by Alexander

created 2017-11-08 15:44 UTC

MetadataManager::getCache() A

↳ Parent: MetadataManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

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

<?php

namespace Flying\Struct\Metadata;

use Doctrine\Common\Cache\Cache;
use Flying\Struct\ConfigurationManager;
use Flying\Struct\StructInterface;

/**
 * Structures metadata manager
 */
class MetadataManager implements MetadataManagerInterface
{
    /**
     * Structures metadata parser
     *
     * @var MetadataParserInterface
     */
    private $parser;
    /**
     * Structures metadata cache
     *
     * @var Cache
     */
    private $cache;
    /**
     * Structures metadata
     *
     * @var array
     */
    private $metadata = [];
    /**
     * Prefix for cache entries for structure metadata
     *
     * @var string
     */
    private $cachePrefix = 'StructMetadata_';

    /**
     * Get structure metadata information for given structure
     *
     * @param string|StructInterface $struct    Either structure class name or instance of structure object
     *                                          to get metadata for
     * @throws \InvalidArgumentException
     * @return StructMetadata|null
     */
    public function getMetadata($struct)
    {
        $class = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        // Get class name of given structure
        if (is_object($struct)) {
            if ($struct instanceof StructInterface) {
                $class = get_class($struct);
            } else {
                throw new \InvalidArgumentException('Structure class must implement StructInterface interface');
            }
        } elseif (is_string($struct)) {
            try {
                $reflection = new \ReflectionClass($struct);
            } catch (\ReflectionException $e) {
                throw new \InvalidArgumentException('Invalid structure class "' . $struct . '"');
            }
            if (in_array(StructInterface::class, $reflection->getInterfaceNames(), true)) {
                $class = $reflection->getName();

            } else {
                throw new \InvalidArgumentException('Structure class must implement StructInterface interface');
            }
        } else {
            throw new \InvalidArgumentException('Invalid structure information is given');
        }
        // Check local metadata storage - fastest possible way
        if (array_key_exists($class, $this->metadata)) {
            return clone $this->metadata[$class];
        }
        // Check metadata cache
        $cacheKey = $this->getCacheKey($class);
        if ($this->getCache()->contains($cacheKey)) {
            $cachedMetadata = $this->getCache()->fetch($cacheKey);
            if ($cachedMetadata instanceof StructMetadata) {
                $this->metadata[$class] = $cachedMetadata;
                return clone $cachedMetadata;
            }
            // Cache has incorrect or corrupted entry
            $this->getCache()->delete($cacheKey);
        }
        // Get metadata from parser
        $metadata = $this->getParser()->getMetadata($class);
        if ($metadata instanceof StructMetadata) {
            $this->metadata[$class] = $metadata;
            $this->getCache()->save($cacheKey, $metadata);
            return clone $metadata;
        }
        // No metadata is found for structure
        return null;
    }

    /**
     * Get cache key for given class
     *
     * @param string $class
     * @return string
     */
    protected function getCacheKey($class)
    {
        return $this->cachePrefix . str_replace('\\', '_', $class);
    }

    /**
     * Get metadata cache
     *
     * @return Cache
     */
    public function getCache()
    {
        if (!$this->cache) {
            $this->cache = ConfigurationManager::getConfiguration()->getCache();
        }
        return $this->cache;
    }

    /**
     * Set metadata cache
     *
     * @param Cache $cache
     * @return $this
     */
    public function setCache(Cache $cache)
    {
        $this->cache = $cache;
        return $this;
    }

    /**
     * Get metadata parser
     *
     * @return MetadataParserInterface
     */
    public function getParser()
    {
        if (!$this->parser) {
            $this->parser = ConfigurationManager::getConfiguration()->getMetadataParser();
            if ($this->parser instanceof AbstractMetadataParser) {
                $this->parser->setMetadataManager($this);
            }
        }
        return $this->parser;
    }

    /**
     * Set metadata parser
     *
     * @param MetadataParserInterface $parser
     * @return $this
     */
    public function setParser(MetadataParserInterface $parser)
    {
        $this->parser = $parser;
        if ($this->parser instanceof AbstractMetadataParser) {
            $this->parser->setMetadataManager($this);
        }
        return $this;
    }
}


1		<?php
2
3		namespace Flying\Struct\Metadata;
4
5		use Doctrine\Common\Cache\Cache;
6		use Flying\Struct\ConfigurationManager;
7		use Flying\Struct\StructInterface;
8
9		/**
10		* Structures metadata manager
11		*/
12		class MetadataManager implements MetadataManagerInterface
13		{
14		/**
15		* Structures metadata parser
16		*
17		* @var MetadataParserInterface
18		*/
19		private $parser;
20		/**
21		* Structures metadata cache
22		*
23		* @var Cache
24		*/
25		private $cache;
26		/**
27		* Structures metadata
28		*
29		* @var array
30		*/
31		private $metadata = [];
32		/**
33		* Prefix for cache entries for structure metadata
34		*
35		* @var string
36		*/
37		private $cachePrefix = 'StructMetadata_';
38
39		/**
40		* Get structure metadata information for given structure
41		*
42		* @param string\|StructInterface $struct Either structure class name or instance of structure object
43		* to get metadata for
44		* @throws \InvalidArgumentException
45		* @return StructMetadata\|null
46		*/
47	188	public function getMetadata($struct)
48		{
49	188	$class = null;
		0 ignored issues – show Unused Code introduced 2017-11-08 15:48 UTC by Report Bug Copy Issue Report `$class` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
50		// Get class name of given structure
51	188	if (is_object($struct)) {
52	163	if ($struct instanceof StructInterface) {
53	162	$class = get_class($struct);
54	162	} else {
55	1	throw new \InvalidArgumentException('Structure class must implement StructInterface interface');
56		}
57	187	} elseif (is_string($struct)) {
58		try {
59	183	$reflection = new \ReflectionClass($struct);
60	183	} catch (\ReflectionException $e) {
61		throw new \InvalidArgumentException('Invalid structure class "' . $struct . '"');
62		}
63	183	if (in_array(StructInterface::class, $reflection->getInterfaceNames(), true)) {
64	182	$class = $reflection->getName();
		0 ignored issues – show Bug introduced 2017-11-08 15:48 UTC by Report Bug Copy Issue Report Consider using `$reflection->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
65	182	} else {
66	1	throw new \InvalidArgumentException('Structure class must implement StructInterface interface');
67		}
68	182	} else {
69	4	throw new \InvalidArgumentException('Invalid structure information is given');
70		}
71		// Check local metadata storage - fastest possible way
72	182	if (array_key_exists($class, $this->metadata)) {
73	67	return clone $this->metadata[$class];
74		}
75		// Check metadata cache
76	182	$cacheKey = $this->getCacheKey($class);
77	182	if ($this->getCache()->contains($cacheKey)) {
78	2	$cachedMetadata = $this->getCache()->fetch($cacheKey);
79	2	if ($cachedMetadata instanceof StructMetadata) {
80	1	$this->metadata[$class] = $cachedMetadata;
81	1	return clone $cachedMetadata;
82		}
83		// Cache has incorrect or corrupted entry
84	1	$this->getCache()->delete($cacheKey);
85	1	}
86		// Get metadata from parser
87	182	$metadata = $this->getParser()->getMetadata($class);
88	182	if ($metadata instanceof StructMetadata) {
89	181	$this->metadata[$class] = $metadata;
90	181	$this->getCache()->save($cacheKey, $metadata);
91	181	return clone $metadata;
92		}
93		// No metadata is found for structure
94	1	return null;
95		}
96
97		/**
98		* Get cache key for given class
99		*
100		* @param string $class
101		* @return string
102		*/
103	182	protected function getCacheKey($class)
104		{
105	182	return $this->cachePrefix . str_replace('\\', '_', $class);
106		}
107
108		/**
109		* Get metadata cache
110		*
111		* @return Cache
112		*/
113	184	public function getCache()
114		{
115	184	if (!$this->cache) {
116	182	$this->cache = ConfigurationManager::getConfiguration()->getCache();
117	182	}
118	184	return $this->cache;
119		}
120
121		/**
122		* Set metadata cache
123		*
124		* @param Cache $cache
125		* @return $this
126		*/
127	6	public function setCache(Cache $cache)
128		{
129	6	$this->cache = $cache;
130	6	return $this;
131		}
132
133		/**
134		* Get metadata parser
135		*
136		* @return MetadataParserInterface
137		*/
138	185	public function getParser()
139		{
140	185	if (!$this->parser) {
141	183	$this->parser = ConfigurationManager::getConfiguration()->getMetadataParser();
142	183	if ($this->parser instanceof AbstractMetadataParser) {
143	183	$this->parser->setMetadataManager($this);
144	183	}
145	183	}
146	185	return $this->parser;
147		}
148
149		/**
150		* Set metadata parser
151		*
152		* @param MetadataParserInterface $parser
153		* @return $this
154		*/
155	7	public function setParser(MetadataParserInterface $parser)
156		{
157	7	$this->parser = $parser;
158	7	if ($this->parser instanceof AbstractMetadataParser) {
159	2	$this->parser->setMetadataManager($this);
160	2	}
161	7	return $this;
162		}
163		}
164

FlyingDR / struct

Push — master ( 4cc6c2...176af1 )

MetadataManager::getCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like