CallProxy::hasPreviousInteraction() - Code Metrics - michael-rubel/laravel-enhanced-container - Measure and Improve Code Quality continuously with Scrutinizer

CallProxy::hasPreviousInteraction() A
last analyzed 2024-04-26 13:52 UTC

↳ Parent: CallProxy

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	1
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	2
rs	10

<?php

declare(strict_types=1);

namespace MichaelRubel\EnhancedContainer\Core;

use Illuminate\Container\BoundMethod;
use Illuminate\Container\Container;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\ForwardsCalls;
use MichaelRubel\EnhancedContainer\Call;
use MichaelRubel\EnhancedContainer\Exceptions\InstanceInteractionException;
use MichaelRubel\EnhancedContainer\Traits\InteractsWithContainer;

class CallProxy implements Call
{
    use ForwardsCalls, InteractsWithContainer;


    /**
     * Current proxy instance.
     */
    protected object $instance;

    /**
     * Previous proxy instance.
     */
    protected ?object $previous = null;

    /**
     * Determines if the forwarding is enabled in this proxy.
     */
    protected bool $forwarding = true;

    /**
     * Saves proxy interactions (method calls, property assignments, etc).
     */
    protected array $interactions = [];

    /**
     * Initialize a new CallProxy.
     */
    public function __construct(object|string $class, array $dependencies = [], ?string $context = null)
    {
        $this->instance = $this->getInstance($class, $dependencies, $context);
    }

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

    /**
     * Sets the internal instance to previous one.
     */
    public function setPrevious(): static
    {
        if ($this->previous) {
            $oldInstance = $this->instance;

            $this->instance = $this->previous;

            $this->previous = $oldInstance;
        }

        return $this;
    }

    /**
     * Disables the forwarding on the proxy level.
     */
    public function disableForwarding(): static
    {
        $this->forwarding = false;

        return $this;
    }

    /**
     * Enables the forwarding on the proxy level.
     */
    public function enableForwarding(): static
    {
        $this->forwarding = true;

        return $this;
    }

    /**
     * Perform the container call.
     */
    protected function containerCall(object $service, string $method, array $parameters): mixed
    {
        try {
            return BoundMethod::call(
                Container::getInstance(), [$service, $method], $this->getParameters($service, $method, $parameters)
            );
        } catch (\ReflectionException) {
            return $this->forwardCallTo($service, $method, $parameters);
        }
    }

    /**
     * Find the forwarding instance if bound.
     */
    protected function findForwardingInstance(): void
    {
        $clue = $this->instance::class . Forwarding::CONTAINER_KEY;

        if ($this->forwarding && app()->bound($clue)) {
            $newInstance = app($clue);

            $this->previous = $this->instance;
            $this->instance = $newInstance;
        }
    }

    /**
     * Save the interaction with proxy.
     */
    protected function interact(string $name, string $type): void
    {
        $this->interactions[$name] = $type;
    }

    /**
     * Check the proxy has previous interaction
     * with the same method or property.
     */
    protected function hasPreviousInteraction(string $name): bool
    {
        return $this->previous && isset($this->interactions[$name]);
    }

    /**
     * Handle the missing by error message.
     */
    protected function handleMissing(\Closure $callback, string $by): mixed
    {
        try {
            return $callback();
        } catch (\Error|\ErrorException $e) {
            if (Str::contains($e->getMessage(), $by)) {
                $this->findForwardingInstance();

                return $callback();
            }

            throw $e;
        }
    }

    /**
     * Pass the call through container.
     */
    public function __call(string $method, array $parameters): mixed
    {
        if (! method_exists($this->instance, $method)) {
            if ($this->hasPreviousInteraction($method)) {
                throw new InstanceInteractionException;
            }

            $this->findForwardingInstance();
        }

        $this->interact($method, Call::METHOD);

        return $this->handleMissing(
            fn () => $this->containerCall($this->instance, $method, $parameters),
            by: 'Call to undefined method'
        );
    }

    /**
     * Get the instance's property.
     */
    public function __get(string $name): mixed
    {
        if (! property_exists($this->instance, $name)) {
            if ($this->hasPreviousInteraction($name)) {
                throw new InstanceInteractionException;
            }

            $this->findForwardingInstance();
        }

        $this->interact($name, Call::GET);

        return $this->handleMissing(
            fn () => $this->instance->{$name},
            by: 'Undefined property'
        );
    }

    /**
     * Set the instance's property.
     */
    public function __set(string $name, mixed $value): void
    {
        $this->interact($name, Call::SET);

        $this->instance->{$name} = $value;
    }

    /**
     * Check the property is set.
     */
    public function __isset(string $name): bool
    {
        $this->interact($name, Call::ISSET);

        return isset($this->instance->{$name});
    }

    /**
     * Unset the property.
     */
    public function __unset(string $name): void
    {
        $this->interact($name, Call::UNSET);

        unset($this->instance->{$name});
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace MichaelRubel\EnhancedContainer\Core;
6
7		use Illuminate\Container\BoundMethod;
8		use Illuminate\Container\Container;
9		use Illuminate\Support\Str;
10		use Illuminate\Support\Traits\ForwardsCalls;
11		use MichaelRubel\EnhancedContainer\Call;
12		use MichaelRubel\EnhancedContainer\Exceptions\InstanceInteractionException;
13		use MichaelRubel\EnhancedContainer\Traits\InteractsWithContainer;
14
15		class CallProxy implements Call
16		{
17		use ForwardsCalls, InteractsWithContainer;
		0 ignored issues – show introduced 2022-07-05 21:35 UTC by Report Bug Copy Issue Report The trait `MichaelRubel\EnhancedCon...\InteractsWithContainer` requires some properties which are not provided by `MichaelRubel\EnhancedContainer\Core\CallProxy`: `$contextual`, `$map` Loading history...
18
19		/**
20		* Current proxy instance.
21		*/
22		protected object $instance;
23
24		/**
25		* Previous proxy instance.
26		*/
27		protected ?object $previous = null;
28
29		/**
30		* Determines if the forwarding is enabled in this proxy.
31		*/
32		protected bool $forwarding = true;
33
34		/**
35		* Saves proxy interactions (method calls, property assignments, etc).
36		*/
37		protected array $interactions = [];
38
39		/**
40		* Initialize a new CallProxy.
41		*/
42	60	public function __construct(object\|string $class, array $dependencies = [], ?string $context = null)
43		{
44	60	$this->instance = $this->getInstance($class, $dependencies, $context);
45		}
46
47		/**
48		* Gets the internal property by name.
49		*/
50	14	public function getInternal(string $property): mixed
51		{
52	14	return $this->{$property};
53		}
54
55		/**
56		* Sets the internal instance to previous one.
57		*/
58	1	public function setPrevious(): static
59		{
60	1	if ($this->previous) {
61	1	$oldInstance = $this->instance;
62
63	1	$this->instance = $this->previous;
64
65	1	$this->previous = $oldInstance;
66		}
67
68	1	return $this;
69		}
70
71		/**
72		* Disables the forwarding on the proxy level.
73		*/
74	2	public function disableForwarding(): static
75		{
76	2	$this->forwarding = false;
77
78	2	return $this;
79		}
80
81		/**
82		* Enables the forwarding on the proxy level.
83		*/
84	1	public function enableForwarding(): static
85		{
86	1	$this->forwarding = true;
87
88	1	return $this;
89		}
90
91		/**
92		* Perform the container call.
93		*/
94	46	protected function containerCall(object $service, string $method, array $parameters): mixed
95		{
96		try {
97	46	return BoundMethod::call(
98	46	Container::getInstance(), [$service, $method], $this->getParameters($service, $method, $parameters)
99	46	);
100	11	} catch (\ReflectionException) {
101	2	return $this->forwardCallTo($service, $method, $parameters);
102		}
103		}
104
105		/**
106		* Find the forwarding instance if bound.
107		*/
108	20	protected function findForwardingInstance(): void
109		{
110	20	$clue = $this->instance::class . Forwarding::CONTAINER_KEY;
111
112	20	if ($this->forwarding && app()->bound($clue)) {
113	16	$newInstance = app($clue);
114
115	16	$this->previous = $this->instance;
116	16	$this->instance = $newInstance;
117		}
118		}
119
120		/**
121		* Save the interaction with proxy.
122		*/
123	57	protected function interact(string $name, string $type): void
124		{
125	57	$this->interactions[$name] = $type;
126		}
127
128		/**
129		* Check the proxy has previous interaction
130		* with the same method or property.
131		*/
132	20	protected function hasPreviousInteraction(string $name): bool
133		{
134	20	return $this->previous && isset($this->interactions[$name]);
135		}
136
137		/**
138		* Handle the missing by error message.
139		*/
140	56	protected function handleMissing(\Closure $callback, string $by): mixed
141		{
142		try {
143	56	return $callback();
144	13	} catch (\Error\|\ErrorException $e) {
145	9	if (Str::contains($e->getMessage(), $by)) {
146	6	$this->findForwardingInstance();
147
148	6	return $callback();
149		}
150
151	3	throw $e;
152		}
153		}
154
155		/**
156		* Pass the call through container.
157		*/
158	45	public function __call(string $method, array $parameters): mixed
159		{
160	45	if (! method_exists($this->instance, $method)) {
161	15	if ($this->hasPreviousInteraction($method)) {
162	1	throw new InstanceInteractionException;
163		}
164
165	15	$this->findForwardingInstance();
166		}
167
168	45	$this->interact($method, Call::METHOD);
169
170	45	return $this->handleMissing(
171	45	fn () => $this->containerCall($this->instance, $method, $parameters),
172	45	by: 'Call to undefined method'
173	45	);
174		}
175
176		/**
177		* Get the instance's property.
178		*/
179	12	public function __get(string $name): mixed
180		{
181	12	if (! property_exists($this->instance, $name)) {
182	5	if ($this->hasPreviousInteraction($name)) {
183	3	throw new InstanceInteractionException;
184		}
185
186	4	$this->findForwardingInstance();
187		}
188
189	12	$this->interact($name, Call::GET);
190
191	12	return $this->handleMissing(
192	12	fn () => $this->instance->{$name},
193	12	by: 'Undefined property'
194	12	);
195		}
196
197		/**
198		* Set the instance's property.
199		*/
200	6	public function __set(string $name, mixed $value): void
201		{
202	6	$this->interact($name, Call::SET);
203
204	6	$this->instance->{$name} = $value;
205		}
206
207		/**
208		* Check the property is set.
209		*/
210	2	public function __isset(string $name): bool
211		{
212	2	$this->interact($name, Call::ISSET);
213
214	2	return isset($this->instance->{$name});
215		}
216
217		/**
218		* Unset the property.
219		*/
220	2	public function __unset(string $name): void
221		{
222	2	$this->interact($name, Call::UNSET);
223
224	2	unset($this->instance->{$name});
225		}
226		}
227

michael-rubel / laravel-enhanced-container

CallProxy::hasPreviousInteraction() A last analyzed 2024-04-26 13:52 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

CallProxy::hasPreviousInteraction() A
last analyzed 2024-04-26 13:52 UTC