Go\Aop\Framework\ClassFieldAccess

Complexity

Total Complexity

24

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Coupling/Cohesion

Components	5
Dependencies	3

Test Coverage

Coverage

15.87%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	getAccessType()	0	4	1
A	getField()	0	4	1
A	getValue()	0	6	1
A	getValueToSet()	0	6	1
B	ensureScopeRule()	0	22	7
A	proceed()	0	8	2
A	__invoke()	0	32	4
A	getThis()	0	4	1
A	isDynamic()	0	4	1
A	getScope()	0	5	1
A	__toString()	0	9	2

<?php
declare(strict_types = 1);
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2011, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Aop\Framework;

use Go\Aop\AspectException;
use Go\Aop\Intercept\FieldAccess;
use Go\Aop\Support\AnnotatedReflectionProperty;
use ReflectionProperty;
use function get_class;

/**
 * Represents a field access joinpoint
 */
class ClassFieldAccess extends AbstractJoinpoint implements FieldAccess
{

    /**
     * Instance of object for accessing
     *
     * @var object
     */
    protected $instance;

    /**
     * Instance of reflection property
     *
     * @var ReflectionProperty
     */
    protected $reflectionProperty;

    /**
     * New value to set
     *
     * @var mixed
     */
    protected $newValue;

    /**
     * Access type for field access
     *
     * @var integer
     */
    private $accessType;

    /**
     * Copy of the original value of property
     *
     * @var mixed
     */
    private $value;

    /**
     * Constructor for field access
     *
     * @param array $advices List of advices for this invocation
     */
    public function __construct(string $className, string $fieldName, array $advices)
    {
        parent::__construct($advices);

        $this->reflectionProperty = $reflectionProperty = new AnnotatedReflectionProperty($className, $fieldName);
        // Give an access to protected field
        if ($reflectionProperty->isProtected()) {
            $reflectionProperty->setAccessible(true);
        }
    }

    /**
     * Returns the access type.
     */
    public function getAccessType(): int
    {
        return $this->accessType;
    }

    /**
     * Gets the field being accessed.
     *
     * @return AnnotatedReflectionProperty the property which is being accessed.
     */
    public function getField(): ReflectionProperty
    {
        return $this->reflectionProperty;
    }

    /**
     * Gets the current value of property
     */
    public function &getValue()
    {
        $value = &$this->value;

        return $value;
    }

    /**
     * Gets the value that must be set to the field.
     */
    public function &getValueToSet()
    {
        $newValue = &$this->newValue;

        return $newValue;
    }

    /**
     * Checks scope rules for accessing property
     */
    public function ensureScopeRule(int $stackLevel = 2): void
    {
        $property    = $this->reflectionProperty;
        $isProtected = $property->isProtected();
        $isPrivate   = $property->isPrivate();
        if ($isProtected || $isPrivate) {
            $backTrace     = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $stackLevel+1);
            $accessor      = $backTrace[$stackLevel] ?? [];
            $propertyClass = $property->class;
            if (isset($accessor['class'])) {
                // For private and protected properties its ok to access from the same class
                if ($accessor['class'] === $propertyClass) {
                    return;
                }
                // For protected properties its ok to access from any subclass
                if ($isProtected && is_subclass_of($accessor['class'], $propertyClass)) {
                    return;
                }
            }
            throw new AspectException("Cannot access property {$propertyClass}::{$property->name}");
        }
    }

    /**
     * Proceed to the next interceptor in the Chain
     *
     * @return void For field interceptor there is no return values
     */
    final public function proceed()
    {
        if (isset($this->advices[$this->current])) {
            $currentInterceptor = $this->advices[$this->current++];

            $currentInterceptor->invoke($this);
        }
    }

    /**
     * Invokes current field access with all interceptors
     *
     * @param object $instance Instance of object
     * @param integer $accessType Type of access: READ or WRITE
     * @param mixed $originalValue Original value of property
     * @param mixed $newValue New value to set
     *
     * @return mixed
     */
    final public function &__invoke(object $instance, int $accessType, &$originalValue, $newValue = NAN)
    {
        if ($this->level > 0) {
            $this->stackFrames[] = [$this->instance, $this->accessType, &$this->value, &$this->newValue];
        }

        try {
            ++$this->level;

            $this->current    = 0;
            $this->instance   = $instance;
            $this->accessType = $accessType;
            $this->value      = &$originalValue;
            $this->newValue   = $newValue;

            $this->proceed();

            if ($accessType === self::READ) {
                $result = &$this->value;
            } else {
                $result = &$this->newValue;
            }

            return $result;
        } finally {
            --$this->level;

            if ($this->level > 0) {
                [$this->instance, $this->accessType, $this->value, $this->newValue] = array_pop($this->stackFrames);
            }
        }
    }

    /**
     * Returns the object for which current joinpoint is invoked
     *
     * @return object|null Instance of object or null for static call/unavailable context
     */
    final public function getThis(): ?object
    {
        return $this->instance;
    }

    /**
     * Checks if the current joinpoint is dynamic or static
     *
     * Dynamic joinpoint contains a reference to an object that can be received via getThis() method call
     *
     * @see ClassJoinpoint::getThis()
     */
    final public function isDynamic(): bool
    {
        return true;
    }

    /**
     * Returns the static scope name (class name) of this joinpoint.
     */
    final public function getScope(): string
    {
        // $this->instance always contains an object, so we can take it's name as a scope name
        return get_class($this->instance);
    }

    /**
     * Returns a friendly description of current joinpoint
     */
    final public function __toString(): string
    {
        return sprintf(
            '%s(%s->%s)',
            $this->accessType === self::READ ? 'get' : 'set',
            $this->getScope(),
            $this->reflectionProperty->name
        );
    }
}