XmppClient::getContainer() - Code Metrics - Inspection of "add Query class representing iq query element" - kadet1090/nucleus - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 939cef...4aee11 )

by Kacper

created 2016-08-29 17:29 UTC

XmppClient::getContainer() A

↳ Parent: XmppClient

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php
/**
 * Nucleus - XMPP Library for PHP
 *
 * Copyright (C) 2016, Some rights reserved.
 *
 * @author Kacper "Kadet" Donat <[email protected]>
 *
 * Contact with author:
 * Xmpp: [email protected]
 * E-mail: [email protected]
 *
 * From Kadet with love.
 */

namespace Kadet\Xmpp;

use DI\Container;
use DI\ContainerBuilder;
use Interop\Container\ContainerInterface;
use Kadet\Xmpp\Exception\InvalidArgumentException;
use Kadet\Xmpp\Exception\WriteOnlyException;
use Kadet\Xmpp\Component\Authenticator;
use Kadet\Xmpp\Component\Binding;
use Kadet\Xmpp\Component\Component;
use Kadet\Xmpp\Component\ComponentInterface;
use Kadet\Xmpp\Component\SaslAuthenticator;
use Kadet\Xmpp\Component\TlsEnabler;
use Kadet\Xmpp\Network\Connector;
use Kadet\Xmpp\Stanza\Stanza;
use Kadet\Xmpp\Stream\Features;
use Kadet\Xmpp\Utils\Accessors;
use Kadet\Xmpp\Utils\filter as with;
use Kadet\Xmpp\Utils\ServiceManager;
use Kadet\Xmpp\Xml\XmlElementFactory;
use Kadet\Xmpp\Xml\XmlParser;
use Kadet\Xmpp\Xml\XmlStream;
use React\EventLoop\LoopInterface;
use React\Promise\Deferred;
use React\Promise\ExtendedPromiseInterface;

/**
 * Class XmppClient
 * @package Kadet\Xmpp
 *
 * @property Features           $features  Features provided by that stream
 * @property XmlParser          $parser    XmlParser instance used to process data from stream, can be exchanged only
 *                                         when client is not connected to server.
 * @property string             $resource  Client's jid resource
 * @property Jid                $jid       Client's jid (Jabber Identifier) address.
 * @property ContainerInterface $container Dependency container used for module management.
 * @property string             $language  Stream language (reflects xml:language attribute)
 * @property string             $state     Current client state
 *                                         `disconnected`   - not connected to any server,
 *                                         `connected`      - connected to server, but nothing happened yet,
 *                                         `secured`        - [optional] TLS negotiation succeeded, after stream restart
 *                                         `authenticated`  - authentication succeeded,
 *                                         `bound`          - resource binding succeeded,
 *                                         `ready`          - client is ready to operate
 *
 *                                         However modules can add custom states.
 *
 * @property Connector    $connector Connector used for obtaining stream
 * @property-write string       $password  Password used for client authentication
 */
class XmppClient extends XmlStream implements ContainerInterface
{
    use ServiceManager, Accessors;

    /**
     * Connector used to instantiate stream connection to server.
     *
     * @var Connector
     */
    private $_connector;

    /**
     * Client's jid (Jabber Identifier) address.
     *
     * @var Jid
     */
    private $_jid;

    /**
     * Dependency container used as service manager.
     *
     * @var Container
     */
    private $_container;

    /**
     * Features provided by that stream
     *
     * @var Features
     */
    private $_features;

    /**
     * Current client state.
     *
     * @var string
     */
    private $_state = 'disconnected';
    private $_lang;

    /**
     * XmppClient constructor.
     * @param Jid                  $jid
     * @param array                $options   {
     *     @var XmlParser          $parser    Parser used for interpreting streams.
     *     @var Component[]        $modules   Additional modules registered when creating client.
     *     @var string             $language  Stream language (reflects xml:language attribute)
     *     @var ContainerInterface $container Dependency container used for module management.
     *     @var bool               $default   -modules Load default modules or not
     * }
     */
    public function __construct(Jid $jid, array $options = [])
    {
        $options = array_replace([
            'parser'    => new XmlParser(new XmlElementFactory()),
            'language'  => 'en',
            'container' => ContainerBuilder::buildDevContainer(),
            'connector' => $options['connector'] ?? new Connector\TcpXmppConnector($jid->domain, $options['loop']),
            'jid'       => $jid,

            'modules'         => [],
            'default-modules' => true,
        ], $options);

        parent::__construct($options['parser'], null);
        unset($options['parser']);

        $this->applyOptions($options);

        $this->on('element', function (Features $element) {
            $this->_features = $element;
            $this->emit('features', [$element]);
        }, Features::class);

        $this->on('close', function (Features $element) {

            $this->state = 'disconnected';
        }, Features::class);
    }

    public function applyOptions(array $options)
    {
        $options = \Kadet\Xmpp\Utils\helper\rearrange($options, [
            'container' => 6,
            'jid'       => 5,
            'connector' => 4,
            'modules'   => 3,
            'password'  => -1
        ]);

        if ($options['default-modules']) {
            $options['modules'] = array_merge([
                TlsEnabler::class    => new TlsEnabler(),
                Binding::class       => new Binding(),
                Authenticator::class => new SaslAuthenticator()
            ], $options['modules']);
        }

        foreach ($options as $name => $value) {
            $this->$name = $value;
        }
    }

    public function start(array $attributes = [])
    {
        parent::start(array_merge([
            'xmlns'    => 'jabber:client',
            'version'  => '1.0',
            'language' => $this->_lang
        ], $attributes));
    }

    public function connect()
    {
        $this->getLogger()->debug("Connecting to {$this->_jid->domain}");

        $this->_connector->connect();
    }

    public function bind($jid)
    {
        $this->jid = new Jid($jid);
        $this->emit('bind', [$jid]);

        $this->state = 'bound';

        $queue = new \SplQueue();
        $this->emit('init', [ $queue ]);

        \React\Promise\all(iterator_to_array($queue))->then(function() {
            $this->state = 'ready';
        });
    }

    /**
     * Registers module in client's dependency container.
     *
     * @param ComponentInterface $module    Module to be registered
     * @param bool|string|array  $alias     Module alias, class name by default.
     *                                      `true` for aliasing interfaces and parents too,
     *                                      `false` for aliasing as class name only
     *                                      array for multiple aliases,
     *                                      and any string for alias name
     */
    public function register(ComponentInterface $module, $alias = true)
    {
        $module->setClient($this);
        if ($alias === true) {
            $this->_container->set(get_class($module), $module);

            $this->_addToContainer($module, array_merge(class_implements($module), array_slice(class_parents($module), 1)));
        } elseif(is_array($alias)) {
            $this->_addToContainer($module, $alias);
        } else {
            $this->_addToContainer($module, [ $alias === false ? get_class($module) : $alias ]);
        }
    }

    private function _addToContainer(ComponentInterface $module, array $aliases) {
        foreach ($aliases as $name) {
            if (!$this->has($name)) {
                $this->_container->set($name, $module);
            }
        }
    }

    /**
     * Sends stanza to server and returns promise with server response.
     *
     * @param Stanza $stanza
     * @return ExtendedPromiseInterface
     */
    public function send(Stanza $stanza) : ExtendedPromiseInterface
    {
        $deferred = new Deferred();

        $this->once('element', function(Stanza $stanza) use ($deferred) {
            if($stanza->type === "error") {
                $deferred->reject($stanza);
            } else {
                $deferred->resolve($stanza);
            }
        }, with\stanza\id($stanza->id));
        $this->write($stanza);

        return $deferred->promise();
    }

    private function handleConnect($stream)
    {
        $this->exchangeStream($stream);

        $this->getLogger()->info("Connected to {$this->_jid->domain}");
        $this->start([
            'from' => (string)$this->_jid,
            'to'   => $this->_jid->domain
        ]);

        $this->state = 'connected';

        return $this->emit('connect');
    }

    //region Features
    public function getFeatures()
    {
        return $this->_features;
    }
    //endregion

    //region Parser
    public function setParser(XmlParser $parser)
    {
        if($this->state !== "disconnected") {
            throw new \BadMethodCallException('Parser can be changed only when client is disconnected.');
        }

        parent::setParser($parser);
        $this->_parser->factory->load(require __DIR__ . '/XmlElementLookup.php');
    }

    public function getParser()
    {
        return $this->_parser;
    }
    //endregion

    //region Connector
    protected function setConnector($connector)
    {
        if ($connector instanceof LoopInterface) {
            $this->_connector = new Connector\TcpXmppConnector($this->_jid->domain, $connector);
        } elseif ($connector instanceof Connector) {
            $this->_connector = $connector;
        } else {
            throw new InvalidArgumentException(sprintf(
                '$connector must be either %s or %s instance, %s given.',
                LoopInterface::class, Connector::class, \Kadet\Xmpp\Utils\helper\typeof($connector)
            ));
        }

        $this->_connector->on('connect', function ($stream) {
            return $this->handleConnect($stream);
        });
    }

    public function getConnector()
    {
        return $this->_connector;
    }
    //endregion

    //region Resource
    public function setResource(string $resource)
    {
        $this->_jid = new Jid($this->_jid->domain, $this->_jid->local, $resource);
    }

    public function getResource()
    {
        return $this->_jid->resource;
    }
    //endregion

    //region Password
    public function setPassword(string $password)
    {
        $this->get(Authenticator::class)->setPassword($password);
    }

    public function getPassword()
    {
        throw new WriteOnlyException("Password can't be obtained.");
    }
    //endregion

    //region Modules
    public function setModules(array $modules)
    {
        foreach ($modules as $name => $module) {
            $this->register($module, is_string($name) ? $name : true);
        }
    }
    //endregion

    //region State
    public function setState($state)
    {
        $this->_state = $state;
        $this->emit('state', [$state]);
    }

    public function getState()
    {
        return $this->_state;
    }
    //endregion

    //region Container
    protected function getContainer() : ContainerInterface
    {
        return $this->_container;
    }

    protected function setContainer(Container $container)
    {
        $this->_container = $container;
    }
    //endregion

    //region Language
    public function getLanguage(): string
    {
        return $this->_lang;
    }

    public function setLanguage(string $language)
    {
        $this->_lang = $language;
    }
    //endregion

    //region JID
    public function getJid()
    {
        return $this->_jid;
    }

    protected function setJid(Jid $jid)
    {
        $this->_jid = $jid;
    }
    //endregion
}


1			<?php
2			/**
3			* Nucleus - XMPP Library for PHP
4			*
5			* Copyright (C) 2016, Some rights reserved.
6			*
7			* @author Kacper "Kadet" Donat <[email protected]>
8			*
9			* Contact with author:
10			* Xmpp: [email protected]
11			* E-mail: [email protected]
12			*
13			* From Kadet with love.
14			*/
15
16			namespace Kadet\Xmpp;
17
18			use DI\Container;
19			use DI\ContainerBuilder;
20			use Interop\Container\ContainerInterface;
21			use Kadet\Xmpp\Exception\InvalidArgumentException;
22			use Kadet\Xmpp\Exception\WriteOnlyException;
23			use Kadet\Xmpp\Component\Authenticator;
24			use Kadet\Xmpp\Component\Binding;
25			use Kadet\Xmpp\Component\Component;
26			use Kadet\Xmpp\Component\ComponentInterface;
27			use Kadet\Xmpp\Component\SaslAuthenticator;
28			use Kadet\Xmpp\Component\TlsEnabler;
29			use Kadet\Xmpp\Network\Connector;
30			use Kadet\Xmpp\Stanza\Stanza;
31			use Kadet\Xmpp\Stream\Features;
32			use Kadet\Xmpp\Utils\Accessors;
33			use Kadet\Xmpp\Utils\filter as with;
34			use Kadet\Xmpp\Utils\ServiceManager;
35			use Kadet\Xmpp\Xml\XmlElementFactory;
36			use Kadet\Xmpp\Xml\XmlParser;
37			use Kadet\Xmpp\Xml\XmlStream;
38			use React\EventLoop\LoopInterface;
39			use React\Promise\Deferred;
40			use React\Promise\ExtendedPromiseInterface;
41
42			/**
43			* Class XmppClient
44			* @package Kadet\Xmpp
45			*
46			* @property Features $features Features provided by that stream
47			* @property XmlParser $parser XmlParser instance used to process data from stream, can be exchanged only
48			* when client is not connected to server.
49			* @property string $resource Client's jid resource
50			* @property Jid $jid Client's jid (Jabber Identifier) address.
51			* @property ContainerInterface $container Dependency container used for module management.
52			* @property string $language Stream language (reflects xml:language attribute)
53			* @property string $state Current client state
54			* `disconnected` - not connected to any server,
55			* `connected` - connected to server, but nothing happened yet,
56			* `secured` - [optional] TLS negotiation succeeded, after stream restart
57			* `authenticated` - authentication succeeded,
58			* `bound` - resource binding succeeded,
59			* `ready` - client is ready to operate
60			*
61			* However modules can add custom states.
62			*
63			* @property Connector $connector Connector used for obtaining stream
64			* @property-write string $password Password used for client authentication
65			*/
66			class XmppClient extends XmlStream implements ContainerInterface
67			{
68			use ServiceManager, Accessors;
69
70			/**
71			* Connector used to instantiate stream connection to server.
72			*
73			* @var Connector
74			*/
75			private $_connector;
76
77			/**
78			* Client's jid (Jabber Identifier) address.
79			*
80			* @var Jid
81			*/
82			private $_jid;
83
84			/**
85			* Dependency container used as service manager.
86			*
87			* @var Container
88			*/
89			private $_container;
90
91			/**
92			* Features provided by that stream
93			*
94			* @var Features
95			*/
96			private $_features;
97
98			/**
99			* Current client state.
100			*
101			* @var string
102			*/
103			private $_state = 'disconnected';
104			private $_lang;
105
106			/**
107			* XmppClient constructor.
108			* @param Jid $jid
109			* @param array $options {
110			* @var XmlParser $parser Parser used for interpreting streams.
111			* @var Component[] $modules Additional modules registered when creating client.
112			* @var string $language Stream language (reflects xml:language attribute)
113			* @var ContainerInterface $container Dependency container used for module management.
114			* @var bool $default -modules Load default modules or not
115			* }
116			*/
117			public function __construct(Jid $jid, array $options = [])
118			{
119			$options = array_replace([
120			'parser' => new XmlParser(new XmlElementFactory()),
121			'language' => 'en',
122			'container' => ContainerBuilder::buildDevContainer(),
123			'connector' => $options['connector'] ?? new Connector\TcpXmppConnector($jid->domain, $options['loop']),
124			'jid' => $jid,
125
126			'modules' => [],
127			'default-modules' => true,
128			], $options);
129
130			parent::__construct($options['parser'], null);
131			unset($options['parser']);
132
133			$this->applyOptions($options);
134
135			$this->on('element', function (Features $element) {
136			$this->_features = $element;
137			$this->emit('features', [$element]);
138			}, Features::class);
139
140			$this->on('close', function (Features $element) {
			0 ignored issues – show Unused Code introduced 2016-08-26 16:19 UTC by Report Bug Copy Issue Report The parameter `$element` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
141			$this->state = 'disconnected';
142			}, Features::class);
143			}
144
145			public function applyOptions(array $options)
146			{
147			$options = \Kadet\Xmpp\Utils\helper\rearrange($options, [
148			'container' => 6,
149			'jid' => 5,
150			'connector' => 4,
151			'modules' => 3,
152			'password' => -1
153			]);
154
155			if ($options['default-modules']) {
156			$options['modules'] = array_merge([
157			TlsEnabler::class => new TlsEnabler(),
158			Binding::class => new Binding(),
159			Authenticator::class => new SaslAuthenticator()
160			], $options['modules']);
161			}
162
163			foreach ($options as $name => $value) {
164			$this->$name = $value;
165			}
166			}
167
168			public function start(array $attributes = [])
169			{
170			parent::start(array_merge([
171			'xmlns' => 'jabber:client',
172			'version' => '1.0',
173			'language' => $this->_lang
174			], $attributes));
175			}
176
177			public function connect()
178			{
179			$this->getLogger()->debug("Connecting to {$this->_jid->domain}");
180
181			$this->_connector->connect();
182			}
183
184			public function bind($jid)
185			{
186			$this->jid = new Jid($jid);
187			$this->emit('bind', [$jid]);
188
189			$this->state = 'bound';
190
191			$queue = new \SplQueue();
192			$this->emit('init', [ $queue ]);
193
194			\React\Promise\all(iterator_to_array($queue))->then(function() {
195			$this->state = 'ready';
196			});
197			}
198
199			/**
200			* Registers module in client's dependency container.
201			*
202			* @param ComponentInterface $module Module to be registered
203			* @param bool\|string\|array $alias Module alias, class name by default.
204			* `true` for aliasing interfaces and parents too,
205			* `false` for aliasing as class name only
206			* array for multiple aliases,
207			* and any string for alias name
208			*/
209			public function register(ComponentInterface $module, $alias = true)
210			{
211			$module->setClient($this);
212			if ($alias === true) {
213			$this->_container->set(get_class($module), $module);
214
215			$this->_addToContainer($module, array_merge(class_implements($module), array_slice(class_parents($module), 1)));
216			} elseif(is_array($alias)) {
217			$this->_addToContainer($module, $alias);
218			} else {
219			$this->_addToContainer($module, [ $alias === false ? get_class($module) : $alias ]);
220			}
221			}
222
223			private function _addToContainer(ComponentInterface $module, array $aliases) {
224			foreach ($aliases as $name) {
225			if (!$this->has($name)) {
226			$this->_container->set($name, $module);
227			}
228			}
229			}
230
231			/**
232			* Sends stanza to server and returns promise with server response.
233			*
234			* @param Stanza $stanza
235			* @return ExtendedPromiseInterface
236			*/
237			public function send(Stanza $stanza) : ExtendedPromiseInterface
238			{
239			$deferred = new Deferred();
240
241			$this->once('element', function(Stanza $stanza) use ($deferred) {
242			if($stanza->type === "error") {
243			$deferred->reject($stanza);
244			} else {
245			$deferred->resolve($stanza);
246			}
247			}, with\stanza\id($stanza->id));
248			$this->write($stanza);
249
250			return $deferred->promise();
251			}
252
253			private function handleConnect($stream)
254			{
255			$this->exchangeStream($stream);
256
257			$this->getLogger()->info("Connected to {$this->_jid->domain}");
258			$this->start([
259			'from' => (string)$this->_jid,
260			'to' => $this->_jid->domain
261			]);
262
263			$this->state = 'connected';
264
265			return $this->emit('connect');
266			}
267
268			//region Features
269			public function getFeatures()
270			{
271			return $this->_features;
272			}
273			//endregion
274
275			//region Parser
276			public function setParser(XmlParser $parser)
277			{
278			if($this->state !== "disconnected") {
279			throw new \BadMethodCallException('Parser can be changed only when client is disconnected.');
280			}
281
282			parent::setParser($parser);
283			$this->_parser->factory->load(require __DIR__ . '/XmlElementLookup.php');
284			}
285
286			public function getParser()
287			{
288			return $this->_parser;
289			}
290			//endregion
291
292			//region Connector
293			protected function setConnector($connector)
294			{
295			if ($connector instanceof LoopInterface) {
296			$this->_connector = new Connector\TcpXmppConnector($this->_jid->domain, $connector);
297			} elseif ($connector instanceof Connector) {
298			$this->_connector = $connector;
299			} else {
300			throw new InvalidArgumentException(sprintf(
301			'$connector must be either %s or %s instance, %s given.',
302			LoopInterface::class, Connector::class, \Kadet\Xmpp\Utils\helper\typeof($connector)
303			));
304			}
305
306			$this->_connector->on('connect', function ($stream) {
307			return $this->handleConnect($stream);
308			});
309			}
310
311			public function getConnector()
312			{
313			return $this->_connector;
314			}
315			//endregion
316
317			//region Resource
318			public function setResource(string $resource)
319			{
320			$this->_jid = new Jid($this->_jid->domain, $this->_jid->local, $resource);
321			}
322
323			public function getResource()
324			{
325			return $this->_jid->resource;
326			}
327			//endregion
328
329			//region Password
330			public function setPassword(string $password)
331			{
332			$this->get(Authenticator::class)->setPassword($password);
333			}
334
335			public function getPassword()
336			{
337			throw new WriteOnlyException("Password can't be obtained.");
338			}
339			//endregion
340
341			//region Modules
342			public function setModules(array $modules)
343			{
344			foreach ($modules as $name => $module) {
345			$this->register($module, is_string($name) ? $name : true);
346			}
347			}
348			//endregion
349
350			//region State
351			public function setState($state)
352			{
353			$this->_state = $state;
354			$this->emit('state', [$state]);
355			}
356
357			public function getState()
358			{
359			return $this->_state;
360			}
361			//endregion
362
363			//region Container
364			protected function getContainer() : ContainerInterface
365			{
366			return $this->_container;
367			}
368
369			protected function setContainer(Container $container)
370			{
371			$this->_container = $container;
372			}
373			//endregion
374
375			//region Language
376			public function getLanguage(): string
377			{
378			return $this->_lang;
379			}
380
381			public function setLanguage(string $language)
382			{
383			$this->_lang = $language;
384			}
385			//endregion
386
387			//region JID
388			public function getJid()
389			{
390			return $this->_jid;
391			}
392
393			protected function setJid(Jid $jid)
394			{
395			$this->_jid = $jid;
396			}
397			//endregion
398			}
399

kadet1090 / nucleus

Push — master ( 939cef...4aee11 )

XmppClient::getContainer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like