Analogue\ORM\System\Wrappers\ObjectWrapper

Complexity

Total Complexity

19

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getObject()	0	5	1
A	dehydrate()	0	8	1
A	hydrate()	0	5	1
A	getManagedProperties()	0	8	2
B	attributesFromProperties()	0	30	4
A	propertiesFromAttributes()	0	18	2
A	setEntityAttributes()	0	4	1
A	getEntityAttributes()	0	4	1
A	setEntityAttribute()	0	4	1
A	getEntityAttribute()	0	8	2
A	hasAttribute()	0	4	2

<?php

namespace Analogue\ORM\System\Wrappers;

use Zend\Hydrator\HydratorInterface;
use Analogue\ORM\Exceptions\MappingException;

/**
 * Mixed wrapper using HydratorGenerator
 */
class ObjectWrapper extends Wrapper
{
    /** 
     * Internal Representation of analogue's entity attributes
     * 
     * @var  array
     */
    protected $attributes = [];

    /** 
     * Object properties that are not a part of the entity attributes,
     * but which are needed to correctly hydrate the Object
     * 
     * @var array
     */
    protected $unmanagedProperties = [];

    /**
     * The hydrator for the wrapped object
     * 
     * @var  HydratorInterface
     */
    protected $hydrator;

    /**
     * Object Wrapper constructor
     * 
     * @param mixed $object

There is no parameter named $object. Was it maybe removed?

     * @param Analogue\ORM\EntityMap $entityMap
     * 
     * @return  void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($entity, $entityMap, HydratorInterface $hydrator)
    {
        $this->hydrator = $hydrator;
        parent::__construct($entity, $entityMap);
        $this->attributes = $this->dehydrate($entity);
    }

    /**
     * Returns the wrapped entity
     *
     * @return mixed
     */
    public function getObject()
    {   
        $this->hydrate();
        return $this->entity;
    }

    /**  
     * Extract entity attributes / properties to an array of attributes
     * 
     * @param  mixed $entity 
     * @return array
     */
    protected function dehydrate($entity) : array
    {
        $properties = $this->hydrator->extract($entity);

        $this->unmanagedProperties = array_except($properties, $this->getManagedProperties());

        return $this->attributesFromProperties($properties);
    }

    /**  
     * Hydrate object's properties/attribute from the internal array representation
     * 
     * @return mixed
     */
    public function hydrate()
    {
        $properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
        $this->hydrator->hydrate($properties, $this->entity);
    }

    /**  
     * Return properties that will be extracted from the entity
     * 
     * @return array
     */
    protected function getManagedProperties() : array
    {
        $properties = $this->entityMap->getProperties();

        $attributesName = $this->entityMap->getAttributesArrayName();
        
        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);

It seems like you are loosely comparing $attributesName of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

    }

    /** 
     * Convert object's properties to analogue's internal attributes representation
     * 
     * @param  array  $properties 
     * @return array
     */
    protected function attributesFromProperties(array $properties) : array
    {
        // First, we'll only keep the entities that are part of the Entity's
        // attributes
        $managedProperties = $this->getManagedProperties();

        $properties = array_only($properties, $managedProperties);

        // If the entity does not uses the attributes array to store
        // part of its attributes, we'll directly return the properties
        if(! $this->entityMap->usesAttributesArray()) {
            return $properties;
        }

        $arrayName = $this->entityMap->getAttributesArrayName();
        
        if(! array_key_exists($arrayName, $properties)) {
            throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
        }

        if(! is_array($properties[$arrayName])) {
            throw new MappingException("Property $arrayName should be an array.");
        }

        $attributes = $properties[$arrayName];

        unset($properties[$arrayName]);

        return $properties + $attributes;
    }

    /**  
     * Convert internal representation of attributes to an array of properties
     * that can hydrate the actual object.
     * 
     * @param  array  $attributes 
     * @return array
     */
    protected function propertiesFromAttributes(array $attributes) : array

The parameter $attributes is not used and could be removed.

    {
        $attributes = $this->attributes;

        // Get all managed properties 
        $propertyNames = $this->entityMap->getProperties();

        $propertyAttributes = array_only($attributes, $propertyNames);
        $attributesArray = array_except($attributes, $propertyNames);

        $attributesArrayName = $this->entityMap->getAttributesArrayName();

        if($attributesArrayName) {

The expression $attributesArrayName of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $propertyAttributes[$attributesArrayName] = $attributesArray;
        }

        return $propertyAttributes;
    }
    
    /**
     * Method used by the mapper to set the object
     * attribute raw values (hydration)
     *
     * @param array $attributes
     *
     * @return void
     */
    public function setEntityAttributes(array $attributes)
    {
        $this->attributes = $attributes;
    }

    /**
     * Method used by the mapper to get the
     * raw object's values.
     *
     * @return array
     */
    public function getEntityAttributes() : array
    {
        return $this->attributes;
    }

    /**
     * Method used by the mapper to set raw
     * key-value pair
     *
     * @param string $key
     * @param string $value
     *
     * @return void
     */
    public function setEntityAttribute($key, $value)
    {
        $this->attributes[$key] = $value;
    }

    /**
     * Method used by the mapper to get single
     * key-value pair
     *
     * @param  string $key
     * @return mixed|null
     */
    public function getEntityAttribute($key)
    {
        if ($this->hasAttribute($key)) {
            return $this->attributes[$key];
        } else {
            return null;
        }
    }

    /**
     * Test if a given attribute exists
     *
     * @param  string $key
     * @return boolean
     */
    public function hasAttribute($key) : bool
    {
        return array_key_exists($key, $this->attributes) ? true : false;
    }
}