Accessible\Reader\Reader

Complexity

Total Complexity

18

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

88.89%

Importance

Changes	8
Bugs	1	Features	5

5 Methods

Rating	Name	Duplication	Size	Complexity
C	getClassesToRead()	0	34	7
A	getProperties()	0	12	3
B	getClassInformation()	0	26	2
A	getFromCache()	0	18	4
A	saveToCache()	0	10	2

<?php

namespace Accessible\Reader;

use \Accessible\Configuration;

class Reader
{
    /**
     * The name of the annotation classes that define a collection behavior.
     *
     * @var array<string>
     */
    protected static $collectionAnnotationClasses = array(
        "list" => "Accessible\\Annotation\\ListBehavior",
        "map" => "Accessible\\Annotation\\MapBehavior",
        "set" => "Accessible\\Annotation\\SetBehavior",
    );

    /**
     * Get a list of classes and traits to analyze.
     *
     * @param \ReflectionObject $reflectionObject The object to get the parents from.
     *
     * @return array The list of classes to read.
     */
    public static function getClassesToRead(\ReflectionObject $reflectionObject)
    {
        $cacheId = md5("classesToRead:" . $reflectionObject->getName());
        $objectClasses = self::getFromCache($cacheId);
        if ($objectClasses !== null) {
            return $objectClasses;
        }

        $objectClasses = array($reflectionObject);
        $objectTraits = $reflectionObject->getTraits();
        if (!empty($objectTraits)) {
            foreach ($objectTraits as $trait) {
                $objectClasses[] = $trait;
            }
        }

        $parentClass = $reflectionObject->getParentClass();
        while ($parentClass) {
            $objectClasses[] = $parentClass;

            $parentTraits = $parentClass->getTraits();
            if (!empty($parentTraits)) {
                foreach ($parentTraits as $trait) {
                    $objectClasses[] = $trait;
                }
            }

            $parentClass = $parentClass->getParentClass();
        }

        self::saveToCache($cacheId, $objectClasses);

        return $objectClasses;
    }

    /**
     * Get the properties from a list of classes.
     *
     * @param array $classes
     *
     * @return array
     */
    public static function getProperties($classes)
    {
        array_reverse($classes);
        $properties = array();
        foreach ($classes as $class) {
            foreach ($class->getProperties() as $property) {
                $properties[$property->getName()] = $property;
            }
        }

        return $properties;
    }

    /**
     * Get the information on a class from its instance.
     *
     * @param  object $object
     *
     * @return array
     */
    public static function getClassInformation($object)
    {
        $reflectionObject = new \ReflectionObject($object);
        $cacheId = md5("classInformation:" . $reflectionObject->getName());
        $classInfo = self::getFromCache($cacheId);
        if ($classInfo !== null) {
            return $classInfo;
        }

        $objectClasses = self::getClassesToRead($reflectionObject);
        $objectProperties = self::getProperties($objectClasses);
        $annotationReader = Configuration::getAnnotationReader();

        $classInfo = array(
            'accessProperties' => AccessReader::getAccessProperties($objectProperties, $annotationReader),

It seems like $annotationReader defined by \Accessible\Configuration::getAnnotationReader() on line 100 can also be of type object<Doctrine\Common\Annotations\CachedReader>; however, Accessible\Reader\AccessReader::getAccessProperties() does only seem to accept object<Accessible\Reader\Reader>, maybe add an additional type check?

            'collectionsItemNames' => CollectionsReader::getCollectionsItemNames($objectProperties, $annotationReader),
            'associationsList' => AssociationReader::getAssociations($objectProperties, $annotationReader),
            'constraintsValidationEnabled' => ConstraintsReader::isConstraintsValidationEnabled($objectClasses, $annotationReader),
            'initialPropertiesValues' => AutoConstructReader::getPropertiesToInitialize($objectProperties, $annotationReader),
            'initializationNeededArguments' => AutoConstructReader::getConstructArguments($objectClasses, $annotationReader)
        );

        self::saveToCache($cacheId, $classInfo);

        return $classInfo;
    }

    /**
     * Get a value from the cache.
     *
     * @param  string $id
     *
     * @return mixed
     */
    public static function getFromCache($id)
    {
        $arrayCache = Configuration::getArrayCache();
        if ($arrayCache->contains($id)) {
            return $arrayCache->fetch($id);
        }

        $cacheDriver = Configuration::getCacheDriver();
        if ($cacheDriver !== null) {
            $cacheResult = $cacheDriver->fetch($id);
            if ($cacheResult !== false) {
                $arrayCache->save($id, $cacheResult);
                return $cacheResult;
            }
        }

        return null;
    }

    /**
     * Save a value to the cache.
     *
     * @param  string $id
     * @param  mixed $value
     */
    public static function saveToCache($id, $value)
    {
        $arrayCache = Configuration::getArrayCache();
        $cacheDriver = Configuration::getCacheDriver();

        $arrayCache->save($id, $value);
        if ($cacheDriver !== null) {
            $cacheDriver->save($id, $value);
        }
    }
}