memcache_cache::cacheSettings() - Code Metrics - Inspection of "Merge pull request #4306 from jdarwood007/cache_ap..." - albertlast/SMF2.1 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — release-2.1 ( 4bdd41...11eb43 )

by Mathias

created 2017-10-15 06:17 UTC

memcache_cache::cacheSettings() A

↳ Parent: memcache_cache

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	7

Duplication

Lines	16
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	16
loc	16
rs	9.4285
c	0
b	0
f	0

<?php

/**
 * Simple Machines Forum (SMF)
 *
 * @package SMF
 * @author Simple Machines http://www.simplemachines.org
 * @copyright 2017 Simple Machines and individual contributors
 * @license http://www.simplemachines.org/about/smf/license.php BSD
 *
 * @version 2.1 Beta 4
 */

if (!defined('SMF'))
	die('Hacking attempt...');

/**
 * Our Cache API class
 * @package cacheAPI
 */
class memcache_cache extends cache_api
{
	/**
	 * @var \Memcache The memcache instance.
	 */
	private $memcache = null;

	/**
	 * {@inheritDoc}
	 */
	public function isSupported($test = false)

	{
		global $cache_memcached;
function myFunction($a, $b) {
    // Do something
}

		$supported = class_exists('memcache');

		if ($test)
			return $supported;
		return parent::isSupported() && $supported && !empty($cache_memcached);
	}

	/**
	 * {@inheritDoc}
	 */
	public function connect()
	{
		global $db_persist, $cache_memcached;
function myFunction($a, $b) {
    // Do something
}

		$servers = explode(',', $cache_memcached);
		$port = 0;

		// Don't try more times than we have servers!
		$connected = false;
		$level = 0;

		// We should keep trying if a server times out, but only for the amount of servers we have.
		while (!$connected && $level < count($servers))
		{
			++$level;
			$this->memcache = new Memcache();
			$server = trim($servers[array_rand($servers)]);

			// Normal host names do not contain slashes, while e.g. unix sockets do. Assume alternative transport pipe with port 0.
			if (strpos($server,'/') !== false)
				$host = $server;
			else
			{
				$server = explode(':', $server);
				$host = $server[0];
				$port = isset($server[1]) ? $server[1] : 11211;
			}

			// Don't wait too long: yes, we want the server, but we might be able to run the query faster!
			if (empty($db_persist))
				$connected = $this->memcache->connect($host, $port);
			else
				$connected = $this->memcache->pconnect($host, $port);
		}

		return $connected;
	}

	/**
	 * {@inheritDoc}
	 */
	public function getData($key, $ttl = null)

	{
		$key = $this->prefix . strtr($key, ':/', '-_');

		$value = $this->memcache->get($key);

		// $value should return either data or false (from failure, key not found or empty array).
		if ($value === false)
			return null;
		return $value;
	}

	/**
	 * {@inheritDoc}
	 */
	public function putData($key, $value, $ttl = null)
	{
		$key = $this->prefix . strtr($key, ':/', '-_');

		return $this->memcache->set($key, $value, 0, $ttl);
	}

	/**
	 * {@inheritDoc}
	 */
	public function quit()
	{
		return $this->memcache->close();
	}

	/**
	 * {@inheritDoc}
	 */
	public function cleanCache($type = '')
	{
		$this->invalidateCache();
		return $this->memcache->flush();
	}

	/**
	 * {@inheritDoc}
	 */
	public function cacheSettings(array &$config_vars)

	{
		global $context, $txt;
function myFunction($a, $b) {
    // Do something
}

		$config_vars[] = $txt['cache_memcache_settings'];
		$config_vars[] = array('cache_memcached', $txt['cache_memcache_servers'], 'file', 'text', 0, 'cache_memcached', 'postinput' => '<br><div class="smalltext"><em>' . $txt['cache_memcache_servers_subtext'] . '</em></div>');

		if (!isset($context['settings_post_javascript']))
			$context['settings_post_javascript'] = '';

		$context['settings_post_javascript'] .= '
			$("#cache_accelerator").change(function (e) {
				var cache_type = e.currentTarget.value;
				$("#cache_memcached").prop("disabled", cache_type != "memcache");
			});';
	}

	/**
	 * {@inheritDoc}
	 */
	public function getVersion()
	{
		return $this->memcache->getVersion();
	}
}

?>

1		<?php
2
3		/**
4		* Simple Machines Forum (SMF)
5		*
6		* @package SMF
7		* @author Simple Machines http://www.simplemachines.org
8		* @copyright 2017 Simple Machines and individual contributors
9		* @license http://www.simplemachines.org/about/smf/license.php BSD
10		*
11		* @version 2.1 Beta 4
12		*/
13
14		if (!defined('SMF'))
15		die('Hacking attempt...');
16
17		/**
18		* Our Cache API class
19		* @package cacheAPI
20		*/
21		class memcache_cache extends cache_api
22		{
23		/**
24		* @var \Memcache The memcache instance.
25		*/
26		private $memcache = null;
27
28		/**
29		* {@inheritDoc}
30		*/
31	View Code Duplication	public function isSupported($test = false)
		0 ignored issues – show Duplication introduced 2017-07-31 17:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
32		{
33		global $cache_memcached;
		0 ignored issues – show Compatibility Best Practice introduced 2017-08-25 21:51 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
34
35		$supported = class_exists('memcache');
36
37		if ($test)
38		return $supported;
39		return parent::isSupported() && $supported && !empty($cache_memcached);
40		}
41
42		/**
43		* {@inheritDoc}
44		*/
45		public function connect()
46		{
47		global $db_persist, $cache_memcached;
		0 ignored issues – show Compatibility Best Practice introduced 2017-08-25 21:51 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
48
49		$servers = explode(',', $cache_memcached);
50		$port = 0;
51
52		// Don't try more times than we have servers!
53		$connected = false;
54		$level = 0;
55
56		// We should keep trying if a server times out, but only for the amount of servers we have.
57		while (!$connected && $level < count($servers))
58		{
59		++$level;
60		$this->memcache = new Memcache();
61		$server = trim($servers[array_rand($servers)]);
62
63		// Normal host names do not contain slashes, while e.g. unix sockets do. Assume alternative transport pipe with port 0.
64		if (strpos($server,'/') !== false)
65		$host = $server;
66	View Code Duplication	else
67		{
68		$server = explode(':', $server);
69		$host = $server[0];
70		$port = isset($server[1]) ? $server[1] : 11211;
71		}
72
73		// Don't wait too long: yes, we want the server, but we might be able to run the query faster!
74		if (empty($db_persist))
75		$connected = $this->memcache->connect($host, $port);
76		else
77		$connected = $this->memcache->pconnect($host, $port);
78		}
79
80		return $connected;
81		}
82
83		/**
84		* {@inheritDoc}
85		*/
86	View Code Duplication	public function getData($key, $ttl = null)
		0 ignored issues – show Duplication introduced 2017-07-31 17:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
87		{
88		$key = $this->prefix . strtr($key, ':/', '-_');
89
90		$value = $this->memcache->get($key);
91
92		// $value should return either data or false (from failure, key not found or empty array).
93		if ($value === false)
94		return null;
95		return $value;
96		}
97
98		/**
99		* {@inheritDoc}
100		*/
101		public function putData($key, $value, $ttl = null)
102		{
103		$key = $this->prefix . strtr($key, ':/', '-_');
104
105		return $this->memcache->set($key, $value, 0, $ttl);
106		}
107
108		/**
109		* {@inheritDoc}
110		*/
111		public function quit()
112		{
113		return $this->memcache->close();
114		}
115
116		/**
117		* {@inheritDoc}
118		*/
119		public function cleanCache($type = '')
120		{
121		$this->invalidateCache();
122		return $this->memcache->flush();
123		}
124
125		/**
126		* {@inheritDoc}
127		*/
128	View Code Duplication	public function cacheSettings(array &$config_vars)
		0 ignored issues – show Duplication introduced 2017-07-31 17:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
129		{
130		global $context, $txt;
		0 ignored issues – show Compatibility Best Practice introduced 2017-08-25 21:51 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
131
132		$config_vars[] = $txt['cache_memcache_settings'];
133		$config_vars[] = array('cache_memcached', $txt['cache_memcache_servers'], 'file', 'text', 0, 'cache_memcached', 'postinput' => '<br><div class="smalltext"><em>' . $txt['cache_memcache_servers_subtext'] . '</em></div>');
134
135		if (!isset($context['settings_post_javascript']))
136		$context['settings_post_javascript'] = '';
137
138		$context['settings_post_javascript'] .= '
139		$("#cache_accelerator").change(function (e) {
140		var cache_type = e.currentTarget.value;
141		$("#cache_memcached").prop("disabled", cache_type != "memcache");
142		});';
143		}
144
145		/**
146		* {@inheritDoc}
147		*/
148		public function getVersion()
149		{
150		return $this->memcache->getVersion();
151		}
152		}
153
154		?>

albertlast / SMF2.1

Push — release-2.1 ( 4bdd41...11eb43 )

memcache_cache::cacheSettings() A

Complexity

Size

Duplication

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like