Manager - Code Metrics - Inspection of "Separate the connection library into its own packa..." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/jetpack-packages ( bae5a5...a37189 )

unknown

created 2019-06-03 16:49 UTC

Manager A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	280
Duplicated Lines	27.14 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
dl	76
loc	280
rs	9.0399
c	0
b	0
f	0
wmc	42
lcom	1
cbo	1

11 Methods

Rating	Name	Duplication	Size	Complexity
	get_option_names()	0	1	?
A	get_option()	7	19	5
A	get_grouped_option()	8	8	3
A	update_option()	8	29	5
A	update_grouped_option()	0	9	2
B	delete_option()	5	25	6
A	delete_grouped_option()	7	14	3
B	is_valid()	10	28	10
A	is_network_option()	0	6	2
A	get_raw_option()	17	17	4
A	bypass_raw_option()	14	14	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Manager often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Manager, and based on these observations, apply Extract Interface, too.

<?php
/**
 * The Jetpack Options manager class file.
 *
 * @package jetpack-options
 */

namespace Automattic\Jetpack\Options;

/**
 * The Jetpack Options Manager class that is used as a single gateway between WordPress options API
 * and Jetpack.
 */
abstract class Manager {

	/**
	 * An array that maps a grouped option type to an option name.
	 *
	 * @var array
	 */
	protected $grouped_options = array(
		'compact' => 'jetpack_options',
		'private' => 'jetpack_private_options',
	);

	/**
	 * Returns an array of option names for a given type.
	 *
	 * @param string $type The type of option to return. Defaults to 'compact'.
	 *
	 * @return array
	 */
	abstract public function get_option_names( $type );

	/**
	 * Returns the requested option.  Looks in jetpack_options or jetpack_$name as appropriate.
	 *
	 * @param string $name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
	 * @param mixed  $default (optional) the default value.
	 *
	 * @return mixed
	 */
	public function get_option( $name, $default = false ) {
		if ( $this->is_valid( $name, 'non_compact' ) ) {
			if ( $this->is_network_option( $name ) ) {
				return get_site_option( "jetpack_$name", $default );
			}

			return get_option( "jetpack_$name", $default );
		}

		foreach ( array_keys( $this->grouped_options ) as $group ) {
			if ( $this->is_valid( $name, $group ) ) {
				return $this->get_grouped_option( $group, $name, $default );
			}
		}

		// TODO: throw an exception here?

		return $default;
	}

	/**
	 * Returns a single value from a grouped option.
	 *
	 * @param String $group   name of the group, i.e., 'private'.
	 * @param String $name    the name of the option to return.
	 * @param Mixed  $default a default value in case the option is not found.
	 * @return Mixed the option value or default if not found.
	 */
	protected function get_grouped_option( $group, $name, $default ) {
		$options = get_option( $this->grouped_options[ $group ] );
		if ( is_array( $options ) && isset( $options[ $name ] ) ) {
			return $options[ $name ];
		}

		return $default;
	}

	/**
	 * Updates the single given option.  Updates jetpack_options or jetpack_$name as appropriate.
	 *
	 * @param string $name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
	 * @param mixed  $value Option value.
	 * @param string $autoload If not compact option, allows specifying whether to autoload or not.

	 *
	 * @return bool Was the option successfully updated?
	 */
	public function update_option( $name, $value, $autoload = null ) {
		/**
		 * Fires before Jetpack updates a specific option.
		 *
		 * @since 3.0.0
		 *
		 * @param str $name The name of the option being updated.
		 * @param mixed $value The new value of the option.
		 */
		do_action( 'pre_update_jetpack_option_' . $name, $name, $value );
		if ( $this->is_valid( $name, 'non_compact' ) ) {
			if ( $this->is_network_option( $name ) ) {
				return update_site_option( "jetpack_$name", $value );
			}

			return update_option( "jetpack_$name", $value, $autoload );

		}

		foreach ( array_keys( $this->grouped_options ) as $group ) {
			if ( $this->is_valid( $name, $group ) ) {
				return $this->update_grouped_option( $group, $name, $value );
			}
		}

		// TODO: throw an exception here?

		return false;
	}

	/**
	 * Updates a single value from a grouped option.
	 *
	 * @param String $group name of the group, i.e., 'private'.
	 * @param String $name  the name of the option to update.
	 * @param Mixed  $value the to update the option with.
	 * @return Boolean was the update successful?
	 */
	protected function update_grouped_option( $group, $name, $value ) {
		$options = get_option( $this->grouped_options[ $group ] );
		if ( ! is_array( $options ) ) {
			$options = array();
		}
		$options[ $name ] = $value;

		return update_option( $this->grouped_options[ $group ], $options );
	}

	/**
	 * Deletes the given option.  May be passed multiple option names as an array.
	 * Updates jetpack_options and/or deletes jetpack_$name as appropriate.
	 *
	 * @param string|array $names Option names. They must come _without_ `jetpack_%` prefix. The method will prefix the option names.
	 *
	 * @return bool Was the option successfully deleted?
	 */
	public function delete_option( $names ) {
		$result = true;
		$names  = (array) $names;

		if ( ! $this->is_valid( $names ) ) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			// TODO: issue a warning here?
			return false;
		}

		foreach ( array_intersect( $names, $this->get_option_names( 'non_compact' ) ) as $name ) {
			if ( $this->is_network_option( $name ) ) {
				$result = delete_site_option( "jetpack_$name" );
			} else {
				$result = delete_option( "jetpack_$name" );
			}
		}

		foreach ( array_keys( $this->grouped_options ) as $group ) {
			if ( ! $this->delete_grouped_option( $group, $names ) ) {
				$result = false;
			}
		}

		return $result;
	}

	/**
	 * Deletes a single value from a grouped option.
	 *
	 * @param String $group   name of the group, i.e., 'private'.
	 * @param Array  $names   the names of the option to delete.
	 * @return Mixed the option value or default if not found.
	 */
	protected function delete_grouped_option( $group, $names ) {
		$options = get_option( $this->grouped_options[ $group ], array() );

		$to_delete = array_intersect( $names, $this->get_option_names( $group ), array_keys( $options ) );
		if ( $to_delete ) {

			foreach ( $to_delete as $name ) {
				unset( $options[ $name ] );
			}

			return update_option( $this->grouped_options[ $group ], $options );
		}

		return true;
	}

	/**
	 * Is the option name valid?
	 *
	 * @param string      $name  The name of the option.
	 * @param string|null $group The name of the group that the option is in. Default to null, which will search non_compact.
	 *
	 * @return bool Is the option name valid?
	 */
	public function is_valid( $name, $group = null ) {
		if ( is_array( $name ) ) {
			$compact_names = array();
			foreach ( array_keys( $this->grouped_options ) as $_group ) {
				$compact_names = array_merge( $compact_names, $this->get_option_names( $_group ) );
			}

			$result = array_diff( $name, $this->get_option_names( 'non_compact' ), $compact_names );

			return empty( $result );
		}

		if ( is_null( $group ) || 'non_compact' === $group ) {
			if ( in_array( $name, $this->get_option_names( $group ), true ) ) {
				return true;
			}
		}

		foreach ( array_keys( $this->grouped_options ) as $_group ) {
			if ( is_null( $group ) || $group === $_group ) {
				if ( in_array( $name, $this->get_option_names( $_group ), true ) ) {
					return true;
				}
			}
		}

		return false;
	}

	/**
	 * Checks if an option must be saved for the whole network in WP Multisite
	 *
	 * @param string $option_name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
	 *
	 * @return bool
	 */
	public function is_network_option( $option_name ) {
		if ( ! is_multisite() ) {
			return false;
		}
		return in_array( $option_name, $this->get_option_names( 'network' ), true );
	}

	/**
	 * Gets an option via $wpdb query.
	 *
	 * @since 5.4.0
	 *
	 * @param string $name Option name.
	 * @param mixed  $default Default option value if option is not found.
	 *
	 * @return mixed Option value, or null if option is not found and default is not specified.
	 */
	function get_raw_option( $name, $default = null ) {
		if ( $this->bypass_raw_option( $name ) ) {
			return get_option( $name, $default );
		}
		global $wpdb;
		$value = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1",
				$name
			)
		);
		$value = maybe_unserialize( $value );
		if ( $value === null && $default !== null ) {
			return $default;
		}
		return $value;
	}
	/**
	 * This function checks for a constant that, if present, will disable direct DB queries Jetpack uses to manage certain options and force Jetpack to always use Options API instead.
	 * Options can be selectively managed via a blacklist by filtering option names via the jetpack_disabled_raw_option filter.
	 *
	 * @param $name Option name
	 *
	 * @return bool
	 */
	function bypass_raw_option( $name ) {
		if ( \Jetpack_Constants::get_constant( 'JETPACK_DISABLE_RAW_OPTIONS' ) ) {
			return true;
		}
		/**
		 * Allows to disable particular raw options.
		 *
		 * @since 5.5.0
		 *
		 * @param array $disabled_raw_options An array of option names that you can selectively blacklist from being managed via direct database queries.
		 */
		$disabled_raw_options = apply_filters( 'jetpack_disabled_raw_options', array() );
		return isset( $disabled_raw_options[ $name ] );
	}
}


1		<?php
2		/**
3		* The Jetpack Options manager class file.
4		*
5		* @package jetpack-options
6		*/
7
8		namespace Automattic\Jetpack\Options;
9
10		/**
11		* The Jetpack Options Manager class that is used as a single gateway between WordPress options API
12		* and Jetpack.
13		*/
14		abstract class Manager {
15
16		/**
17		* An array that maps a grouped option type to an option name.
18		*
19		* @var array
20		*/
21		protected $grouped_options = array(
22		'compact' => 'jetpack_options',
23		'private' => 'jetpack_private_options',
24		);
25
26		/**
27		* Returns an array of option names for a given type.
28		*
29		* @param string $type The type of option to return. Defaults to 'compact'.
30		*
31		* @return array
32		*/
33		abstract public function get_option_names( $type );
34
35		/**
36		* Returns the requested option. Looks in jetpack_options or jetpack_$name as appropriate.
37		*
38		* @param string $name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
39		* @param mixed $default (optional) the default value.
40		*
41		* @return mixed
42		*/
43		public function get_option( $name, $default = false ) {
44	View Code Duplication	if ( $this->is_valid( $name, 'non_compact' ) ) {
45		if ( $this->is_network_option( $name ) ) {
46		return get_site_option( "jetpack_$name", $default );
47		}
48
49		return get_option( "jetpack_$name", $default );
50		}
51
52		foreach ( array_keys( $this->grouped_options ) as $group ) {
53		if ( $this->is_valid( $name, $group ) ) {
54		return $this->get_grouped_option( $group, $name, $default );
55		}
56		}
57
58		// TODO: throw an exception here?
59
60		return $default;
61		}
62
63		/**
64		* Returns a single value from a grouped option.
65		*
66		* @param String $group name of the group, i.e., 'private'.
67		* @param String $name the name of the option to return.
68		* @param Mixed $default a default value in case the option is not found.
69		* @return Mixed the option value or default if not found.
70		*/
71	View Code Duplication	protected function get_grouped_option( $group, $name, $default ) {
72		$options = get_option( $this->grouped_options[ $group ] );
73		if ( is_array( $options ) && isset( $options[ $name ] ) ) {
74		return $options[ $name ];
75		}
76
77		return $default;
78		}
79
80		/**
81		* Updates the single given option. Updates jetpack_options or jetpack_$name as appropriate.
82		*
83		* @param string $name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
84		* @param mixed $value Option value.
85		* @param string $autoload If not compact option, allows specifying whether to autoload or not.
		0 ignored issues – show Documentation introduced 2019-05-22 20:28 UTC by Report Bug Copy Issue Report Should the type for parameter `$autoload` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
86		*
87		* @return bool Was the option successfully updated?
88		*/
89		public function update_option( $name, $value, $autoload = null ) {
90		/**
91		* Fires before Jetpack updates a specific option.
92		*
93		* @since 3.0.0
94		*
95		* @param str $name The name of the option being updated.
96		* @param mixed $value The new value of the option.
97		*/
98		do_action( 'pre_update_jetpack_option_' . $name, $name, $value );
99	View Code Duplication	if ( $this->is_valid( $name, 'non_compact' ) ) {
100		if ( $this->is_network_option( $name ) ) {
101		return update_site_option( "jetpack_$name", $value );
102		}
103
104		return update_option( "jetpack_$name", $value, $autoload );
105
106		}
107
108		foreach ( array_keys( $this->grouped_options ) as $group ) {
109		if ( $this->is_valid( $name, $group ) ) {
110		return $this->update_grouped_option( $group, $name, $value );
111		}
112		}
113
114		// TODO: throw an exception here?
115
116		return false;
117		}
118
119		/**
120		* Updates a single value from a grouped option.
121		*
122		* @param String $group name of the group, i.e., 'private'.
123		* @param String $name the name of the option to update.
124		* @param Mixed $value the to update the option with.
125		* @return Boolean was the update successful?
126		*/
127		protected function update_grouped_option( $group, $name, $value ) {
128		$options = get_option( $this->grouped_options[ $group ] );
129		if ( ! is_array( $options ) ) {
130		$options = array();
131		}
132		$options[ $name ] = $value;
133
134		return update_option( $this->grouped_options[ $group ], $options );
135		}
136
137		/**
138		* Deletes the given option. May be passed multiple option names as an array.
139		* Updates jetpack_options and/or deletes jetpack_$name as appropriate.
140		*
141		* @param string\|array $names Option names. They must come _without_ `jetpack_%` prefix. The method will prefix the option names.
142		*
143		* @return bool Was the option successfully deleted?
144		*/
145		public function delete_option( $names ) {
146		$result = true;
147		$names = (array) $names;
148
149		if ( ! $this->is_valid( $names ) ) {
		0 ignored issues – show Documentation introduced 2019-05-24 12:08 UTC by Report Bug Copy Issue Report `$names` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
150		// TODO: issue a warning here?
151		return false;
152		}
153
154		foreach ( array_intersect( $names, $this->get_option_names( 'non_compact' ) ) as $name ) {
155	View Code Duplication	if ( $this->is_network_option( $name ) ) {
156		$result = delete_site_option( "jetpack_$name" );
157		} else {
158		$result = delete_option( "jetpack_$name" );
159		}
160		}
161
162		foreach ( array_keys( $this->grouped_options ) as $group ) {
163		if ( ! $this->delete_grouped_option( $group, $names ) ) {
164		$result = false;
165		}
166		}
167
168		return $result;
169		}
170
171		/**
172		* Deletes a single value from a grouped option.
173		*
174		* @param String $group name of the group, i.e., 'private'.
175		* @param Array $names the names of the option to delete.
176		* @return Mixed the option value or default if not found.
177		*/
178		protected function delete_grouped_option( $group, $names ) {
179		$options = get_option( $this->grouped_options[ $group ], array() );
180
181		$to_delete = array_intersect( $names, $this->get_option_names( $group ), array_keys( $options ) );
182	View Code Duplication	if ( $to_delete ) {
		0 ignored issues – show Bug Best Practice introduced 2019-05-21 21:31 UTC by Report Bug Copy Issue Report The expression `$to_delete` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
183		foreach ( $to_delete as $name ) {
184		unset( $options[ $name ] );
185		}
186
187		return update_option( $this->grouped_options[ $group ], $options );
188		}
189
190		return true;
191		}
192
193		/**
194		* Is the option name valid?
195		*
196		* @param string $name The name of the option.
197		* @param string\|null $group The name of the group that the option is in. Default to null, which will search non_compact.
198		*
199		* @return bool Is the option name valid?
200		*/
201		public function is_valid( $name, $group = null ) {
202		if ( is_array( $name ) ) {
203		$compact_names = array();
204		foreach ( array_keys( $this->grouped_options ) as $_group ) {
205		$compact_names = array_merge( $compact_names, $this->get_option_names( $_group ) );
206		}
207
208		$result = array_diff( $name, $this->get_option_names( 'non_compact' ), $compact_names );
209
210		return empty( $result );
211		}
212
213	View Code Duplication	if ( is_null( $group ) \|\| 'non_compact' === $group ) {
214		if ( in_array( $name, $this->get_option_names( $group ), true ) ) {
215		return true;
216		}
217		}
218
219		foreach ( array_keys( $this->grouped_options ) as $_group ) {
220	View Code Duplication	if ( is_null( $group ) \|\| $group === $_group ) {
221		if ( in_array( $name, $this->get_option_names( $_group ), true ) ) {
222		return true;
223		}
224		}
225		}
226
227		return false;
228		}
229
230		/**
231		* Checks if an option must be saved for the whole network in WP Multisite
232		*
233		* @param string $option_name Option name. It must come _without_ `jetpack_%` prefix. The method will prefix the option name.
234		*
235		* @return bool
236		*/
237		public function is_network_option( $option_name ) {
238		if ( ! is_multisite() ) {
239		return false;
240		}
241		return in_array( $option_name, $this->get_option_names( 'network' ), true );
242		}
243
244		/**
245		* Gets an option via $wpdb query.
246		*
247		* @since 5.4.0
248		*
249		* @param string $name Option name.
250		* @param mixed $default Default option value if option is not found.
251		*
252		* @return mixed Option value, or null if option is not found and default is not specified.
253		*/
254	View Code Duplication	function get_raw_option( $name, $default = null ) {
255		if ( $this->bypass_raw_option( $name ) ) {
256		return get_option( $name, $default );
257		}
258		global $wpdb;
259		$value = $wpdb->get_var(
260		$wpdb->prepare(
261		"SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1",
262		$name
263		)
264		);
265		$value = maybe_unserialize( $value );
266		if ( $value === null && $default !== null ) {
267		return $default;
268		}
269		return $value;
270		}
271		/**
272		* This function checks for a constant that, if present, will disable direct DB queries Jetpack uses to manage certain options and force Jetpack to always use Options API instead.
273		* Options can be selectively managed via a blacklist by filtering option names via the jetpack_disabled_raw_option filter.
274		*
275		* @param $name Option name
276		*
277		* @return bool
278		*/
279	View Code Duplication	function bypass_raw_option( $name ) {
280		if ( \Jetpack_Constants::get_constant( 'JETPACK_DISABLE_RAW_OPTIONS' ) ) {
281		return true;
282		}
283		/**
284		* Allows to disable particular raw options.
285		*
286		* @since 5.5.0
287		*
288		* @param array $disabled_raw_options An array of option names that you can selectively blacklist from being managed via direct database queries.
289		*/
290		$disabled_raw_options = apply_filters( 'jetpack_disabled_raw_options', array() );
291		return isset( $disabled_raw_options[ $name ] );
292		}
293		}
294

Automattic / jetpack