Client::__construct() - Code Metrics - CharlotteDunois/Livia - Measure and Improve Code Quality continuously with Scrutinizer

Client::__construct() B
last analyzed 2019-10-24 18:53 UTC

↳ Parent: Client

Complexity

Conditions	9
Paths	64

Size

Total Lines	47
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	27
nc	64
nop	2
dl	0
loc	47
rs	8.0555
c	0
b	0
f	0

<?php
/**
 * Livia
 * Copyright 2017-2019 Charlotte Dunois, All Rights Reserved
 *
 * Website: https://charuru.moe
 * License: https://github.com/CharlotteDunois/Livia/blob/master/LICENSE
*/

namespace CharlotteDunois\Livia;

/**
 * The Livia Client, the heart of the framework.
 *
 * @property \CharlotteDunois\Livia\CommandDispatcher                 $dispatcher     The client's command dispatcher.
 * @property \CharlotteDunois\Livia\CommandRegistry                   $registry       The client's command registry.
 * @property \CharlotteDunois\Livia\Providers\SettingProvider|null    $provider       The client's setting provider.
 *
 * @property string|null                                              $commandPrefix  The global command prefix. ({@see Client::setCommandPrefix})
 * @property \CharlotteDunois\Yasmin\Models\User[]                    $owners         Owners of the bot, set by the client option owners. If you simply need to check if a user is an owner of the bot, please use Client::isOwner instead. ({@see \CharlotteDunois\Livia\Client:isOwner})
 */
class Client extends \CharlotteDunois\Yasmin\Client {
    /**
     * The client's command dispatcher.
     * @var \CharlotteDunois\Livia\CommandDispatcher
     */
    protected $dispatcher;
    
    /**
     * The client's command registry.
     * @var \CharlotteDunois\Livia\CommandRegistry
     */
    protected $registry;
    
    /**
     * The client's setting provider.
     * @var \CharlotteDunois\Livia\Providers\SettingProvider|null
     */
    protected $provider;
    
    /**
     * Constructs a new Command Client. Additional available Client Options are as following:
     *
     * ```
     * array(
     *   'commandPrefix' => string|null, (Default command prefix, null means only mentions will trigger the handling, defaults to l$)
     *   'commandBlockedMessagePattern' => bool, (Whether command pattern matches will send command blocked messages, defaults to true)
     *   'commandEditableDuration' => int, (Time in seconds that command messages should be editable, defaults to 30)
     *   'commandThrottlingMessagePattern' => bool, (Whether command pattern matches will send command throttling messages, defaults to true)
     *   'negativeResponseThrottlingDuration' => int, (Time in seconds how long negative responses should be not repeated during that time (determined by authorID-channelID-command), defaults to 15)
     *   'nonCommandEditable' => bool, (Whether messages without commands can be edited to a command, defaults to true)
     *   'unknownCommandResponse' => bool, (Whether the bot should respond to an unknown command, defaults to true)
     *   'owners' => string[], (Array of user IDs)
     *   'invite' => string, (Invite URL to the bot's support server)
     * )
     * ```
     *
     * @param array                           $options  Any Client Options.
     * @param \React\EventLoop\LoopInterface  $loop
     * @throws \Exception
     * @throws \RuntimeException
     * @throws \InvalidArgumentException
     */
    function __construct(array $options = array(), ?\React\EventLoop\LoopInterface $loop = null) {
        if(!\array_key_exists('commandPrefix', $options)) {
            $options['commandPrefix'] = 'l$';
        }
        
        if(!isset($options['commandEditableDuration'])) {
            $options['commandEditableDuration'] = 30;
        }
        
        if(!isset($options['negativeResponseThrottlingDuration'])) {
            $options['negativeResponseThrottlingDuration'] = 15;
        }
        
        if(!isset($options['nonCommandEditable'])) {
            $options['nonCommandEditable'] = true;
        }
        
        if(!isset($options['unknownCommandResponse'])) {
            $options['unknownCommandResponse'] = true;
        }
        
        parent::__construct($options, $loop);
        
        $this->dispatcher = new \CharlotteDunois\Livia\CommandDispatcher($this);
        $this->registry = new \CharlotteDunois\Livia\CommandRegistry($this);
        
        $msgError = function ($error) {
            $this->emit('error', $error);
        };
        
        $this->on('message', function ($message) use ($msgError) {
            $this->dispatcher->handleMessage($message)->done(null, $msgError);
        });
        $this->on('messageUpdate', function ($message, $oldMessage) use ($msgError) {
            $this->dispatcher->handleMessage($message, $oldMessage)->done(null, $msgError);
        });
        
        if(!empty($options['owners'])) {
            $this->once('ready', function () use ($options) {
                if(!\is_array($options['owners'])) {
                    $options['owners'] = array($options['owners']);
                }
                
                foreach($options['owners'] as $owner) {
                    $this->fetchUser($owner)->done(null, function ($error) use ($owner) {
                        $this->emit('warn', 'Unable to fetch owner '.$owner);
                        $this->emit('error', $error);
                    });
                }
            });
        }
    }
    
    /**
     * @param string  $name
     * @return mixed
     * @throws \Exception
     * @internal
     */
    function __get($name) {
        switch($name) {
            case 'dispatcher':
            case 'registry':
            case 'provider':
                return $this->$name;
            break;
            case 'commandPrefix':
                return $this->options['commandPrefix'];
            break;
            case 'owners':
                $owners = array();
                foreach($this->options['owners'] as $owner) {
                    $owners[$owner] = $this->users->get($owner);
                }
                
                return $owners;
            break;
        }
        
        return parent::__get($name);
    }
    
    /**
     * @return string
     * @internal
     */
    function serialize() {
        $serializable = ($this->provider instanceof \Serializable);
        
        if(!$serializable) {
            $provider = $this->provider;
            $this->provider = null;
        }
        
        $str = parent::serialize();
        
        if(!$serializable) {
            $this->provider = $provider;
        }
        
        return $str;
    }
    
    /**
     * @return void
     * @internal
     */
    function unserialize($str) {
        parent::unserialize($str);
        
        foreach($this->registry->internalSerializedCommands as $command) {
            $this->registry->registerCommand($command);
        }
        
        $this->registry->unsetInternalSerializedCommands();
    }
    
    /**
     * Sets the global command prefix. Null indicates that there is no default prefix, and only mentions will be used. Emits a commandPrefixChange event.
     * @param string|null  $prefix
     * @param bool         $fromProvider
     * @return $this
     * @throws \InvalidArgumentException
     */
    function setCommandPrefix($prefix, bool $fromProvider = false) {
        if(\is_string($prefix) && empty($prefix)) {
            throw new \InvalidArgumentException('Can not set an empty string as command prefix');
        }
        
        $this->options['commandPrefix'] = $prefix;
        
        if(!$fromProvider) {
            $this->emit('commandPrefixChange', null, $prefix);
        }
        
        return $this;
    }
    
    /**
     * Checks whether an user is an owner of the bot.
     * @param string|\CharlotteDunois\Yasmin\Models\User|\CharlotteDunois\Yasmin\Models\GuildMember  $user
     * @return bool
     */
    function isOwner($user) {
        if($user instanceof \CharlotteDunois\Yasmin\Models\User || $user instanceof \CharlotteDunois\Yasmin\Models\GuildMember) {
            $user = $user->id;
        }
        
        return (\in_array($user, $this->options['owners']));
    }
    
    /**
     * Sets the setting provider to use, and initializes it once the client is ready.
     * @param \CharlotteDunois\Livia\Providers\SettingProvider  $provider
     * @return \React\Promise\ExtendedPromiseInterface
     */
    function setProvider(\CharlotteDunois\Livia\Providers\SettingProvider $provider) {
        $this->provider = $provider;
        
        return (new \React\Promise\Promise(function (callable $resolve, callable $reject) {
            $classname = \get_class($this->provider);
            
            if($this->readyTimestamp !== null) {
                $this->emit('debug', 'Provider set to '.$classname.' - initializing...');
                $this->provider->init($this)->done($resolve, $reject);
                return;
            }
            
            $this->emit('debug', 'Provider set to '.$classname.' - will initialize once ready');
            
            $this->once('ready', function () use ($resolve, $reject) {
                $this->emit('debug', 'Initializing provider...');
                $this->provider->init($this)->done(function () use ($resolve) {
                    $this->emit('debug', 'Provider finished initialization.');
                    $resolve();
                }, $reject);
            });
        }));
    }
    
    /**
     * Get the guild's prefix - or the default prefix. Null means only mentions.
     * @param \CharlotteDunois\Yasmin\Models\Guild|null  $guild
     * @return string|null
     */
    function getGuildPrefix(?\CharlotteDunois\Yasmin\Models\Guild $guild = null) {
        if($guild !== null && $this->provider !== null) {
            try {
                $prefix = $this->provider->get($guild, 'commandPrefix', 404);
                if($prefix !== 404 && $prefix !== '') {
                    return $prefix;
                }
            } catch (\BadMethodCallException $e) {
                return $this->commandPrefix;
            }
        }
        
        return $this->commandPrefix;
    }
    
    /**
     * Set the guild's prefix. An empty string means the command prefix will be used. Null means only mentions.
     * @param \CharlotteDunois\Yasmin\Models\Guild|null  $guild
     * @param string|null                                $prefix
     * @return bool
     */
    function setGuildPrefix(?\CharlotteDunois\Yasmin\Models\Guild $guild, string $prefix = null) {
        $this->emit('commandPrefixChange', $guild, $prefix);
        return true;
    }
    
    /**
     * Login into Discord. Opens a WebSocket Gateway connection. Resolves once a WebSocket connection has been successfully established (does not mean the client is ready).
     * @param string $token  Your token.
     * @param bool   $force  Forces the client to get the gateway address from Discord.
     * @return \React\Promise\ExtendedPromiseInterface
     * @throws \RuntimeException
     * @internal
     */
    function login(string $token, bool $force = false) {
        $this->addPeriodicTimer(300, array($this->dispatcher, 'cleanupNegativeResponseMessages'));
        
        return parent::login($token, $force);
    }
    
    /**
     * @return \React\Promise\ExtendedPromiseInterface
     * @internal
     */
    function destroy(bool $destroyUtils = true) {
        return parent::destroy($destroyUtils)->then(function () {
            if($this->provider !== null) {
                return $this->provider->destroy();
            }
        });
    }
    
    /**
     * Validates the passed client options.
     * @param array  $options
     * @return void
     * @throws \InvalidArgumentException
     */
    protected function validateClientOptions(array $options) {
        parent::validateClientOptions($options);
        
        \CharlotteDunois\Validation\Validator::make($options, array(
            'commandPrefix' => 'string|nullable',
            'commandBlockedMessagePattern' => 'boolean',
            'commandEditableDuration' => 'integer',
            'commandThrottlingMessagePattern' => 'boolean',
            'nonCommandEditable' => 'boolean',
            'unknownCommandResponse' => 'boolean',
            'owners' => 'array:string|array:integer',
            'invite' => 'string'
        ))->throw(\InvalidArgumentException::class);
    }
}


1			<?php
2			/**
3			* Livia
4			* Copyright 2017-2019 Charlotte Dunois, All Rights Reserved
5			*
6			* Website: https://charuru.moe
7			* License: https://github.com/CharlotteDunois/Livia/blob/master/LICENSE
8			*/
9
10			namespace CharlotteDunois\Livia;
11
12			/**
13			* The Livia Client, the heart of the framework.
14			*
15			* @property \CharlotteDunois\Livia\CommandDispatcher $dispatcher The client's command dispatcher.
16			* @property \CharlotteDunois\Livia\CommandRegistry $registry The client's command registry.
17			* @property \CharlotteDunois\Livia\Providers\SettingProvider\|null $provider The client's setting provider.
18			*
19			* @property string\|null $commandPrefix The global command prefix. ({@see Client::setCommandPrefix})
20			* @property \CharlotteDunois\Yasmin\Models\User[] $owners Owners of the bot, set by the client option owners. If you simply need to check if a user is an owner of the bot, please use Client::isOwner instead. ({@see \CharlotteDunois\Livia\Client:isOwner})
21			*/
22			class Client extends \CharlotteDunois\Yasmin\Client {
23			/**
24			* The client's command dispatcher.
25			* @var \CharlotteDunois\Livia\CommandDispatcher
26			*/
27			protected $dispatcher;
28
29			/**
30			* The client's command registry.
31			* @var \CharlotteDunois\Livia\CommandRegistry
32			*/
33			protected $registry;
34
35			/**
36			* The client's setting provider.
37			* @var \CharlotteDunois\Livia\Providers\SettingProvider\|null
38			*/
39			protected $provider;
40
41			/**
42			* Constructs a new Command Client. Additional available Client Options are as following:
43			*
44			* ```
45			* array(
46			* 'commandPrefix' => string\|null, (Default command prefix, null means only mentions will trigger the handling, defaults to l$)
47			* 'commandBlockedMessagePattern' => bool, (Whether command pattern matches will send command blocked messages, defaults to true)
48			* 'commandEditableDuration' => int, (Time in seconds that command messages should be editable, defaults to 30)
49			* 'commandThrottlingMessagePattern' => bool, (Whether command pattern matches will send command throttling messages, defaults to true)
50			* 'negativeResponseThrottlingDuration' => int, (Time in seconds how long negative responses should be not repeated during that time (determined by authorID-channelID-command), defaults to 15)
51			* 'nonCommandEditable' => bool, (Whether messages without commands can be edited to a command, defaults to true)
52			* 'unknownCommandResponse' => bool, (Whether the bot should respond to an unknown command, defaults to true)
53			* 'owners' => string[], (Array of user IDs)
54			* 'invite' => string, (Invite URL to the bot's support server)
55			* )
56			* ```
57			*
58			* @param array $options Any Client Options.
59			* @param \React\EventLoop\LoopInterface $loop
60			* @throws \Exception
61			* @throws \RuntimeException
62			* @throws \InvalidArgumentException
63			*/
64			function __construct(array $options = array(), ?\React\EventLoop\LoopInterface $loop = null) {
65			if(!\array_key_exists('commandPrefix', $options)) {
66			$options['commandPrefix'] = 'l$';
67			}
68
69			if(!isset($options['commandEditableDuration'])) {
70			$options['commandEditableDuration'] = 30;
71			}
72
73			if(!isset($options['negativeResponseThrottlingDuration'])) {
74			$options['negativeResponseThrottlingDuration'] = 15;
75			}
76
77			if(!isset($options['nonCommandEditable'])) {
78			$options['nonCommandEditable'] = true;
79			}
80
81			if(!isset($options['unknownCommandResponse'])) {
82			$options['unknownCommandResponse'] = true;
83			}
84
85			parent::__construct($options, $loop);
86
87			$this->dispatcher = new \CharlotteDunois\Livia\CommandDispatcher($this);
88			$this->registry = new \CharlotteDunois\Livia\CommandRegistry($this);
89
90			$msgError = function ($error) {
91			$this->emit('error', $error);
92			};
93
94			$this->on('message', function ($message) use ($msgError) {
95			$this->dispatcher->handleMessage($message)->done(null, $msgError);
96			});
97			$this->on('messageUpdate', function ($message, $oldMessage) use ($msgError) {
98			$this->dispatcher->handleMessage($message, $oldMessage)->done(null, $msgError);
99			});
100
101			if(!empty($options['owners'])) {
102			$this->once('ready', function () use ($options) {
103			if(!\is_array($options['owners'])) {
104			$options['owners'] = array($options['owners']);
105			}
106
107			foreach($options['owners'] as $owner) {
108			$this->fetchUser($owner)->done(null, function ($error) use ($owner) {
109			$this->emit('warn', 'Unable to fetch owner '.$owner);
110			$this->emit('error', $error);
111			});
112			}
113			});
114			}
115			}
116
117			/**
118			* @param string $name
119			* @return mixed
120			* @throws \Exception
121			* @internal
122			*/
123			function __get($name) {
124			switch($name) {
125			case 'dispatcher':
126			case 'registry':
127			case 'provider':
128			return $this->$name;
129			break;
130			case 'commandPrefix':
131			return $this->options['commandPrefix'];
132			break;
133			case 'owners':
134			$owners = array();
135			foreach($this->options['owners'] as $owner) {
136			$owners[$owner] = $this->users->get($owner);
137			}
138
139			return $owners;
140			break;
141			}
142
143			return parent::__get($name);
144			}
145
146			/**
147			* @return string
148			* @internal
149			*/
150			function serialize() {
151			$serializable = ($this->provider instanceof \Serializable);
152
153			if(!$serializable) {
154			$provider = $this->provider;
155			$this->provider = null;
156			}
157
158			$str = parent::serialize();
159
160			if(!$serializable) {
161			$this->provider = $provider;
162			}
163
164			return $str;
165			}
166
167			/**
168			* @return void
169			* @internal
170			*/
171			function unserialize($str) {
172			parent::unserialize($str);
173
174			foreach($this->registry->internalSerializedCommands as $command) {
175			$this->registry->registerCommand($command);
176			}
177
178			$this->registry->unsetInternalSerializedCommands();
179			}
180
181			/**
182			* Sets the global command prefix. Null indicates that there is no default prefix, and only mentions will be used. Emits a commandPrefixChange event.
183			* @param string\|null $prefix
184			* @param bool $fromProvider
185			* @return $this
186			* @throws \InvalidArgumentException
187			*/
188			function setCommandPrefix($prefix, bool $fromProvider = false) {
189			if(\is_string($prefix) && empty($prefix)) {
190			throw new \InvalidArgumentException('Can not set an empty string as command prefix');
191			}
192
193			$this->options['commandPrefix'] = $prefix;
194
195			if(!$fromProvider) {
196			$this->emit('commandPrefixChange', null, $prefix);
197			}
198
199			return $this;
200			}
201
202			/**
203			* Checks whether an user is an owner of the bot.
204			* @param string\|\CharlotteDunois\Yasmin\Models\User\|\CharlotteDunois\Yasmin\Models\GuildMember $user
205			* @return bool
206			*/
207			function isOwner($user) {
208			if($user instanceof \CharlotteDunois\Yasmin\Models\User \|\| $user instanceof \CharlotteDunois\Yasmin\Models\GuildMember) {
209			$user = $user->id;
210			}
211
212			return (\in_array($user, $this->options['owners']));
213			}
214
215			/**
216			* Sets the setting provider to use, and initializes it once the client is ready.
217			* @param \CharlotteDunois\Livia\Providers\SettingProvider $provider
218			* @return \React\Promise\ExtendedPromiseInterface
219			*/
220			function setProvider(\CharlotteDunois\Livia\Providers\SettingProvider $provider) {
221			$this->provider = $provider;
222
223			return (new \React\Promise\Promise(function (callable $resolve, callable $reject) {
224			$classname = \get_class($this->provider);
225
226			if($this->readyTimestamp !== null) {
227			$this->emit('debug', 'Provider set to '.$classname.' - initializing...');
228			$this->provider->init($this)->done($resolve, $reject);
229			return;
230			}
231
232			$this->emit('debug', 'Provider set to '.$classname.' - will initialize once ready');
233
234			$this->once('ready', function () use ($resolve, $reject) {
235			$this->emit('debug', 'Initializing provider...');
236			$this->provider->init($this)->done(function () use ($resolve) {
237			$this->emit('debug', 'Provider finished initialization.');
238			$resolve();
239			}, $reject);
240			});
241			}));
242			}
243
244			/**
245			* Get the guild's prefix - or the default prefix. Null means only mentions.
246			* @param \CharlotteDunois\Yasmin\Models\Guild\|null $guild
247			* @return string\|null
248			*/
249			function getGuildPrefix(?\CharlotteDunois\Yasmin\Models\Guild $guild = null) {
250			if($guild !== null && $this->provider !== null) {
251			try {
252			$prefix = $this->provider->get($guild, 'commandPrefix', 404);
253			if($prefix !== 404 && $prefix !== '') {
254			return $prefix;
255			}
256			} catch (\BadMethodCallException $e) {
257			return $this->commandPrefix;
258			}
259			}
260
261			return $this->commandPrefix;
262			}
263
264			/**
265			* Set the guild's prefix. An empty string means the command prefix will be used. Null means only mentions.
266			* @param \CharlotteDunois\Yasmin\Models\Guild\|null $guild
267			* @param string\|null $prefix
268			* @return bool
269			*/
270			function setGuildPrefix(?\CharlotteDunois\Yasmin\Models\Guild $guild, string $prefix = null) {
271			$this->emit('commandPrefixChange', $guild, $prefix);
272			return true;
273			}
274
275			/**
276			* Login into Discord. Opens a WebSocket Gateway connection. Resolves once a WebSocket connection has been successfully established (does not mean the client is ready).
277			* @param string $token Your token.
278			* @param bool $force Forces the client to get the gateway address from Discord.
279			* @return \React\Promise\ExtendedPromiseInterface
280			* @throws \RuntimeException
281			* @internal
282			*/
283			function login(string $token, bool $force = false) {
284			$this->addPeriodicTimer(300, array($this->dispatcher, 'cleanupNegativeResponseMessages'));
285
286			return parent::login($token, $force);
287			}
288
289			/**
290			* @return \React\Promise\ExtendedPromiseInterface
291			* @internal
292			*/
293			function destroy(bool $destroyUtils = true) {
294			return parent::destroy($destroyUtils)->then(function () {
295			if($this->provider !== null) {
296			return $this->provider->destroy();
297			}
298			});
299			}
300
301			/**
302			* Validates the passed client options.
303			* @param array $options
304			* @return void
305			* @throws \InvalidArgumentException
306			*/
307			protected function validateClientOptions(array $options) {
308			parent::validateClientOptions($options);
309
310			\CharlotteDunois\Validation\Validator::make($options, array(
311			'commandPrefix' => 'string\|nullable',
312			'commandBlockedMessagePattern' => 'boolean',
313			'commandEditableDuration' => 'integer',
314			'commandThrottlingMessagePattern' => 'boolean',
315			'nonCommandEditable' => 'boolean',
316			'unknownCommandResponse' => 'boolean',
317			'owners' => 'array:string\|array:integer',
318			'invite' => 'string'
319			))->throw(\InvalidArgumentException::class);
320			}
321			}
322

CharlotteDunois / Livia

Client::__construct() B last analyzed 2019-10-24 18:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Client::__construct() B
last analyzed 2019-10-24 18:53 UTC