Jarvis::runCallback() - Code Metrics - Inspection of "reworked test classes and adde BroadcasterTrait fo..." - eric-chau/jarvis - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#67)

by Eric

created 2017-06-06 20:12 UTC

Jarvis::runCallback() A

↳ Parent: Jarvis

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2

<?php

declare(strict_types=1);

namespace Jarvis;

use Jarvis\Skill\Core\CallbackResolver;
use Jarvis\Skill\DependencyInjection\Container;
use Jarvis\Skill\DependencyInjection\ContainerProvider;
use Jarvis\Skill\DependencyInjection\ContainerProviderInterface;
use Jarvis\Skill\EventBroadcaster\BroadcasterInterface;
use Jarvis\Skill\EventBroadcaster\BroadcasterTrait;
use Jarvis\Skill\EventBroadcaster\ControllerEvent;
use Jarvis\Skill\EventBroadcaster\EventInterface;
use Jarvis\Skill\EventBroadcaster\ExceptionEvent;
use Jarvis\Skill\EventBroadcaster\ResponseEvent;
use Jarvis\Skill\EventBroadcaster\RunEvent;
use Jarvis\Skill\Routing\Router;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Jarvis. Minimalist dependency injection container.
 *
 * @property bool                                              $debug
 * @property Router                                            $router
 * @property Request                                           $request
 * @property \Symfony\Component\HttpFoundation\Session\Session $session
 * @property CallbackResolver                                  $callbackResolver
 *
 * @author Eric Chau <[email protected]>
 */
class Jarvis extends Container implements BroadcasterInterface
{
    use BroadcasterTrait {
        broadcast as traitBroadcast;
    }

    const DEFAULT_DEBUG = false;
    const CONTAINER_PROVIDER_FQCN = ContainerProvider::class;

    private $masterSetter = false;

    /**
     * Creates an instance of Jarvis. It can take settings as first argument.
     * List of accepted options:
     *   - providers (type: string|array): fqcn of your container provider
     *   - extra
     *
     * @param  array $settings Your own settings to modify Jarvis behavior
     */
    public function __construct(array $settings = [])
    {
        parent::__construct();

        $this['settings'] = $settings;
        $providers = array_merge([static::CONTAINER_PROVIDER_FQCN], (array) ($settings['providers'] ?? []));
        foreach (array_unique($providers) as $classname) {
            $this->hydrate(new $classname());
        }
    }

    public function __destruct()
    {
        $this->masterBroadcast(BroadcasterInterface::TERMINATE_EVENT);
    }

    /**
     * This method is an another way to get a locked value.
     *
     * Example: $this['foo'] is equal to $this->foo, but it ONLY works for locked values.
     *
     * @param  string $key The key of the locked value
     * @return mixed
     * @throws \InvalidArgumentException if the requested key is not associated to a locked service
     */
    public function __get(string $key)
    {
        if (!isset($this->locked[$key])) {
            throw new \InvalidArgumentException(sprintf('"%s" is not a key of a locked value.', $key));
        }

        $this->masterSet($key, $this[$key]);

        return $this->$key;
    }

    /**
     * Sets new attributes to Jarvis. Note that this method is reserved to Jarvis itself only.
     *
     * @param string $key   The key name of the new attribute
     * @param mixed  $value The value to associate to provided key
     * @throws \LogicException if this method is not called by Jarvis itself
     */
    public function __set(string $key, $value)
    {
        if (!$this->masterSetter) {
            throw new \LogicException('You are not allowed to set new attribute into Jarvis.');
        }

        $this->$key = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($id, $v): void
    {
        parent::offsetSet($id, $v);

        if (!($v instanceof \Closure)) {
            return;
        }

        $refMethod = new \ReflectionMethod($v, '__invoke');
        if (null === $returntype = $refMethod->getReturnType()) {
            return;
        }

        $alias = $returntype->getName();
        if (
            $alias === $id
            || (!class_exists($alias) && !interface_exists($alias))
        ) {
            return;
        }

        if (!isset($this[$alias])) {
            $this->alias($alias, $id);
        } else {
            unset($this[$alias]);
        }
    }


    /**
     * @param  ContainerProviderInterface $provider
     */
    public function hydrate(ContainerProviderInterface $provider): void
    {
        $provider->hydrate($this);
    }

    /**
     * @param  Request|null $request
     * @return Response
     */
    public function run(Request $request = null): Response
    {
        $request = $request ?? $this[Request::class];
        $event = $event = new RunEvent($request);

        try {
            $this->masterBroadcast(BroadcasterInterface::RUN_EVENT, $event);
            if ($response = $event->response()) {
                return $response;
            }

            [$callback, $arguments] = $this[Router::class]->match($request->getMethod(), $request->getPathInfo());

            $event = new ControllerEvent($this[CallbackResolver::class]->resolveReference($callback), $arguments);
            $this->masterBroadcast(BroadcasterInterface::CONTROLLER_EVENT, $event);

            $response = call_user_func_array($event->callback(), $event->arguments());
            $event = new ResponseEvent($request, $response);
            $this->masterBroadcast(BroadcasterInterface::RESPONSE_EVENT, $event);
        } catch (\Throwable $throwable) {
            $event = new ExceptionEvent($throwable);
            $this->masterBroadcast(BroadcasterInterface::EXCEPTION_EVENT, $event);
        }

        return $event->response();
    }

    /**
     * {@inheritdoc}
     */
    public function broadcast(string $name, EventInterface $event = null): void
    {
        if (!$this->masterEmitter && in_array($name, BroadcasterInterface::RESERVED_EVENT_NAMES)) {
            throw new \LogicException(sprintf(
                'You\'re trying to broadcast "$name" but "%s" are reserved event names.',
                implode('|', BroadcasterInterface::RESERVED_EVENT_NAMES)
            ));
        }

        $this->traitBroadcast($name, $event);
    }

    /**
     * {@inheritdoc}
     */
    protected function runCallback($receiver, EventInterface $event)
    {
        $this[CallbackResolver::class]->resolveAndCall($receiver, ['event' => $event]);
    }

    /**
     * Sets new attribute into Jarvis.
     *
     * @param  string $key   The name of the new attribute
     * @param  mixed  $value The value of the new attribute
     */
    private function masterSet(string $key, $value): void
    {
        $this->masterSetter = true;
        $this->$key = $value;
        $this->masterSetter = false;
    }

    /**
     * Enables master emitter mode.
     */
    private function masterBroadcast(string $name, EventInterface $event = null): void
    {
        $this->masterEmitter = true;
        $this->broadcast($name, $event);
        $this->masterEmitter = false;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Jarvis;
6
7			use Jarvis\Skill\Core\CallbackResolver;
8			use Jarvis\Skill\DependencyInjection\Container;
9			use Jarvis\Skill\DependencyInjection\ContainerProvider;
10			use Jarvis\Skill\DependencyInjection\ContainerProviderInterface;
11			use Jarvis\Skill\EventBroadcaster\BroadcasterInterface;
12			use Jarvis\Skill\EventBroadcaster\BroadcasterTrait;
13			use Jarvis\Skill\EventBroadcaster\ControllerEvent;
14			use Jarvis\Skill\EventBroadcaster\EventInterface;
15			use Jarvis\Skill\EventBroadcaster\ExceptionEvent;
16			use Jarvis\Skill\EventBroadcaster\ResponseEvent;
17			use Jarvis\Skill\EventBroadcaster\RunEvent;
18			use Jarvis\Skill\Routing\Router;
19			use Symfony\Component\HttpFoundation\Request;
20			use Symfony\Component\HttpFoundation\Response;
21
22			/**
23			* Jarvis. Minimalist dependency injection container.
24			*
25			* @property bool $debug
26			* @property Router $router
27			* @property Request $request
28			* @property \Symfony\Component\HttpFoundation\Session\Session $session
29			* @property CallbackResolver $callbackResolver
30			*
31			* @author Eric Chau <[email protected]>
32			*/
33			class Jarvis extends Container implements BroadcasterInterface
34			{
35			use BroadcasterTrait {
36			broadcast as traitBroadcast;
37			}
38
39			const DEFAULT_DEBUG = false;
40			const CONTAINER_PROVIDER_FQCN = ContainerProvider::class;
41
42			private $masterSetter = false;
43
44			/**
45			* Creates an instance of Jarvis. It can take settings as first argument.
46			* List of accepted options:
47			* - providers (type: string\|array): fqcn of your container provider
48			* - extra
49			*
50			* @param array $settings Your own settings to modify Jarvis behavior
51			*/
52			public function __construct(array $settings = [])
53			{
54			parent::__construct();
55
56			$this['settings'] = $settings;
57			$providers = array_merge([static::CONTAINER_PROVIDER_FQCN], (array) ($settings['providers'] ?? []));
58			foreach (array_unique($providers) as $classname) {
59			$this->hydrate(new $classname());
60			}
61			}
62
63			public function __destruct()
64			{
65			$this->masterBroadcast(BroadcasterInterface::TERMINATE_EVENT);
66			}
67
68			/**
69			* This method is an another way to get a locked value.
70			*
71			* Example: $this['foo'] is equal to $this->foo, but it ONLY works for locked values.
72			*
73			* @param string $key The key of the locked value
74			* @return mixed
75			* @throws \InvalidArgumentException if the requested key is not associated to a locked service
76			*/
77			public function __get(string $key)
78			{
79			if (!isset($this->locked[$key])) {
80			throw new \InvalidArgumentException(sprintf('"%s" is not a key of a locked value.', $key));
81			}
82
83			$this->masterSet($key, $this[$key]);
84
85			return $this->$key;
86			}
87
88			/**
89			* Sets new attributes to Jarvis. Note that this method is reserved to Jarvis itself only.
90			*
91			* @param string $key The key name of the new attribute
92			* @param mixed $value The value to associate to provided key
93			* @throws \LogicException if this method is not called by Jarvis itself
94			*/
95			public function __set(string $key, $value)
96			{
97			if (!$this->masterSetter) {
98			throw new \LogicException('You are not allowed to set new attribute into Jarvis.');
99			}
100
101			$this->$key = $value;
102			}
103
104			/**
105			* {@inheritdoc}
106			*/
107			public function offsetSet($id, $v): void
108			{
109			parent::offsetSet($id, $v);
110
111			if (!($v instanceof \Closure)) {
112			return;
113			}
114
115			$refMethod = new \ReflectionMethod($v, '__invoke');
116			if (null === $returntype = $refMethod->getReturnType()) {
117			return;
118			}
119
120			$alias = $returntype->getName();
121			if (
122			$alias === $id
123			\|\| (!class_exists($alias) && !interface_exists($alias))
124			) {
125			return;
126			}
127
128			if (!isset($this[$alias])) {
129			$this->alias($alias, $id);
130			} else {
131			unset($this[$alias]);
132			}
133			}
134
135
136			/**
137			* @param ContainerProviderInterface $provider
138			*/
139			public function hydrate(ContainerProviderInterface $provider): void
140			{
141			$provider->hydrate($this);
142			}
143
144			/**
145			* @param Request\|null $request
146			* @return Response
147			*/
148			public function run(Request $request = null): Response
149			{
150			$request = $request ?? $this[Request::class];
151			$event = $event = new RunEvent($request);
152
153			try {
154			$this->masterBroadcast(BroadcasterInterface::RUN_EVENT, $event);
155			if ($response = $event->response()) {
156			return $response;
157			}
158
159			[$callback, $arguments] = $this[Router::class]->match($request->getMethod(), $request->getPathInfo());
			0 ignored issues – show Bug introduced 2017-01-04 22:07 UTC by Report Bug Copy Issue Report The variable `$callback` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2017-01-04 22:07 UTC by Report Bug Copy Issue Report The variable `$arguments` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
160			$event = new ControllerEvent($this[CallbackResolver::class]->resolveReference($callback), $arguments);
161			$this->masterBroadcast(BroadcasterInterface::CONTROLLER_EVENT, $event);
162
163			$response = call_user_func_array($event->callback(), $event->arguments());
164			$event = new ResponseEvent($request, $response);
165			$this->masterBroadcast(BroadcasterInterface::RESPONSE_EVENT, $event);
166			} catch (\Throwable $throwable) {
167			$event = new ExceptionEvent($throwable);
168			$this->masterBroadcast(BroadcasterInterface::EXCEPTION_EVENT, $event);
169			}
170
171			return $event->response();
172			}
173
174			/**
175			* {@inheritdoc}
176			*/
177			public function broadcast(string $name, EventInterface $event = null): void
178			{
179			if (!$this->masterEmitter && in_array($name, BroadcasterInterface::RESERVED_EVENT_NAMES)) {
180			throw new \LogicException(sprintf(
181			'You\'re trying to broadcast "$name" but "%s" are reserved event names.',
182			implode('\|', BroadcasterInterface::RESERVED_EVENT_NAMES)
183			));
184			}
185
186			$this->traitBroadcast($name, $event);
187			}
188
189			/**
190			* {@inheritdoc}
191			*/
192			protected function runCallback($receiver, EventInterface $event)
193			{
194			$this[CallbackResolver::class]->resolveAndCall($receiver, ['event' => $event]);
195			}
196
197			/**
198			* Sets new attribute into Jarvis.
199			*
200			* @param string $key The name of the new attribute
201			* @param mixed $value The value of the new attribute
202			*/
203			private function masterSet(string $key, $value): void
204			{
205			$this->masterSetter = true;
206			$this->$key = $value;
207			$this->masterSetter = false;
208			}
209
210			/**
211			* Enables master emitter mode.
212			*/
213			private function masterBroadcast(string $name, EventInterface $event = null): void
214			{
215			$this->masterEmitter = true;
216			$this->broadcast($name, $event);
217			$this->masterEmitter = false;
218			}
219			}
220

eric-chau / jarvis

Pull Request — master (#67)

Jarvis::runCallback() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like