MichaelRubel\EnhancedContainer\Core\CallProxy

Complexity

Total Complexity

16

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	16
Bugs	3	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	containerCall()	0	8	1
A	__call()	0	12	4
A	__set()	0	14	5
A	__construct()	0	15	1
A	__get()	0	9	4
A	getInternal()	0	3	1

<?php

declare(strict_types=1);

namespace MichaelRubel\EnhancedContainer\Core;

use BadMethodCallException;
use MichaelRubel\EnhancedContainer\Call;
use MichaelRubel\EnhancedContainer\Exceptions\PropertyNotFoundException;
use MichaelRubel\EnhancedContainer\Traits\HelpsProxies;
use ReflectionException;

class CallProxy implements Call
{
    use HelpsProxies;

The trait MichaelRubel\EnhancedContainer\Traits\HelpsProxies requires the property $contextual which is not provided by MichaelRubel\EnhancedContainer\Core\CallProxy.

    /**
     * @var object
     */
    private object $instance;

    /**
     * @var object|null
     */
    private ?object $forwardsTo;

    /**
     * CallProxy constructor.
     *
     * @param object|class-string $class
     * @param array               $dependencies
     * @param string|null         $context
     */
    public function __construct(
        private object | string $class,
        private array $dependencies = [],
        private ?string $context = null
    ) {
        $this->instance = $this->resolvePassedClass(
            $this->class,
            $this->dependencies,
            $this->context
        );

        $this->forwardsTo = (new MethodForwarder(
            $this->class,
            $this->dependencies
        ))->getClass();
    }

    /**
     * Perform the container call.
     *
     * @param object $service
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     * @throws ReflectionException
     */
    public function containerCall(object $service, string $method, array $parameters): mixed
    {
        return app()->call(
            [$service, $method],
            $this->getPassedParameters(
                $service,
                $method,
                $parameters
            )
        );
    }

    /**
     * Gets the internal property by name.
     *
     * @param string $property
     *
     * @return mixed
     */
    public function getInternal(string $property): mixed
    {
        return $this->{$property};
    }

    /**
     * Pass the call through container.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     * @throws ReflectionException
     */
    public function __call(string $method, array $parameters): mixed
    {
        if (method_exists($this->instance, $method)) {
            return $this->containerCall($this->instance, $method, $parameters);
        } elseif (isForwardingEnabled() && ! is_null($this->forwardsTo)) {
            return $this->containerCall($this->forwardsTo, $method, $parameters);
        }

        throw new BadMethodCallException(sprintf(
            'Call to undefined method %s::%s()',
            $this->instance::class,
            $method
        ));
    }

    /**
     * Get the instance's property.
     *
     * @param string $name
     *
     * @return mixed
     * @throws PropertyNotFoundException
     */
    public function __get(string $name): mixed
    {
        if (property_exists($this->instance, $name)) {
            return $this->instance->{$name};
        } elseif (isForwardingEnabled() && ! is_null($this->forwardsTo)) {
            return $this->forwardsTo->{$name};
        }

        return $this->throwPropertyNotFoundException($name, $this->instance);
    }

    /**
     * Set the instance's property.
     *
     * @param string $name
     * @param mixed  $value
     *
     * @throws PropertyNotFoundException
     */
    public function __set(string $name, mixed $value): void
    {
        if (property_exists($this->instance, $name)) {
            $this->instance->{$name} = $value;
        } else {
            if (isForwardingEnabled() && ! is_null($this->forwardsTo)) {
                property_exists($this->forwardsTo, $name)
                    ? $this->forwardsTo->{$name} = $value
                    : $this->throwPropertyNotFoundException($name, $this->forwardsTo);

                return;
            }

            $this->throwPropertyNotFoundException($name, $this->instance);
        }
    }
}