AbstractCollectionPersister::evictCollectionCache() - Code Metrics - Inspection of "Fixed wrong operator use in condition" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6055)

by Martin

created 2016-09-27 08:08 UTC

evictCollectionCache() A

↳ Parent: AbstractCollectionPersister

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ORM\Cache\Persister\Collection;

use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Cache\EntityCacheKey;
use Doctrine\ORM\Cache\CollectionCacheKey;
use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
use Doctrine\ORM\Persisters\Collection\CollectionPersister;
use Doctrine\ORM\PersistentCollection;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Cache\Region;
use Doctrine\Common\Util\ClassUtils;

/**
 * @author Fabio B. Silva <[email protected]>
 * @author Guilherme Blanco <[email protected]>
 * @since 2.5
 */
abstract class AbstractCollectionPersister implements CachedCollectionPersister
{
     /**
     * @var \Doctrine\ORM\UnitOfWork
     */
    protected $uow;

    /**
     * @var \Doctrine\ORM\Mapping\ClassMetadataFactory
     */
    protected $metadataFactory;

    /**
     * @var \Doctrine\ORM\Persisters\Collection\CollectionPersister
     */
    protected $persister;

    /**
     * @var \Doctrine\ORM\Mapping\ClassMetadata
     */
    protected $sourceEntity;

    /**
     * @var \Doctrine\ORM\Mapping\ClassMetadata
     */
    protected $targetEntity;

    /**
     * @var array
     */
    protected $association;

     /**
     * @var array
     */
    protected $queuedCache = array();

    /**
     * @var \Doctrine\ORM\Cache\Region
     */
    protected $region;

    /**
     * @var string
     */
    protected $regionName;

    /**
     * @var \Doctrine\ORM\Cache\CollectionHydrator
     */
    protected $hydrator;

    /**
     * @var \Doctrine\ORM\Cache\Logging\CacheLogger
     */
    protected $cacheLogger;

    /**
     * @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister   The collection persister that will be cached.
     * @param \Doctrine\ORM\Cache\Region                              $region      The collection region.
     * @param \Doctrine\ORM\EntityManagerInterface                    $em          The entity manager.
     * @param array                                                   $association The association mapping.
     */
    public function __construct(CollectionPersister $persister, Region $region, EntityManagerInterface $em, array $association)
    {
        $configuration  = $em->getConfiguration();
        $cacheConfig    = $configuration->getSecondLevelCacheConfiguration();
        $cacheFactory   = $cacheConfig->getCacheFactory();

        $this->region           = $region;
        $this->persister        = $persister;
        $this->association      = $association;
        $this->regionName       = $region->getName();
        $this->uow              = $em->getUnitOfWork();
        $this->metadataFactory  = $em->getMetadataFactory();
        $this->cacheLogger      = $cacheConfig->getCacheLogger();
        $this->hydrator         = $cacheFactory->buildCollectionHydrator($em, $association);
        $this->sourceEntity     = $em->getClassMetadata($association['sourceEntity']);
        $this->targetEntity     = $em->getClassMetadata($association['targetEntity']);
    }

    /**
     * {@inheritdoc}
     */
    public function getCacheRegion()
    {
        return $this->region;
    }

    /**
     * {@inheritdoc}
     */
    public function getSourceEntityMetadata()
    {
        return $this->sourceEntity;
    }

    /**
     * {@inheritdoc}
     */
    public function getTargetEntityMetadata()
    {
        return $this->targetEntity;
    }

    /**
     * @param \Doctrine\ORM\PersistentCollection     $collection
     * @param \Doctrine\ORM\Cache\CollectionCacheKey $key
     *
     * @return \Doctrine\ORM\PersistentCollection|null
     */
    public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key)
    {
        if (($cache = $this->region->get($key)) === null) {
            return null;
        }

        if (($cache = $this->hydrator->loadCacheEntry($this->sourceEntity, $key, $cache, $collection)) === null) {

            return null;
        }

        return $cache;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    public function storeCollectionCache(CollectionCacheKey $key, $elements)
    {
        /* @var $targetPersister CachedEntityPersister */
        $associationMapping = $this->sourceEntity->associationMappings[$key->association];
        $targetPersister    = $this->uow->getEntityPersister($this->targetEntity->rootEntityName);
        $targetRegion       = $targetPersister->getCacheRegion();
        $targetHydrator     = $targetPersister->getEntityHydrator();

        // Only preserve ordering if association configured it
        if ( ! (isset($associationMapping['indexBy']) && $associationMapping['indexBy'])) {
            // Elements may be an array or a Collection
            $elements = array_values(is_array($elements) ? $elements : $elements->getValues());
        }

        $entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements);

        foreach ($entry->identifiers as $index => $entityKey) {
            if ($targetRegion->contains($entityKey)) {
                continue;
            }

            $class      = $this->targetEntity;
            $className  = ClassUtils::getClass($elements[$index]);

            if ($className !== $this->targetEntity->name) {
                $class = $this->metadataFactory->getMetadataFor($className);
            }

            $entity       = $elements[$index];
            $entityEntry  = $targetHydrator->buildCacheEntry($class, $entityKey, $entity);

            $targetRegion->put($entityKey, $entityEntry);
        }

        $cached = $this->region->put($key, $entry);

        if ($this->cacheLogger && $cached) {
            $this->cacheLogger->collectionCachePut($this->regionName, $key);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function contains(PersistentCollection $collection, $element)
    {
        return $this->persister->contains($collection, $element);
    }

    /**
     * {@inheritdoc}
     */
    public function containsKey(PersistentCollection $collection, $key)
    {
        return $this->persister->containsKey($collection, $key);
    }

    /**
     * {@inheritdoc}
     */
    public function count(PersistentCollection $collection)
    {
        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
        $entry   = $this->region->get($key);

        if ($entry !== null) {
            return count($entry->identifiers);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        return $this->persister->count($collection);
    }

    /**
     * {@inheritdoc}
     */
    public function get(PersistentCollection $collection, $index)
    {
        return $this->persister->get($collection, $index);
    }

    /**
     * {@inheritdoc}
     */
    public function removeElement(PersistentCollection $collection, $element)
    {
        if ($persisterResult = $this->persister->removeElement($collection, $element)) {
            $this->evictCollectionCache($collection);
            $this->evictElementCache($this->sourceEntity->rootEntityName, $collection->getOwner());
            $this->evictElementCache($this->targetEntity->rootEntityName, $element);
        }

        return $persisterResult;
    }

    /**
     * {@inheritdoc}
     */
    public function slice(PersistentCollection $collection, $offset, $length = null)
    {
        return $this->persister->slice($collection, $offset, $length);
    }

    /**
     * {@inheritDoc}
     */
    public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
    {
        return $this->persister->loadCriteria($collection, $criteria);
    }

    /**
     * Clears cache entries related to the current collection
     *
     * @param PersistentCollection $collection
     */
    protected function evictCollectionCache(PersistentCollection $collection)
    {
        $key = new CollectionCacheKey(
            $this->sourceEntity->rootEntityName,
            $this->association['fieldName'],
            $this->uow->getEntityIdentifier($collection->getOwner())
        );

        $this->region->evict($key);

        if ($this->cacheLogger) {
            $this->cacheLogger->collectionCachePut($this->regionName, $key);
        }
    }

    /**
     * @param string $targetEntity
     * @param object $element
     */
    protected function evictElementCache($targetEntity, $element)
    {
        /* @var $targetPersister CachedEntityPersister */
        $targetPersister = $this->uow->getEntityPersister($targetEntity);
        $targetRegion    = $targetPersister->getCacheRegion();
        $key             = new EntityCacheKey($targetEntity, $this->uow->getEntityIdentifier($element));

        $targetRegion->evict($key);

        if ($this->cacheLogger) {
            $this->cacheLogger->entityCachePut($targetRegion->getName(), $key);
        }
    }
}


1		<?php
2
3		/*
4		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
5		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
6		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
7		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
8		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
9		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
10		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
11		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
12		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
13		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
14		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
15		*
16		* This software consists of voluntary contributions made by many individuals
17		* and is licensed under the MIT license. For more information, see
18		* <http://www.doctrine-project.org>.
19		*/
20
21		namespace Doctrine\ORM\Cache\Persister\Collection;
22
23		use Doctrine\Common\Collections\Criteria;
24		use Doctrine\ORM\Cache\EntityCacheKey;
25		use Doctrine\ORM\Cache\CollectionCacheKey;
26		use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
27		use Doctrine\ORM\Persisters\Collection\CollectionPersister;
28		use Doctrine\ORM\PersistentCollection;
29		use Doctrine\ORM\EntityManagerInterface;
30		use Doctrine\ORM\Cache\Region;
31		use Doctrine\Common\Util\ClassUtils;
32
33		/**
34		* @author Fabio B. Silva <[email protected]>
35		* @author Guilherme Blanco <[email protected]>
36		* @since 2.5
37		*/
38		abstract class AbstractCollectionPersister implements CachedCollectionPersister
39		{
40		/**
41		* @var \Doctrine\ORM\UnitOfWork
42		*/
43		protected $uow;
44
45		/**
46		* @var \Doctrine\ORM\Mapping\ClassMetadataFactory
47		*/
48		protected $metadataFactory;
49
50		/**
51		* @var \Doctrine\ORM\Persisters\Collection\CollectionPersister
52		*/
53		protected $persister;
54
55		/**
56		* @var \Doctrine\ORM\Mapping\ClassMetadata
57		*/
58		protected $sourceEntity;
59
60		/**
61		* @var \Doctrine\ORM\Mapping\ClassMetadata
62		*/
63		protected $targetEntity;
64
65		/**
66		* @var array
67		*/
68		protected $association;
69
70		/**
71		* @var array
72		*/
73		protected $queuedCache = array();
74
75		/**
76		* @var \Doctrine\ORM\Cache\Region
77		*/
78		protected $region;
79
80		/**
81		* @var string
82		*/
83		protected $regionName;
84
85		/**
86		* @var \Doctrine\ORM\Cache\CollectionHydrator
87		*/
88		protected $hydrator;
89
90		/**
91		* @var \Doctrine\ORM\Cache\Logging\CacheLogger
92		*/
93		protected $cacheLogger;
94
95		/**
96		* @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister The collection persister that will be cached.
97		* @param \Doctrine\ORM\Cache\Region $region The collection region.
98		* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
99		* @param array $association The association mapping.
100		*/
101	97	public function __construct(CollectionPersister $persister, Region $region, EntityManagerInterface $em, array $association)
102		{
103	97	$configuration = $em->getConfiguration();
104	97	$cacheConfig = $configuration->getSecondLevelCacheConfiguration();
105	97	$cacheFactory = $cacheConfig->getCacheFactory();
106
107	97	$this->region = $region;
108	97	$this->persister = $persister;
109	97	$this->association = $association;
110	97	$this->regionName = $region->getName();
111	97	$this->uow = $em->getUnitOfWork();
112	97	$this->metadataFactory = $em->getMetadataFactory();
113	97	$this->cacheLogger = $cacheConfig->getCacheLogger();
114	97	$this->hydrator = $cacheFactory->buildCollectionHydrator($em, $association);
115	97	$this->sourceEntity = $em->getClassMetadata($association['sourceEntity']);
116	97	$this->targetEntity = $em->getClassMetadata($association['targetEntity']);
117	97	}
118
119		/**
120		* {@inheritdoc}
121		*/
122	57	public function getCacheRegion()
123		{
124	57	return $this->region;
125		}
126
127		/**
128		* {@inheritdoc}
129		*/
130		public function getSourceEntityMetadata()
131		{
132		return $this->sourceEntity;
133		}
134
135		/**
136		* {@inheritdoc}
137		*/
138		public function getTargetEntityMetadata()
139		{
140		return $this->targetEntity;
141		}
142
143		/**
144		* @param \Doctrine\ORM\PersistentCollection $collection
145		* @param \Doctrine\ORM\Cache\CollectionCacheKey $key
146		*
147		* @return \Doctrine\ORM\PersistentCollection\|null
148		*/
149		public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key)
150		{
151		if (($cache = $this->region->get($key)) === null) {
152		return null;
153		}
154
155		if (($cache = $this->hydrator->loadCacheEntry($this->sourceEntity, $key, $cache, $collection)) === null) {
		0 ignored issues – show Compatibility introduced 2015-12-29 16:33 UTC by Report Bug Copy Issue Report `$cache` of type `object<Doctrine\ORM\Cache\CacheEntry>` is not a sub-type of `object<Doctrine\ORM\Cache\CollectionCacheEntry>`. It seems like you assume a concrete implementation of the interface `Doctrine\ORM\Cache\CacheEntry` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
156		return null;
157		}
158
159		return $cache;
		0 ignored issues – show Bug Best Practice introduced 2015-12-29 16:33 UTC by Report Bug Copy Issue Report The return type of `return $cache;` (`array`) is incompatible with the return type declared by the interface `Doctrine\ORM\Cache\Persi...er::loadCollectionCache` of type `Doctrine\ORM\PersistentCollection\|null`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
160		}
161
162		/**
163		* {@inheritdoc}
164		*/
165		public function storeCollectionCache(CollectionCacheKey $key, $elements)
166		{
167		/* @var $targetPersister CachedEntityPersister */
168		$associationMapping = $this->sourceEntity->associationMappings[$key->association];
169		$targetPersister = $this->uow->getEntityPersister($this->targetEntity->rootEntityName);
170		$targetRegion = $targetPersister->getCacheRegion();
171		$targetHydrator = $targetPersister->getEntityHydrator();
172
173		// Only preserve ordering if association configured it
174		if ( ! (isset($associationMapping['indexBy']) && $associationMapping['indexBy'])) {
175		// Elements may be an array or a Collection
176		$elements = array_values(is_array($elements) ? $elements : $elements->getValues());
177		}
178
179		$entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements);
180
181		foreach ($entry->identifiers as $index => $entityKey) {
182		if ($targetRegion->contains($entityKey)) {
183		continue;
184		}
185
186		$class = $this->targetEntity;
187		$className = ClassUtils::getClass($elements[$index]);
188
189		if ($className !== $this->targetEntity->name) {
190		$class = $this->metadataFactory->getMetadataFor($className);
191		}
192
193		$entity = $elements[$index];
194		$entityEntry = $targetHydrator->buildCacheEntry($class, $entityKey, $entity);
195
196		$targetRegion->put($entityKey, $entityEntry);
197		}
198
199		$cached = $this->region->put($key, $entry);
200
201		if ($this->cacheLogger && $cached) {
202		$this->cacheLogger->collectionCachePut($this->regionName, $key);
203		}
204		}
205
206		/**
207		* {@inheritdoc}
208		*/
209	3	public function contains(PersistentCollection $collection, $element)
210		{
211	3	return $this->persister->contains($collection, $element);
212		}
213
214		/**
215		* {@inheritdoc}
216		*/
217	3	public function containsKey(PersistentCollection $collection, $key)
218		{
219	3	return $this->persister->containsKey($collection, $key);
220		}
221
222		/**
223		* {@inheritdoc}
224		*/
225	3	public function count(PersistentCollection $collection)
226		{
227	3	$ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
228	3	$key = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association['fieldName'], $ownerId);
229	3	$entry = $this->region->get($key);
230
231	3	if ($entry !== null) {
232		return count($entry->identifiers);
		0 ignored issues – show Bug introduced 2015-12-29 16:33 UTC by Report Bug Copy Issue Report Accessing `identifiers` on the interface `Doctrine\ORM\Cache\CacheEntry` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
233		}
234
235	3	return $this->persister->count($collection);
236		}
237
238		/**
239		* {@inheritdoc}
240		*/
241	3	public function get(PersistentCollection $collection, $index)
242		{
243	3	return $this->persister->get($collection, $index);
244		}
245
246		/**
247		* {@inheritdoc}
248		*/
249	3	public function removeElement(PersistentCollection $collection, $element)
250		{
251	3	if ($persisterResult = $this->persister->removeElement($collection, $element)) {
252		$this->evictCollectionCache($collection);
253		$this->evictElementCache($this->sourceEntity->rootEntityName, $collection->getOwner());
254		$this->evictElementCache($this->targetEntity->rootEntityName, $element);
255		}
256
257	3	return $persisterResult;
258		}
259
260		/**
261		* {@inheritdoc}
262		*/
263	3	public function slice(PersistentCollection $collection, $offset, $length = null)
264		{
265	3	return $this->persister->slice($collection, $offset, $length);
266		}
267
268		/**
269		* {@inheritDoc}
270		*/
271		public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
272		{
273		return $this->persister->loadCriteria($collection, $criteria);
274		}
275
276		/**
277		* Clears cache entries related to the current collection
278		*
279		* @param PersistentCollection $collection
280		*/
281		protected function evictCollectionCache(PersistentCollection $collection)
282		{
283		$key = new CollectionCacheKey(
284		$this->sourceEntity->rootEntityName,
285		$this->association['fieldName'],
286		$this->uow->getEntityIdentifier($collection->getOwner())
287		);
288
289		$this->region->evict($key);
290
291		if ($this->cacheLogger) {
292		$this->cacheLogger->collectionCachePut($this->regionName, $key);
293		}
294		}
295
296		/**
297		* @param string $targetEntity
298		* @param object $element
299		*/
300		protected function evictElementCache($targetEntity, $element)
301		{
302		/* @var $targetPersister CachedEntityPersister */
303		$targetPersister = $this->uow->getEntityPersister($targetEntity);
304		$targetRegion = $targetPersister->getCacheRegion();
305		$key = new EntityCacheKey($targetEntity, $this->uow->getEntityIdentifier($element));
306
307		$targetRegion->evict($key);
308
309		if ($this->cacheLogger) {
310		$this->cacheLogger->entityCachePut($targetRegion->getName(), $key);
311		}
312		}
313		}
314

doctrine / orm

Pull Request — master (#6055)

evictCollectionCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like