Application::loadRoutes() - Code Metrics - Inspection of "Refactor Application::routes()" - htmlburger/wpemerge - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — refactor/kernels (f01954)

by Atanas

created 2019-04-11 23:46 UTC

Application::loadRoutes() A

↳ Parent: Application

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	2
dl	0
loc	8
ccs	0
cts	0
cp	0
crap	6
rs	10
c	0
b	0
f	0

<?php
/**
 * @package   WPEmerge
 * @author    Atanas Angelov <[email protected]>
 * @copyright 2018 Atanas Angelov
 * @license   https://www.gnu.org/licenses/gpl-2.0.html GPL-2.0
 * @link      https://wpemerge.com/
 */

namespace WPEmerge\Application;

use Pimple\Container;
use Psr\Http\Message\ResponseInterface;
use WPEmerge\Controllers\ControllersServiceProvider;
use WPEmerge\Csrf\CsrfServiceProvider;
use WPEmerge\Exceptions\ConfigurationException;
use WPEmerge\Exceptions\ExceptionsServiceProvider;
use WPEmerge\Facades\Router;
use WPEmerge\Flash\FlashServiceProvider;
use WPEmerge\Input\OldInputServiceProvider;
use WPEmerge\Kernels\KernelsServiceProvider;
use WPEmerge\Requests\RequestsServiceProvider;
use WPEmerge\Responses\ResponsesServiceProvider;
use WPEmerge\Routing\RoutingServiceProvider;
use WPEmerge\ServiceProviders\ServiceProviderInterface;
use WPEmerge\Support\AliasLoader;
use WPEmerge\View\ViewServiceProvider;

/**
 * Main communication channel with the application.
 */
class Application {
	/**
	 * Flag whether the application has been bootstrapped.
	 *
	 * @var boolean
	 */
	protected $bootstrapped = false;

	/**
	 * IoC container.
	 *
	 * @var Container
	 */
	protected $container = null;

	/**
	 * Array of application service providers.
	 *
	 * @var string[]
	 */
	protected $service_providers = [
		KernelsServiceProvider::class,
		ExceptionsServiceProvider::class,
		RequestsServiceProvider::class,
		ResponsesServiceProvider::class,
		RoutingServiceProvider::class,
		ViewServiceProvider::class,
		ControllersServiceProvider::class,
		CsrfServiceProvider::class,
		FlashServiceProvider::class,
		OldInputServiceProvider::class,
	];

	/**
	 * Constructor.
	 *
	 * @param Container $container
	 */
	public function __construct( Container $container ) {
		$this->container = $container;

		$config = isset( $container[ WPEMERGE_CONFIG_KEY ] ) ? $container[ WPEMERGE_CONFIG_KEY ] : [];
		$config = array_merge( [
			'providers' => [],
		], $config );
		$container[ WPEMERGE_CONFIG_KEY ] = $config;
	}

	/**
	 * Get whether WordPress is in debug mode.
	 *
	 * @return boolean
	 */
	public function debugging() {
		$debugging = ( defined( 'WP_DEBUG' ) && WP_DEBUG );
		$debugging = apply_filters( 'wpemerge.debug', $debugging );
		return $debugging;
	}

	/**
	 * Get whether the application has been bootstrapped.
	 *
	 * @return boolean
	 */
	public function isBootstrapped() {
		return $this->bootstrapped;
	}

	/**
	 * Throw an exception if the application has not been bootstrapped.
	 *
	 * @throws ConfigurationException
	 * @return void
	 */
	protected function verifyBootstrap() {
		if ( ! $this->isBootstrapped() ) {
			throw new ConfigurationException( static::class . ' must be bootstrapped first.' );
		}
	}

	/**
	 * Get the IoC container instance.
	 *
	 * @return Container
	 */
	public function getContainer() {
		return $this->container;
	}

	/**
	 * Bootstrap the application.
	 * WordPress' 'after_setup_theme' action is a good place to call this.
	 *
	 * @throws ConfigurationException
	 * @param  array $config
	 * @return void
	 */
	public function bootstrap( $config = [] ) {
		if ( $this->isBootstrapped() ) {
			throw new ConfigurationException( static::class . ' already bootstrapped.' );
		}

		$container = $this->getContainer();
		$this->loadConfig( $container, $config );
		$this->loadServiceProviders( $container );

		$this->bootstrapped = true;

		require_once WPEMERGE_DIR . DIRECTORY_SEPARATOR . 'src' . DIRECTORY_SEPARATOR . 'run.php';
	}

	/**
	 * Load config into the service container.
	 *
	 * @codeCoverageIgnore
	 * @param  Container $container
	 * @param  array     $config
	 * @return void
	 */
	protected function loadConfig( Container $container, $config ) {
		$container[ WPEMERGE_CONFIG_KEY ] = array_merge(
			$container[ WPEMERGE_CONFIG_KEY ],
			$config
		);
	}

	/**
	 * Register and bootstrap all service providers.
	 *
	 * @codeCoverageIgnore
	 * @param  Container $container
	 * @return void
	 */
	protected function loadServiceProviders( Container $container ) {
		$container[ WPEMERGE_SERVICE_PROVIDERS_KEY ] = array_merge(
			$this->service_providers,
			$container[ WPEMERGE_CONFIG_KEY ]['providers']
		);

		$service_providers = array_map( function ( $service_provider ) {
			if ( ! is_subclass_of( $service_provider, ServiceProviderInterface::class ) ) {
				throw new ConfigurationException( 'The following class does not implement ServiceProviderInterface: ' . $service_provider );
			}

			return new $service_provider();
		}, $container[ WPEMERGE_SERVICE_PROVIDERS_KEY ] );

		$this->registerServiceProviders( $service_providers, $container );
		$this->bootstrapServiceProviders( $service_providers, $container );
	}

	/**
	 * Register all service providers.
	 *
	 * @param  \WPEmerge\ServiceProviders\ServiceProviderInterface[] $service_providers
	 * @param  Container                                             $container
	 * @return void
	 */
	protected function registerServiceProviders( $service_providers, Container $container ) {
		foreach ( $service_providers as $provider ) {
			$provider->register( $container );
		}
	}

	/**
	 * Bootstrap all service providers.
	 *
	 * @param  \WPEmerge\ServiceProviders\ServiceProviderInterface[] $service_providers
	 * @param  Container                                             $container
	 * @return void
	 */
	protected function bootstrapServiceProviders( $service_providers, Container $container ) {
		foreach ( $service_providers as $provider ) {
			$provider->bootstrap( $container );
		}
	}

	/**
	 * Register a facade class.
	 *
	 * @param  string $alias
	 * @param  string $facade_class
	 * @return void
	 */
	public function facade( $alias, $facade_class ) {
		AliasLoader::getInstance()->alias( $alias, $facade_class );
	}

	/**
	 * Resolve a dependency from the IoC container.
	 *
	 * @param  string     $key
	 * @return mixed|null
	 */
	public function resolve( $key ) {
		$this->verifyBootstrap();

		if ( ! isset( $this->getContainer()[ $key ] ) ) {
			return null;
		}

		return $this->getContainer()[ $key ];
	}

	/**
	 * Create and return a class instance.
	 *
	 * @throws ClassNotFoundException
	 * @param  string $class
	 * @return object
	 */
	public function instantiate( $class ) {
		$this->verifyBootstrap();

		$instance = $this->resolve( $class );

		if ( $instance === null ) {
			if ( ! class_exists( $class ) ) {
				throw new ClassNotFoundException( 'Class not found: ' . $class );
			}

			$instance = new $class();
		}

		return $instance;
	}

	/**
	 * Send output based on a response object.
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface $response
	 * @return void
	 */
	public function respond( ResponseInterface $response ) {
		$this->resolve( WPEMERGE_RESPONSE_SERVICE_KEY )->respond( $response );
	}

	/**
	 * Load a route definition file, applying middleware to all routes defined within.
	 *
	 * @codeCoverageIgnore
	 * @param  string        $file
	 * @param  array<string> $middleware
	 * @return void
	 */
	protected function loadRoutes( $file, $middleware = [] ) {
		if ( empty( $file ) ) {
			return;
		}

		Router::group( [
			'middleware' => $middleware,
		], $file );
	}

	/**
	 * Load route definition files according to the current request.
	 *
	 * @codeCoverageIgnore
	 * @param  string $web
	 * @param  string $admin
	 * @param  string $ajax
	 * @return void
	 */
	public function routes( $web = '', $admin = '', $ajax = '' ) {
		if ( defined( 'DOING_AJAX' ) && DOING_AJAX ) {
			$this->loadRoutes( $ajax, ['ajax'] );
			return;
		}

		if ( is_admin() ) {
			$this->loadRoutes( $admin, ['admin'] );
			return;
		}

		$this->loadRoutes( $web, ['web'] );
	}
}


1		<?php
2		/**
3		* @package WPEmerge
4		* @author Atanas Angelov <[email protected]>
5		* @copyright 2018 Atanas Angelov
6		* @license https://www.gnu.org/licenses/gpl-2.0.html GPL-2.0
7		* @link https://wpemerge.com/
8		*/
9
10		namespace WPEmerge\Application;
11
12		use Pimple\Container;
13		use Psr\Http\Message\ResponseInterface;
14		use WPEmerge\Controllers\ControllersServiceProvider;
15		use WPEmerge\Csrf\CsrfServiceProvider;
16		use WPEmerge\Exceptions\ConfigurationException;
17		use WPEmerge\Exceptions\ExceptionsServiceProvider;
18		use WPEmerge\Facades\Router;
19		use WPEmerge\Flash\FlashServiceProvider;
20		use WPEmerge\Input\OldInputServiceProvider;
21		use WPEmerge\Kernels\KernelsServiceProvider;
22		use WPEmerge\Requests\RequestsServiceProvider;
23		use WPEmerge\Responses\ResponsesServiceProvider;
24		use WPEmerge\Routing\RoutingServiceProvider;
25		use WPEmerge\ServiceProviders\ServiceProviderInterface;
26		use WPEmerge\Support\AliasLoader;
27		use WPEmerge\View\ViewServiceProvider;
28
29		/**
30		* Main communication channel with the application.
31		*/
32		class Application {
33		/**
34		* Flag whether the application has been bootstrapped.
35		*
36		* @var boolean
37		*/
38		protected $bootstrapped = false;
39
40		/**
41		* IoC container.
42		*
43		* @var Container
44		*/
45		protected $container = null;
46
47		/**
48		* Array of application service providers.
49		*
50		* @var string[]
51		*/
52		protected $service_providers = [
53		KernelsServiceProvider::class,
54		ExceptionsServiceProvider::class,
55		RequestsServiceProvider::class,
56		ResponsesServiceProvider::class,
57		RoutingServiceProvider::class,
58		ViewServiceProvider::class,
59		ControllersServiceProvider::class,
60		CsrfServiceProvider::class,
61		FlashServiceProvider::class,
62		OldInputServiceProvider::class,
63		];
64
65		/**
66		* Constructor.
67		*
68		* @param Container $container
69		*/
70	1	public function __construct( Container $container ) {
71	1	$this->container = $container;
72
73	1	$config = isset( $container[ WPEMERGE_CONFIG_KEY ] ) ? $container[ WPEMERGE_CONFIG_KEY ] : [];
74	1	$config = array_merge( [
75	1	'providers' => [],
76	1	], $config );
77	1	$container[ WPEMERGE_CONFIG_KEY ] = $config;
78	1	}
79
80		/**
81		* Get whether WordPress is in debug mode.
82		*
83		* @return boolean
84		*/
85	1	public function debugging() {
86	1	$debugging = ( defined( 'WP_DEBUG' ) && WP_DEBUG );
87	1	$debugging = apply_filters( 'wpemerge.debug', $debugging );
88	1	return $debugging;
89		}
90
91		/**
92		* Get whether the application has been bootstrapped.
93		*
94		* @return boolean
95		*/
96	1	public function isBootstrapped() {
97	1	return $this->bootstrapped;
98		}
99
100		/**
101		* Throw an exception if the application has not been bootstrapped.
102		*
103		* @throws ConfigurationException
104		* @return void
105		*/
106	5	protected function verifyBootstrap() {
107	5	if ( ! $this->isBootstrapped() ) {
108	1	throw new ConfigurationException( static::class . ' must be bootstrapped first.' );
109		}
110	4	}
111
112		/**
113		* Get the IoC container instance.
114		*
115		* @return Container
116		*/
117	1	public function getContainer() {
118	1	return $this->container;
119		}
120
121		/**
122		* Bootstrap the application.
123		* WordPress' 'after_setup_theme' action is a good place to call this.
124		*
125		* @throws ConfigurationException
126		* @param array $config
127		* @return void
128		*/
129	3	public function bootstrap( $config = [] ) {
130	3	if ( $this->isBootstrapped() ) {
131	1	throw new ConfigurationException( static::class . ' already bootstrapped.' );
132		}
133
134	3	$container = $this->getContainer();
135	3	$this->loadConfig( $container, $config );
136	3	$this->loadServiceProviders( $container );
137
138	3	$this->bootstrapped = true;
139
140	3	require_once WPEMERGE_DIR . DIRECTORY_SEPARATOR . 'src' . DIRECTORY_SEPARATOR . 'run.php';
141	3	}
142
143		/**
144		* Load config into the service container.
145		*
146		* @codeCoverageIgnore
147		* @param Container $container
148		* @param array $config
149		* @return void
150		*/
151		protected function loadConfig( Container $container, $config ) {
152		$container[ WPEMERGE_CONFIG_KEY ] = array_merge(
153		$container[ WPEMERGE_CONFIG_KEY ],
154		$config
155		);
156		}
157
158		/**
159		* Register and bootstrap all service providers.
160		*
161		* @codeCoverageIgnore
162		* @param Container $container
163		* @return void
164		*/
165		protected function loadServiceProviders( Container $container ) {
166		$container[ WPEMERGE_SERVICE_PROVIDERS_KEY ] = array_merge(
167		$this->service_providers,
168		$container[ WPEMERGE_CONFIG_KEY ]['providers']
169		);
170
171		$service_providers = array_map( function ( $service_provider ) {
172		if ( ! is_subclass_of( $service_provider, ServiceProviderInterface::class ) ) {
173		throw new ConfigurationException( 'The following class does not implement ServiceProviderInterface: ' . $service_provider );
174		}
175
176		return new $service_provider();
177		}, $container[ WPEMERGE_SERVICE_PROVIDERS_KEY ] );
178
179		$this->registerServiceProviders( $service_providers, $container );
180		$this->bootstrapServiceProviders( $service_providers, $container );
181		}
182
183		/**
184		* Register all service providers.
185		*
186		* @param \WPEmerge\ServiceProviders\ServiceProviderInterface[] $service_providers
187		* @param Container $container
188		* @return void
189		*/
190	1	protected function registerServiceProviders( $service_providers, Container $container ) {
191	1	foreach ( $service_providers as $provider ) {
192	1	$provider->register( $container );
193		}
194	1	}
195
196		/**
197		* Bootstrap all service providers.
198		*
199		* @param \WPEmerge\ServiceProviders\ServiceProviderInterface[] $service_providers
200		* @param Container $container
201		* @return void
202		*/
203	1	protected function bootstrapServiceProviders( $service_providers, Container $container ) {
204	1	foreach ( $service_providers as $provider ) {
205	1	$provider->bootstrap( $container );
206		}
207	1	}
208
209		/**
210		* Register a facade class.
211		*
212		* @param string $alias
213		* @param string $facade_class
214		* @return void
215		*/
216	1	public function facade( $alias, $facade_class ) {
217	1	AliasLoader::getInstance()->alias( $alias, $facade_class );
218	1	}
219
220		/**
221		* Resolve a dependency from the IoC container.
222		*
223		* @param string $key
224		* @return mixed\|null
225		*/
226	2	public function resolve( $key ) {
227	2	$this->verifyBootstrap();
228
229	2	if ( ! isset( $this->getContainer()[ $key ] ) ) {
230	1	return null;
231		}
232
233	1	return $this->getContainer()[ $key ];
234		}
235
236		/**
237		* Create and return a class instance.
238		*
239		* @throws ClassNotFoundException
240		* @param string $class
241		* @return object
242		*/
243	3	public function instantiate( $class ) {
244	3	$this->verifyBootstrap();
245
246	3	$instance = $this->resolve( $class );
247
248	3	if ( $instance === null ) {
249	2	if ( ! class_exists( $class ) ) {
250	1	throw new ClassNotFoundException( 'Class not found: ' . $class );
251		}
252
253	1	$instance = new $class();
254		}
255
256	2	return $instance;
257		}
258
259		/**
260		* Send output based on a response object.
261		*
262		* @codeCoverageIgnore
263		* @param ResponseInterface $response
264		* @return void
265		*/
266		public function respond( ResponseInterface $response ) {
267		$this->resolve( WPEMERGE_RESPONSE_SERVICE_KEY )->respond( $response );
268		}
269
270		/**
271		* Load a route definition file, applying middleware to all routes defined within.
272		*
273		* @codeCoverageIgnore
274		* @param string $file
275		* @param array<string> $middleware
276		* @return void
277		*/
278		protected function loadRoutes( $file, $middleware = [] ) {
279		if ( empty( $file ) ) {
280		return;
281		}
282
283		Router::group( [
284		'middleware' => $middleware,
285		], $file );
286		}
287
288		/**
289		* Load route definition files according to the current request.
290		*
291		* @codeCoverageIgnore
292		* @param string $web
293		* @param string $admin
294		* @param string $ajax
295		* @return void
296		*/
297		public function routes( $web = '', $admin = '', $ajax = '' ) {
298		if ( defined( 'DOING_AJAX' ) && DOING_AJAX ) {
299		$this->loadRoutes( $ajax, ['ajax'] );
300		return;
301		}
302
303		if ( is_admin() ) {
304		$this->loadRoutes( $admin, ['admin'] );
305		return;
306		}
307
308		$this->loadRoutes( $web, ['web'] );
309		}
310		}
311

htmlburger / wpemerge

Branch — refactor/kernels (f01954)

Application::loadRoutes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like