Spaark\CompositeUtils\Service\RawPropertyAccessor

Complexity

Total Complexity

6

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setRawValue()	0	9	1
A	getRawValue()	0	10	1
A	rawAddToValue()	0	9	1
A	getPropertyOrFail()	0	19	2

<?php

namespace Spaark\CompositeUtils\Service;

use Spaark\CompositeUtils\Exception\CannotWritePropertyException;
use Spaark\CompositeUtils\Exception\CannotReadPropertyException;
use \ReflectionClass;
use \ReflectionProperty;
use \ReflectionException;

/**
 * This class is used to access the properties of a class
 */
class RawPropertyAccessor
{
    /**
     * The object being accessed
     *
     * @var object
     */
    protected $object;

    /**
     * A PHP Reflector for access
     *
     * @var ReflectionClass
     */
    protected $reflector;

    /**
     * @param object $object The object to access
     * @param ReflectionModel|null $reflect A reflection entity

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

     */
    public function __construct($object)
    {
        $this->object = $object;
        $this->reflector = new ReflectionClass($object);
    }

    /**
     * Access a property and sets it with the given value, irrespective
     * of access permissions
     *
     * @param string $key The property to write to
     * @param mixed $value The value to set
     * @throws CannotWritePropertyException In the event the property
     *     does not exist
     */
    public function setRawValue($key, $value)
    {
        $this->getPropertyOrFail
        (
            $key,
            CannotWritePropertyException::class
        )
        ->setValue($this->object, $value);
    }

    /**
     * Access a property and returns its value, irresepective of access
     * permissions
     *
     * @param string $key The property to read
     * @return mixed The property's value
     * @throws CannotReadPropertyException In the event the property
     *     does not exist
     */
    public function getRawValue($key)
    {
        return
            $this->getPropertyOrFail
            (
                $key,
                CannotReadPropertyException::class
            )
            ->getValue($this->object);
    }

    /**
     * Adds a value to a property, irrespective of access permissions
     *
     * @param string $key The property to write to
     * @param mixed $value The value to add
     * @throws CannotWritePropertyException In the event the property
     *    does not exist
     */ 
    public function rawAddToValue($key, $value)
    {
        $property = $this->getPropertyOrFail
        (
            $key,
            CannotWritePropertyException::class
        );
        $property->getValue($this->object)->add($value);
    }

    /**
     * Checks if a property exists and returns its ReflectionProperty
     *
     * @param string $key The property to access
     * @param string $class The name of the exception to throw on error
     * @throws $class If the property does not exist
     * @return ReflectionProperty
     */
    private function getPropertyOrFail($key, $class)
    {
        try
        {
            $prop = $this->reflector->getProperty($key);
            $prop->setAccessible(true);

            return $prop;
        }
        catch (ReflectionException $e)
        {
            throw new $class
            (
                get_class($this->object),
                $key,
                $e
            );
        }
    }
}