Config::jsonSerialize() - Code Metrics - Inspection of "Next release (#34)" - krowinski/php-mysql-replication - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (80ac3a)

by kacper

created 2018-03-11 19:52 UTC

Config::jsonSerialize() A

↳ Parent: Config

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace MySQLReplication\Config;

/**
 * Class Config
 * @package MySQLReplication\Config
 */
class Config implements \JsonSerializable
{
    /**
     * @var string
     */
    private static $user;
    /**
     * @var string
     */
    private static $host;
    /**
     * @var int
     */
    private static $port;
    /**
     * @var string
     */
    private static $password;
    /**
     * @var string
     */
    private static $charset;
    /**
     * @var string
     */
    private static $gtid;
    /**
     * @var int
     */
    private static $slaveId;
    /**
     * @var string
     */
    private static $binLogFileName;
    /**
     * @var int
     */
    private static $binLogPosition;
    /**
     * @var array
     */
    private static $eventsOnly;
    /**
     * @var array
     */
    private static $eventsIgnore;
    /**
     * @var array
     */
    private static $tablesOnly;
    /**
     * @var array
     */
    private static $databasesOnly;
    /**
     * @var string
     */
    private static $mariaDbGtid;
    /**
     * @var int
     */
    private static $tableCacheSize;
    /**
     * @var array
     */
    private static $custom;
    /**
     * @var int
     */
    private static $heartbeatPeriod;

    /**
     * Config constructor.
     * @param string $user
     * @param string $host
     * @param int $port
     * @param string $password
     * @param string $charset
     * @param string $gtid
     * @param string $mariaGtid
     * @param int $slaveId
     * @param string $binLogFileName
     * @param $binLogPosition
     * @param array $eventsOnly
     * @param array $eventsIgnore
     * @param array $tablesOnly
     * @param array $databasesOnly
     * @param int $tableCacheSize
     * @param array $custom
     * @param int $heartbeatPeriod
     */
    public function __construct(
        $user,
        $host,
        $port,
        $password,
        $charset,
        $gtid,
        $mariaGtid,
        $slaveId,
        $binLogFileName,
        $binLogPosition,
        array $eventsOnly,
        array $eventsIgnore,
        array $tablesOnly,
        array $databasesOnly,
        $tableCacheSize,
        array $custom,
        $heartbeatPeriod
    ) {
        self::$user = $user;
        self::$host = $host;
        self::$port = $port;
        self::$password = $password;
        self::$charset = $charset;
        self::$gtid = $gtid;
        self::$slaveId = $slaveId;
        self::$binLogFileName = $binLogFileName;
        self::$binLogPosition = $binLogPosition;
        self::$eventsOnly = $eventsOnly;
        self::$eventsIgnore = $eventsIgnore;
        self::$tablesOnly = $tablesOnly;
        self::$databasesOnly = $databasesOnly;
        self::$mariaDbGtid = $mariaGtid;
        self::$tableCacheSize = $tableCacheSize;
        self::$custom = $custom;
        self::$heartbeatPeriod = $heartbeatPeriod;
    }

    /**
     * @throws ConfigException
     */
    public static function validate()
    {
        if (!empty(self::$user) && !is_string(self::$user)) {

            throw new ConfigException(ConfigException::USER_ERROR_MESSAGE, ConfigException::USER_ERROR_CODE);
        }
        if (!empty(self::$host)) {
            $ip = gethostbyname(self::$host);
            if (false === filter_var($ip, FILTER_VALIDATE_IP)) {
                throw new ConfigException(ConfigException::IP_ERROR_MESSAGE, ConfigException::IP_ERROR_CODE);
            }
        }
        if (!empty(self::$port) && false === filter_var(
                self::$port, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
            )
        ) {
            throw new ConfigException(ConfigException::PORT_ERROR_MESSAGE, ConfigException::PORT_ERROR_CODE);
        }
        if (!empty(self::$password) && !is_string(self::$password) && !is_numeric(self::$password)) {

            throw new ConfigException(ConfigException::PASSWORD_ERROR_MESSAGE, ConfigException::PASSWORD_ERROR_CODE);
        }
        if (!empty(self::$charset) && !is_string(self::$charset)) {

            throw new ConfigException(ConfigException::CHARSET_ERROR_MESSAGE, ConfigException::CHARSET_ERROR_CODE);
        }
        if (!empty(self::$gtid) && !is_string(self::$gtid)) {

            foreach (explode(',', self::$gtid) as $gtid) {
                if (!(bool)preg_match(
                    '/^([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})((?::[0-9-]+)+)$/', $gtid, $matches
                )
                ) {
                    throw new ConfigException(ConfigException::GTID_ERROR_MESSAGE, ConfigException::GTID_ERROR_CODE);
                }
            }
        }
        if (!empty(self::$slaveId) && false === filter_var(self::$slaveId, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])
        ) {
            throw new ConfigException(ConfigException::SLAVE_ID_ERROR_MESSAGE, ConfigException::SLAVE_ID_ERROR_CODE);
        }
        if (!empty(self::$binLogFileName) && !is_string(self::$binLogFileName)) {

            throw new ConfigException(
                ConfigException::BIN_LOG_FILE_NAME_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_NAME_ERROR_CODE
            );
        }
        if (false === filter_var(self::$binLogPosition, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
            throw new ConfigException(
                ConfigException::BIN_LOG_FILE_POSITION_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_POSITION_ERROR_CODE
            );
        }

        if (!empty(self::$mariaDbGtid) && !is_string(self::$mariaDbGtid)) {

            throw new ConfigException(
                ConfigException::MARIADBGTID_ERROR_MESSAGE, ConfigException::MARIADBGTID_ERROR_CODE
            );
        }
        if (false === filter_var(self::$tableCacheSize, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
            throw new ConfigException(
                ConfigException::TABLE_CACHE_SIZE_ERROR_MESSAGE, ConfigException::TABLE_CACHE_SIZE_ERROR_CODE
            );
        }
        if (0 !== self::$heartbeatPeriod && false === filter_var(
                self::$heartbeatPeriod, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 4294967]]
            )
        ) {
            throw new ConfigException(
                ConfigException::HEARTBEAT_PERIOD_ERROR_MESSAGE, ConfigException::HEARTBEAT_PERIOD_ERROR_CODE
            );
        }
    }

    /**
     * @return array
     */
    public static function getCustom()
    {
        return self::$custom;
    }

    /**
     * @return string
     */
    public static function getUser()
    {
        return self::$user;
    }

    /**
     * @return string
     */
    public static function getHost()
    {
        return self::$host;
    }

    /**
     * @return int
     */
    public static function getPort()
    {
        return self::$port;
    }

    /**
     * @return string
     */
    public static function getPassword()
    {
        return self::$password;
    }

    /**
     * @return string
     */
    public static function getCharset()
    {
        return self::$charset;
    }

    /**
     * @return string
     */
    public static function getGtid()
    {
        return self::$gtid;
    }

    /**
     * @return string
     */
    public static function getMariaDbGtid()
    {
        return self::$mariaDbGtid;
    }

    /**
     * @return int
     */
    public static function getSlaveId()
    {
        return self::$slaveId;
    }

    /**
     * @return string
     */
    public static function getBinLogFileName()
    {
        return self::$binLogFileName;
    }

    /**
     * @return int
     */
    public static function getBinLogPosition()
    {
        return self::$binLogPosition;
    }

    /**
     * @return array
     */
    public static function getEventsOnly()
    {
        return self::$eventsOnly;
    }

    /**
     * @return array
     */
    public static function getEventsIgnore()
    {
        return self::$eventsIgnore;
    }

    /**
     * @return array
     */
    public static function getTablesOnly()
    {
        return self::$tablesOnly;
    }

    /**
     * @return array
     */
    public static function getDatabasesOnly()
    {
        return self::$databasesOnly;
    }

    /**
     * @return int
     */
    public static function getTableCacheSize()
    {
        return self::$tableCacheSize;
    }

    /**
     * @param string $database
     * @return bool
     */
    public static function checkDataBasesOnly($database)
    {
        return [] !== Config::getDatabasesOnly() && !in_array($database, Config::getDatabasesOnly(), true);
    }

    /**
     * @param string $table
     * @return bool
     */
    public static function checkTablesOnly($table)
    {
        return [] !== Config::getTablesOnly() && !in_array($table, Config::getTablesOnly(), true);
    }

    /**
     * @param int $type
     * @return bool
     */
    public static function checkEvent($type)
    {
        if ([] !== Config::getEventsOnly() && !in_array($type, Config::getEventsOnly(), true)) {
            return false;
        }

        if (in_array($type, Config::getEventsIgnore(), true)) {
            return false;
        }

        return true;
    }

    /**
     * @return int
     */
    public static function getHeartbeatPeriod()
    {
        return self::$heartbeatPeriod;
    }

    /**
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return mixed data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     * @since 5.4.0
     */
    public function jsonSerialize()
    {
        return get_class_vars(self::class);
    }
}

1		<?php
2
3		namespace MySQLReplication\Config;
4
5		/**
6		* Class Config
7		* @package MySQLReplication\Config
8		*/
9		class Config implements \JsonSerializable
10		{
11		/**
12		* @var string
13		*/
14		private static $user;
15		/**
16		* @var string
17		*/
18		private static $host;
19		/**
20		* @var int
21		*/
22		private static $port;
23		/**
24		* @var string
25		*/
26		private static $password;
27		/**
28		* @var string
29		*/
30		private static $charset;
31		/**
32		* @var string
33		*/
34		private static $gtid;
35		/**
36		* @var int
37		*/
38		private static $slaveId;
39		/**
40		* @var string
41		*/
42		private static $binLogFileName;
43		/**
44		* @var int
45		*/
46		private static $binLogPosition;
47		/**
48		* @var array
49		*/
50		private static $eventsOnly;
51		/**
52		* @var array
53		*/
54		private static $eventsIgnore;
55		/**
56		* @var array
57		*/
58		private static $tablesOnly;
59		/**
60		* @var array
61		*/
62		private static $databasesOnly;
63		/**
64		* @var string
65		*/
66		private static $mariaDbGtid;
67		/**
68		* @var int
69		*/
70		private static $tableCacheSize;
71		/**
72		* @var array
73		*/
74		private static $custom;
75		/**
76		* @var int
77		*/
78		private static $heartbeatPeriod;
79
80		/**
81		* Config constructor.
82		* @param string $user
83		* @param string $host
84		* @param int $port
85		* @param string $password
86		* @param string $charset
87		* @param string $gtid
88		* @param string $mariaGtid
89		* @param int $slaveId
90		* @param string $binLogFileName
91		* @param $binLogPosition
92		* @param array $eventsOnly
93		* @param array $eventsIgnore
94		* @param array $tablesOnly
95		* @param array $databasesOnly
96		* @param int $tableCacheSize
97		* @param array $custom
98		* @param int $heartbeatPeriod
99		*/
100	74	public function __construct(
101		$user,
102		$host,
103		$port,
104		$password,
105		$charset,
106		$gtid,
107		$mariaGtid,
108		$slaveId,
109		$binLogFileName,
110		$binLogPosition,
111		array $eventsOnly,
112		array $eventsIgnore,
113		array $tablesOnly,
114		array $databasesOnly,
115		$tableCacheSize,
116		array $custom,
117		$heartbeatPeriod
118		) {
119	74	self::$user = $user;
120	74	self::$host = $host;
121	74	self::$port = $port;
122	74	self::$password = $password;
123	74	self::$charset = $charset;
124	74	self::$gtid = $gtid;
125	74	self::$slaveId = $slaveId;
126	74	self::$binLogFileName = $binLogFileName;
127	74	self::$binLogPosition = $binLogPosition;
128	74	self::$eventsOnly = $eventsOnly;
129	74	self::$eventsIgnore = $eventsIgnore;
130	74	self::$tablesOnly = $tablesOnly;
131	74	self::$databasesOnly = $databasesOnly;
132	74	self::$mariaDbGtid = $mariaGtid;
133	74	self::$tableCacheSize = $tableCacheSize;
134	74	self::$custom = $custom;
135	74	self::$heartbeatPeriod = $heartbeatPeriod;
136	74	}
137
138		/**
139		* @throws ConfigException
140		*/
141	69	public static function validate()
142		{
143	69	if (!empty(self::$user) && !is_string(self::$user)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::user)` is always `true`. Loading history...
144	1	throw new ConfigException(ConfigException::USER_ERROR_MESSAGE, ConfigException::USER_ERROR_CODE);
145		}
146	68	if (!empty(self::$host)) {
147	68	$ip = gethostbyname(self::$host);
148	68	if (false === filter_var($ip, FILTER_VALIDATE_IP)) {
149	1	throw new ConfigException(ConfigException::IP_ERROR_MESSAGE, ConfigException::IP_ERROR_CODE);
150		}
151	67	}
152	67	if (!empty(self::$port) && false === filter_var(
153	67	self::$port, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]]
154	67	)
155	67	) {
156	1	throw new ConfigException(ConfigException::PORT_ERROR_MESSAGE, ConfigException::PORT_ERROR_CODE);
157		}
158	66	if (!empty(self::$password) && !is_string(self::$password) && !is_numeric(self::$password)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::password)` is always `true`. Loading history...
159	1	throw new ConfigException(ConfigException::PASSWORD_ERROR_MESSAGE, ConfigException::PASSWORD_ERROR_CODE);
160		}
161	65	if (!empty(self::$charset) && !is_string(self::$charset)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::charset)` is always `true`. Loading history...
162	1	throw new ConfigException(ConfigException::CHARSET_ERROR_MESSAGE, ConfigException::CHARSET_ERROR_CODE);
163		}
164	64	if (!empty(self::$gtid) && !is_string(self::$gtid)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::gtid)` is always `true`. Loading history...
165	1	foreach (explode(',', self::$gtid) as $gtid) {
166	1	if (!(bool)preg_match(
167	1	'/^([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})((?::[0-9-]+)+)$/', $gtid, $matches
168	1	)
169	1	) {
170	1	throw new ConfigException(ConfigException::GTID_ERROR_MESSAGE, ConfigException::GTID_ERROR_CODE);
171		}
172		}
173		}
174	63	if (!empty(self::$slaveId) && false === filter_var(self::$slaveId, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])
175	63	) {
176	1	throw new ConfigException(ConfigException::SLAVE_ID_ERROR_MESSAGE, ConfigException::SLAVE_ID_ERROR_CODE);
177		}
178	62	if (!empty(self::$binLogFileName) && !is_string(self::$binLogFileName)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::binLogFileName)` is always `true`. Loading history...
179	1	throw new ConfigException(
180	1	ConfigException::BIN_LOG_FILE_NAME_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_NAME_ERROR_CODE
181	1	);
182		}
183	61	if (false === filter_var(self::$binLogPosition, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
184	1	throw new ConfigException(
185	1	ConfigException::BIN_LOG_FILE_POSITION_ERROR_MESSAGE, ConfigException::BIN_LOG_FILE_POSITION_ERROR_CODE
186	1	);
187		}
188
189	60	if (!empty(self::$mariaDbGtid) && !is_string(self::$mariaDbGtid)) {
		0 ignored issues – show introduced 2018-03-10 16:57 UTC by Report Bug Copy Issue Report The condition `is_string(self::mariaDbGtid)` is always `true`. Loading history...
190	1	throw new ConfigException(
191	1	ConfigException::MARIADBGTID_ERROR_MESSAGE, ConfigException::MARIADBGTID_ERROR_CODE
192	1	);
193		}
194	59	if (false === filter_var(self::$tableCacheSize, FILTER_VALIDATE_INT, ['options' => ['min_range' => 0]])) {
195	1	throw new ConfigException(
196	1	ConfigException::TABLE_CACHE_SIZE_ERROR_MESSAGE, ConfigException::TABLE_CACHE_SIZE_ERROR_CODE
197	1	);
198		}
199	58	if (0 !== self::$heartbeatPeriod && false === filter_var(
200	4	self::$heartbeatPeriod, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 4294967]]
201	4	)
202	58	) {
203	3	throw new ConfigException(
204	3	ConfigException::HEARTBEAT_PERIOD_ERROR_MESSAGE, ConfigException::HEARTBEAT_PERIOD_ERROR_CODE
205	3	);
206		}
207	55	}
208
209		/**
210		* @return array
211		*/
212	1	public static function getCustom()
213		{
214	1	return self::$custom;
215		}
216
217		/**
218		* @return string
219		*/
220	55	public static function getUser()
221		{
222	55	return self::$user;
223		}
224
225		/**
226		* @return string
227		*/
228	55	public static function getHost()
229		{
230	55	return self::$host;
231		}
232
233		/**
234		* @return int
235		*/
236	55	public static function getPort()
237		{
238	55	return self::$port;
239		}
240
241		/**
242		* @return string
243		*/
244	55	public static function getPassword()
245		{
246	55	return self::$password;
247		}
248
249		/**
250		* @return string
251		*/
252	55	public static function getCharset()
253		{
254	55	return self::$charset;
255		}
256
257		/**
258		* @return string
259		*/
260	55	public static function getGtid()
261		{
262	55	return self::$gtid;
263		}
264
265		/**
266		* @return string
267		*/
268	55	public static function getMariaDbGtid()
269		{
270	55	return self::$mariaDbGtid;
271		}
272
273		/**
274		* @return int
275		*/
276	55	public static function getSlaveId()
277		{
278	55	return self::$slaveId;
279		}
280
281		/**
282		* @return string
283		*/
284	55	public static function getBinLogFileName()
285		{
286	55	return self::$binLogFileName;
287		}
288
289		/**
290		* @return int
291		*/
292	55	public static function getBinLogPosition()
293		{
294	55	return self::$binLogPosition;
295		}
296
297		/**
298		* @return array
299		*/
300	56	public static function getEventsOnly()
301		{
302	56	return self::$eventsOnly;
303		}
304
305		/**
306		* @return array
307		*/
308	56	public static function getEventsIgnore()
309		{
310	56	return self::$eventsIgnore;
311		}
312
313		/**
314		* @return array
315		*/
316	54	public static function getTablesOnly()
317		{
318	54	return self::$tablesOnly;
319		}
320
321		/**
322		* @return array
323		*/
324	54	public static function getDatabasesOnly()
325		{
326	54	return self::$databasesOnly;
327		}
328
329		/**
330		* @return int
331		*/
332	62	public static function getTableCacheSize()
333		{
334	62	return self::$tableCacheSize;
335		}
336
337		/**
338		* @param string $database
339		* @return bool
340		*/
341	53	public static function checkDataBasesOnly($database)
342		{
343	53	return [] !== Config::getDatabasesOnly() && !in_array($database, Config::getDatabasesOnly(), true);
344		}
345
346		/**
347		* @param string $table
348		* @return bool
349		*/
350	53	public static function checkTablesOnly($table)
351		{
352	53	return [] !== Config::getTablesOnly() && !in_array($table, Config::getTablesOnly(), true);
353		}
354
355		/**
356		* @param int $type
357		* @return bool
358		*/
359	55	public static function checkEvent($type)
360		{
361	55	if ([] !== Config::getEventsOnly() && !in_array($type, Config::getEventsOnly(), true)) {
362	4	return false;
363		}
364
365	55	if (in_array($type, Config::getEventsIgnore(), true)) {
366	1	return false;
367		}
368
369	55	return true;
370		}
371
372		/**
373		* @return int
374		*/
375	55	public static function getHeartbeatPeriod()
376		{
377	55	return self::$heartbeatPeriod;
378		}
379
380		/**
381		* Specify data which should be serialized to JSON
382		* @link http://php.net/manual/en/jsonserializable.jsonserialize.php
383		* @return mixed data which can be serialized by <b>json_encode</b>,
384		* which is a value of any type other than a resource.
385		* @since 5.4.0
386		*/
387	1	public function jsonSerialize()
388		{
389	1	return get_class_vars(self::class);
390		}
391		}

krowinski / php-mysql-replication

Branch — master (80ac3a)

Config::jsonSerialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like