Jarvis::broadcast() - 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-05-21 22:12 UTC

Jarvis::broadcast() D

↳ Parent: Project

Complexity

Conditions	9
Paths	10

Size

Total Lines	29
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	4.909
c	0
b	0
f	0
cc	9
eloc	16
nc	10
nop	2

<?php

declare(strict_types=1);

namespace Jarvis;

use Jarvis\Skill\DependencyInjection\Container;
use Jarvis\Skill\DependencyInjection\ContainerProvider;
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\PermanentEventInterface;
use Jarvis\Skill\EventBroadcaster\ResponseEvent;
use Jarvis\Skill\EventBroadcaster\RunEvent;
use Jarvis\Skill\EventBroadcaster\SimpleEvent;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Jarvis. Minimalist dependency injection container.
 *
 * @property bool                                              $debug
 * @property Request                                           $request
 * @property \Jarvis\Skill\Routing\Router                      $router
 * @property \Symfony\Component\HttpFoundation\Session\Session $session
 * @property \Jarvis\Skill\Core\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  Request|null $request
     * @return Response
     */
    public function run(Request $request = null): Response
    {
        $request = $request ?? $this['request'];
        $event = $event = new RunEvent($request);

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

            [$callback, $arguments] = $this['router']->match($request->getMethod(), $request->getPathInfo());
            $event = new ControllerEvent($this['callbackResolver']->resolve($callback), $arguments);
            $this->masterBroadcast(BroadcasterInterface::CONTROLLER_EVENT, $event);

            $response = $this['callbackResolver']->resolveAndCall($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);
    }

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

eric-chau / jarvis

Pull Request — master (#67)

Jarvis::broadcast() D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like