Carbon_Fields::is_booted() - Code Metrics - Inspection of "move url resolving to a generic static method" - htmlburger/carbon-fields - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — milestone/2_0/react-ui ( 6ff089...f420b0 )

unknown

created 2017-05-17 09:35 UTC

Carbon_Fields::is_booted() A

↳ Parent: Carbon_Fields

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Carbon_Fields;

use Carbon_Fields\Pimple\Container as PimpleContainer;
use Carbon_Fields\Helper\Helper;
use Carbon_Fields\Loader\Loader;
use Carbon_Fields\Container\Repository as ContainerRepository;
use Carbon_Fields\Toolset\Key_Toolset;
use Carbon_Fields\Toolset\WP_Toolset;
use Carbon_Fields\Service\Meta_Query_Service;
use Carbon_Fields\Service\Legacy_Storage_Service_v_1_5;
use Carbon_Fields\Service\REST_API_Service;
use Carbon_Fields\Libraries\Sidebar_Manager\Sidebar_Manager;

use Carbon_Fields\REST_API\Router as REST_API_Router;
use Carbon_Fields\REST_API\Decorator as REST_API_Decorator;

use Carbon_Fields\Event\Emitter;
use Carbon_Fields\Event\PersistentListener;
use Carbon_Fields\Event\SingleEventListener;

use Carbon_Fields\Exception\Incorrect_Syntax_Exception;

/**
 * Holds a static reference to the ioc container
 */
final class Carbon_Fields {

	/**
	 * An event emitter to facilitate events before the WordPress environment is guaranteed to be loaded
	 * 
	 * @var Emitter
	 */
	protected $emitter;

	/**
	 * Flag if Carbon Fields has been booted
	 * 
	 * @var bool
	 */
	public $booted = false;

	/**
	 * Inversion of Control container instance
	 * 
	 * @var PimpleContainer
	 */
	public $ioc = null;

	/**
	 * Singleton implementation
	 *
	 * @return Carbon_Fields\Carbon_Fields
	 */
	public static function instance() {
		static $instance = null;
		if ( $instance === null ) {
			$instance = new static();
		}
		return $instance;
	}

	/**
	 * Constructor
	 */
	private function __construct() {
		$this->install( $this->get_default_ioc() );
	}

	/**
	 * Resolve a dependency through IoC
	 *
	 * @param  string      $key
	 * @param  string|null $subcontainer Subcontainer to look into
	 * @return mixed
	 */
	public static function resolve( $key, $subcontainer = null ) {
		$ioc = static::instance()->ioc;
		if ( $subcontainer !== null ) {
			if ( ! isset( $ioc[ $subcontainer ] ) ) {
				return null;
			}
			$ioc = $ioc[ $subcontainer ];
		}
		return $ioc[ $key ];
	}

	/**
	 * Resolve a dependency through IoC with arguments
	 *
	 * @param  string $identifier   Key to resolve from the container
	 * @param  array  $arguments    Key-value array of arguments
	 * @param  string $subcontainer The container to resolve from
	 * @return mixed
	 */
	public static function resolve_with_arguments( $identifier, $arguments, $subcontainer = null ) {
		$supercontainer = $subcontainer ? static::resolve( $subcontainer ) : static::instance()->ioc;
		$container = new PimpleContainer();
		$container['container'] = $supercontainer;
		$container['arguments'] = $arguments;
		$container['object'] = $supercontainer->raw( $identifier );
		return $container['object'];
	}

	/**
	 * Resolve a service through IoC
	 *
	 * @param string $service_name
	 * @return mixed
	 */
	public static function service( $service_name ) {
		return static::resolve( $service_name, 'services' );
	}

	/**
	 * Check if a dependency is registered
	 *
	 * @param  string      $key
	 * @param  string|null $subcontainer Subcontainer to look into
	 * @return bool
	 */
	public static function has( $key, $subcontainer = null ) {
		$ioc = static::instance()->ioc;
		if ( $subcontainer !== null ) {
			if ( ! isset( $ioc[ $subcontainer ] ) ) {
				return false;
			}
			$ioc = $ioc[ $subcontainer ];
		}
		return isset( $ioc[ $key ] );
	}

	/**
	 * Extend Carbon Fields by adding a new entity (container condition etc.)
	 *
	 * @param string $class    Extension class name
	 * @param string $extender Extending callable
	 */
	public static function extend( $class, $extender ) {
		$type_dictionary = array(
			'_Field' => 'fields',
			'_Condition' => 'container_conditions',
		);

		$extension_suffix = '';
		$extension_subcontainer = '';
		foreach ( $type_dictionary as $suffix => $subcontainer ) {
			if ( substr( $class, -strlen( $suffix ) ) === $suffix ) {
				$extension_suffix = $suffix;
				$extension_subcontainer = $subcontainer;
			}
		}

		if ( empty( $extension_suffix ) ) {
			Incorrect_Syntax_Exception::raise( 'Could not determine "' . $class . '" extension type. Extension classes must have one of the following suffixes: ' . implode( ', ', array_keys( $type_dictionary ) ) );
			return;
		}

		$identifier = Helper::class_to_type( $class, $extension_suffix );
		$ioc = static::instance()->ioc[ $extension_subcontainer ];
		$ioc[ $identifier ] = $ioc->factory( $extender );
	}

	/**
	 * Replace the ioc container for Carbon_Fields\Carbon_Fields
	 * 
	 * @param  PimpleContainer $ioc
	 */
	public function install( PimpleContainer $ioc ) {
		$this->ioc = $ioc;
	}

	/**
	 * Boot Carbon Fields with default IoC dependencies
	 */
	public static function boot() {
		if ( static::is_booted() ) {
			return;
		}

		if ( defined( __NAMESPACE__ . '\VERSION' ) ) {
			return; // Possibly attempting to load multiple versions of Carbon Fields; bail in favor of already loaded version
		}

		static::resolve( 'loader' )->boot();
		static::instance()->booted = true;
		static::instance()->get_emitter()->emit( 'loaded' );
		do_action( 'carbon_fields_loaded' );
	}

	/**
	 * Check if Carbon Fields has booted
	 */
	public static function is_booted() {
		return static::instance()->booted;
	}

	/**
	 * Throw exception if Carbon Fields has not been booted
	 */
	public static function verify_boot() {
		if ( ! static::is_booted() ) {
			throw new \Exception( 'You must call Carbon_Fields\Carbon_Fields::boot() in a suitable WordPress hook before using Carbon Fields.' );
		}
	}

	/**
	 * Resolve the public url of a directory inside WordPress
	 * 
	 * @param  string $directory
	 * @return string
	 */
	public static function directory_to_url( $directory ) {
		$url = \trailingslashit( $directory );
		$count = 0;

		# Sanitize directory separator on Windows
		$url = str_replace( '\\' ,'/', $url );

		$possible_locations = array(
			WP_PLUGIN_DIR => \plugins_url(), # If installed as a plugin
			WP_CONTENT_DIR => \content_url(), # If anywhere in wp-content
			ABSPATH => \site_url( '/' ), # If anywhere else within the WordPress installation
		);

		foreach ( $possible_locations as $test_dir => $test_url ) {
			$test_dir_normalized = str_replace( '\\' ,'/', $test_dir );
			$url = str_replace( $test_dir_normalized, $test_url, $url, $count );

			if ( $count > 0 ) {
				break;
			}
		}

		return \untrailingslashit( $url );
	}

	/**
	 * Get the event emitter
	 * 
	 * @return Emitter
	 */
	public function get_emitter() {
		if ( $this->emitter === null ) {
			$this->emitter = static::resolve( 'event_emitter' );
		}
		return $this->emitter;
	}

	/**
	 * Add a listener to an event
	 * 
	 * @param string   $event
	 * @return Listener $listener
	 */
	public static function add_listener( $event, $listener ) {
		return static::instance()->get_emitter()->add_listener( $event, $listener );
	}

	/**
	 * Remove a listener from any event
	 * 
	 * @param Listener $listener
	 */
	public static function remove_listener( $listener ) {
		static::instance()->get_emitter()->remove_listener( $listener );
	}

	/**
	 * Add a persistent listener to an event
	 * 
	 * @param  string   $event    The event to listen for
	 * @param  string   $callable The callable to call when the event is broadcasted
	 * @return Listener
	 */
	public static function on( $event, $callable ) {
		return static::instance()->get_emitter()->on( $event, $callable );
	}

	/**
	 * Add a one-time listener to an event
	 *
	 * @param  string   $event    The event to listen for
	 * @param  string   $callable The callable to call when the event is broadcasted
	 * @return Listener
	 */
	public static function once( $event, $callable ) {
		return static::instance()->get_emitter()->once( $event, $callable );
	}

	/**
	 * Get default IoC container dependencies
	 * 
	 * @return PimpleContainer
	 */
	protected static function get_default_ioc() {
		$ioc = new PimpleContainer();

		$ioc['loader'] = function( $ioc ) {
			return new Loader( $ioc['sidebar_manager'], $ioc['container_repository'] );
		};

		$ioc['container_repository'] = function() {
			return new ContainerRepository();
		};

		$ioc['fields'] = function() {
			return new PimpleContainer();
		};

		$ioc['key_toolset'] = function() {
			return new Key_Toolset();
		};

		$ioc['wp_toolset'] = function() {
			return new WP_Toolset();
		};

		$ioc['sidebar_manager'] = function() {
			return new Sidebar_Manager();
		};

		$ioc['rest_api_router'] = function( $ioc ) {
			return new REST_API_Router( $ioc['container_repository'] );
		};

		$ioc['rest_api_decorator'] = function( $ioc ) {
			return new REST_API_Decorator( $ioc['container_repository'] );
		};

		/* Services */
		$ioc['services'] = function() {
			return new PimpleContainer();
		};

		$ioc['services']['meta_query'] = function() use ( $ioc ) {
			return new Meta_Query_Service( $ioc['container_repository'], $ioc['key_toolset'] );
		};

		$ioc['services']['legacy_storage'] = function() use ( $ioc ) {
			return new Legacy_Storage_Service_v_1_5( $ioc['container_repository'], $ioc['key_toolset'] );
		};

		$ioc['services']['rest_api'] = function() use ( $ioc ) {
			return new REST_API_Service( $ioc['rest_api_router'], $ioc['rest_api_decorator'] );
		};

		/* Events */
		$ioc['event_emitter'] = function() {
			return new Emitter();
		};

		$ioc['event_persistent_listener'] = function() {
			return new PersistentListener();
		};

		$ioc['event_single_event_listener'] = function() {
			return new SingleEventListener();
		};

		$ioc->register( new \Carbon_Fields\Provider\Container_Condition_Provider() );

		return $ioc;
	}
}

1		<?php
2
3		namespace Carbon_Fields;
4
5		use Carbon_Fields\Pimple\Container as PimpleContainer;
6		use Carbon_Fields\Helper\Helper;
7		use Carbon_Fields\Loader\Loader;
8		use Carbon_Fields\Container\Repository as ContainerRepository;
9		use Carbon_Fields\Toolset\Key_Toolset;
10		use Carbon_Fields\Toolset\WP_Toolset;
11		use Carbon_Fields\Service\Meta_Query_Service;
12		use Carbon_Fields\Service\Legacy_Storage_Service_v_1_5;
13		use Carbon_Fields\Service\REST_API_Service;
14		use Carbon_Fields\Libraries\Sidebar_Manager\Sidebar_Manager;
15
16		use Carbon_Fields\REST_API\Router as REST_API_Router;
17		use Carbon_Fields\REST_API\Decorator as REST_API_Decorator;
18
19		use Carbon_Fields\Event\Emitter;
20		use Carbon_Fields\Event\PersistentListener;
21		use Carbon_Fields\Event\SingleEventListener;
22
23		use Carbon_Fields\Exception\Incorrect_Syntax_Exception;
24
25		/**
26		* Holds a static reference to the ioc container
27		*/
28		final class Carbon_Fields {
29
30		/**
31		* An event emitter to facilitate events before the WordPress environment is guaranteed to be loaded
32		*
33		* @var Emitter
34		*/
35		protected $emitter;
36
37		/**
38		* Flag if Carbon Fields has been booted
39		*
40		* @var bool
41		*/
42		public $booted = false;
43
44		/**
45		* Inversion of Control container instance
46		*
47		* @var PimpleContainer
48		*/
49		public $ioc = null;
50
51		/**
52		* Singleton implementation
53		*
54		* @return Carbon_Fields\Carbon_Fields
55		*/
56		public static function instance() {
57		static $instance = null;
58		if ( $instance === null ) {
59		$instance = new static();
60		}
61		return $instance;
62		}
63
64		/**
65		* Constructor
66		*/
67		private function __construct() {
68		$this->install( $this->get_default_ioc() );
69		}
70
71		/**
72		* Resolve a dependency through IoC
73		*
74		* @param string $key
75		* @param string\|null $subcontainer Subcontainer to look into
76		* @return mixed
77		*/
78	View Code Duplication	public static function resolve( $key, $subcontainer = null ) {
79		$ioc = static::instance()->ioc;
80		if ( $subcontainer !== null ) {
81		if ( ! isset( $ioc[ $subcontainer ] ) ) {
82		return null;
83		}
84		$ioc = $ioc[ $subcontainer ];
85		}
86		return $ioc[ $key ];
87		}
88
89		/**
90		* Resolve a dependency through IoC with arguments
91		*
92		* @param string $identifier Key to resolve from the container
93		* @param array $arguments Key-value array of arguments
94		* @param string $subcontainer The container to resolve from
95		* @return mixed
96		*/
97		public static function resolve_with_arguments( $identifier, $arguments, $subcontainer = null ) {
98		$supercontainer = $subcontainer ? static::resolve( $subcontainer ) : static::instance()->ioc;
99		$container = new PimpleContainer();
100		$container['container'] = $supercontainer;
101		$container['arguments'] = $arguments;
102		$container['object'] = $supercontainer->raw( $identifier );
103		return $container['object'];
104		}
105
106		/**
107		* Resolve a service through IoC
108		*
109		* @param string $service_name
110		* @return mixed
111		*/
112		public static function service( $service_name ) {
113		return static::resolve( $service_name, 'services' );
114		}
115
116		/**
117		* Check if a dependency is registered
118		*
119		* @param string $key
120		* @param string\|null $subcontainer Subcontainer to look into
121		* @return bool
122		*/
123	View Code Duplication	public static function has( $key, $subcontainer = null ) {
124		$ioc = static::instance()->ioc;
125		if ( $subcontainer !== null ) {
126		if ( ! isset( $ioc[ $subcontainer ] ) ) {
127		return false;
128		}
129		$ioc = $ioc[ $subcontainer ];
130		}
131		return isset( $ioc[ $key ] );
132		}
133
134		/**
135		* Extend Carbon Fields by adding a new entity (container condition etc.)
136		*
137		* @param string $class Extension class name
138		* @param string $extender Extending callable
139		*/
140		public static function extend( $class, $extender ) {
141		$type_dictionary = array(
142		'_Field' => 'fields',
143		'_Condition' => 'container_conditions',
144		);
145
146		$extension_suffix = '';
147		$extension_subcontainer = '';
148		foreach ( $type_dictionary as $suffix => $subcontainer ) {
149		if ( substr( $class, -strlen( $suffix ) ) === $suffix ) {
150		$extension_suffix = $suffix;
151		$extension_subcontainer = $subcontainer;
152		}
153		}
154
155		if ( empty( $extension_suffix ) ) {
156		Incorrect_Syntax_Exception::raise( 'Could not determine "' . $class . '" extension type. Extension classes must have one of the following suffixes: ' . implode( ', ', array_keys( $type_dictionary ) ) );
157		return;
158		}
159
160		$identifier = Helper::class_to_type( $class, $extension_suffix );
161		$ioc = static::instance()->ioc[ $extension_subcontainer ];
162		$ioc[ $identifier ] = $ioc->factory( $extender );
163		}
164
165		/**
166		* Replace the ioc container for Carbon_Fields\Carbon_Fields
167		*
168		* @param PimpleContainer $ioc
169		*/
170		public function install( PimpleContainer $ioc ) {
171		$this->ioc = $ioc;
172		}
173
174		/**
175		* Boot Carbon Fields with default IoC dependencies
176		*/
177		public static function boot() {
178		if ( static::is_booted() ) {
179		return;
180		}
181
182		if ( defined( __NAMESPACE__ . '\VERSION' ) ) {
183		return; // Possibly attempting to load multiple versions of Carbon Fields; bail in favor of already loaded version
184		}
185
186		static::resolve( 'loader' )->boot();
187		static::instance()->booted = true;
188		static::instance()->get_emitter()->emit( 'loaded' );
189		do_action( 'carbon_fields_loaded' );
190		}
191
192		/**
193		* Check if Carbon Fields has booted
194		*/
195		public static function is_booted() {
196		return static::instance()->booted;
197		}
198
199		/**
200		* Throw exception if Carbon Fields has not been booted
201		*/
202		public static function verify_boot() {
203		if ( ! static::is_booted() ) {
204		throw new \Exception( 'You must call Carbon_Fields\Carbon_Fields::boot() in a suitable WordPress hook before using Carbon Fields.' );
205		}
206		}
207
208		/**
209		* Resolve the public url of a directory inside WordPress
210		*
211		* @param string $directory
212		* @return string
213		*/
214		public static function directory_to_url( $directory ) {
215		$url = \trailingslashit( $directory );
216		$count = 0;
217
218		# Sanitize directory separator on Windows
219		$url = str_replace( '\\' ,'/', $url );
220
221		$possible_locations = array(
222		WP_PLUGIN_DIR => \plugins_url(), # If installed as a plugin
223		WP_CONTENT_DIR => \content_url(), # If anywhere in wp-content
224		ABSPATH => \site_url( '/' ), # If anywhere else within the WordPress installation
225		);
226
227		foreach ( $possible_locations as $test_dir => $test_url ) {
228		$test_dir_normalized = str_replace( '\\' ,'/', $test_dir );
229		$url = str_replace( $test_dir_normalized, $test_url, $url, $count );
230
231		if ( $count > 0 ) {
232		break;
233		}
234		}
235
236		return \untrailingslashit( $url );
237		}
238
239		/**
240		* Get the event emitter
241		*
242		* @return Emitter
243		*/
244		public function get_emitter() {
245		if ( $this->emitter === null ) {
246		$this->emitter = static::resolve( 'event_emitter' );
247		}
248		return $this->emitter;
249		}
250
251		/**
252		* Add a listener to an event
253		*
254		* @param string $event
255		* @return Listener $listener
256		*/
257		public static function add_listener( $event, $listener ) {
258		return static::instance()->get_emitter()->add_listener( $event, $listener );
259		}
260
261		/**
262		* Remove a listener from any event
263		*
264		* @param Listener $listener
265		*/
266		public static function remove_listener( $listener ) {
267		static::instance()->get_emitter()->remove_listener( $listener );
268		}
269
270		/**
271		* Add a persistent listener to an event
272		*
273		* @param string $event The event to listen for
274		* @param string $callable The callable to call when the event is broadcasted
275		* @return Listener
276		*/
277		public static function on( $event, $callable ) {
278		return static::instance()->get_emitter()->on( $event, $callable );
279		}
280
281		/**
282		* Add a one-time listener to an event
283		*
284		* @param string $event The event to listen for
285		* @param string $callable The callable to call when the event is broadcasted
286		* @return Listener
287		*/
288		public static function once( $event, $callable ) {
289		return static::instance()->get_emitter()->once( $event, $callable );
290		}
291
292		/**
293		* Get default IoC container dependencies
294		*
295		* @return PimpleContainer
296		*/
297		protected static function get_default_ioc() {
298		$ioc = new PimpleContainer();
299
300		$ioc['loader'] = function( $ioc ) {
301		return new Loader( $ioc['sidebar_manager'], $ioc['container_repository'] );
302		};
303
304		$ioc['container_repository'] = function() {
305		return new ContainerRepository();
306		};
307
308		$ioc['fields'] = function() {
309		return new PimpleContainer();
310		};
311
312		$ioc['key_toolset'] = function() {
313		return new Key_Toolset();
314		};
315
316		$ioc['wp_toolset'] = function() {
317		return new WP_Toolset();
318		};
319
320		$ioc['sidebar_manager'] = function() {
321		return new Sidebar_Manager();
322		};
323
324		$ioc['rest_api_router'] = function( $ioc ) {
325		return new REST_API_Router( $ioc['container_repository'] );
326		};
327
328		$ioc['rest_api_decorator'] = function( $ioc ) {
329		return new REST_API_Decorator( $ioc['container_repository'] );
330		};
331
332		/* Services */
333		$ioc['services'] = function() {
334		return new PimpleContainer();
335		};
336
337		$ioc['services']['meta_query'] = function() use ( $ioc ) {
338		return new Meta_Query_Service( $ioc['container_repository'], $ioc['key_toolset'] );
339		};
340
341		$ioc['services']['legacy_storage'] = function() use ( $ioc ) {
342		return new Legacy_Storage_Service_v_1_5( $ioc['container_repository'], $ioc['key_toolset'] );
343		};
344
345		$ioc['services']['rest_api'] = function() use ( $ioc ) {
346		return new REST_API_Service( $ioc['rest_api_router'], $ioc['rest_api_decorator'] );
347		};
348
349		/* Events */
350		$ioc['event_emitter'] = function() {
351		return new Emitter();
352		};
353
354		$ioc['event_persistent_listener'] = function() {
355		return new PersistentListener();
356		};
357
358		$ioc['event_single_event_listener'] = function() {
359		return new SingleEventListener();
360		};
361
362		$ioc->register( new \Carbon_Fields\Provider\Container_Condition_Provider() );
363
364		return $ioc;
365		}
366		}

htmlburger / carbon-fields

Push — milestone/2_0/react-ui ( 6ff089...f420b0 )

Carbon_Fields::is_booted() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like