Index::render_title() - Code Metrics - Inspection of "`\cs\Index` lost many ugly designed features which..." - nazar-pc/CleverStyle-Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dd2ca3...b52d57 )

by Nazar

created 2016-01-04 00:52 UTC

Index::render_title() A

↳ Parent: Index

Complexity

Conditions	4
Paths	3

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	15
rs	9.2
cc	4
eloc	8
nc	3
nop	0

<?php
/**
 * @package   CleverStyle CMS
 * @author    Nazar Mokrynskyi <[email protected]>
 * @copyright Copyright (c) 2011-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs;
use
	h;

/**
 * Provides next events:
 *  System/Index/block_render
 *  [
 *      'index'           => $index,        //Block index
 *      'blocks_array'    => &$blocks_array //Reference to array in form ['top' => '', 'left' => '', 'right' => '', 'bottom' => '']
 *  ]
 *
 *  System/Index/construct
 *
 *  System/Index/preload
 *
 *  System/Index/postload
 *
 * @method static Index instance($check = false)
 *
 * @property string[] $controller_path Path that will be used by controller to render page
 */
class Index {
	use
		Singleton,
		Index\Router;

	/**
	 * Appends to the end of title
	 *
	 * @var string
	 */
	protected $append_to_title = '';
	/**
	 * Name of current module
	 *
	 * @var string
	 */
	protected $module;
	protected $request_method;
	protected $working_directory = '';
	protected $called_once       = false;
	/**
	 * Reference to Route::instance()->path
	 *
	 * @var string[]
	 */
	protected $path = [];
	/**
	 * Reference to Route::instance()->ids
	 *
	 * @var int[]
	 */
	protected $ids = [];
	/**
	 * Path that will be used by controller to render page
	 *
	 * @var string[]
	 */
	protected $controller_path = ['index'];
	/**
	 * Detecting module folder including of admin/api request type, including prepare file, including of plugins
	 *
	 * @throws ExitException
	 */
	function construct () {
		$Config     = Config::instance();
		$Route      = Route::instance();
		$this->path = &$Route->path;
		$this->ids  = &$Route->ids;
		if ($this->closed_site($Config)) {
			return;
		}
		$this->module            = current_module();
		$this->working_directory = MODULES."/$this->module";
		if (admin_path()) {
			$this->working_directory .= '/admin';
		} elseif (api_path()) {
			$this->working_directory .= '/api';
		}
		if (!is_dir($this->working_directory)) {
			throw new ExitException(404);
		}
		if (!$this->check_permission('index')) {
			throw new ExitException(403);
		}
		Event::instance()->fire('System/Index/construct');
		/**
		 * Plugins processing
		 */
		foreach ($Config->components['plugins'] as $plugin) {
			_include(PLUGINS."/$plugin/index.php", false, false);
		}
		_include("$this->working_directory/prepare.php", false, false);
		/**
		 * @var _SERVER $_SERVER
		 */
		$this->request_method = strtolower($_SERVER->request_method);
		if (!preg_match('/^[a-z_]+$/', $this->request_method)) {
			throw new ExitException(400);
		}
	}
	/**
	 * Check if site is closed (taking user into account)
	 *
	 * @param Config $Config
	 *
	 * @return bool Whether user is not admin and this is not request for sign in (we allow to sign in on disabled site)
	 */
	protected function closed_site ($Config) {
		if (
			$Config->core['site_mode'] ||
			User::instance()->admin()
		) {
			return false;
		}
		return
			!api_path() ||
			$this->module != 'System' ||
			Route::instance()->route !== ['user', 'sign_in'];
	}
	/**
	 * Check whether user allowed to access to specified label
	 *
	 * @param string $label
	 *
	 * @return bool
	 */
	protected function check_permission ($label) {
		$permission_group = $this->module;
		if (admin_path()) {
			$permission_group = "admin/$permission_group";
		} elseif (api_path()) {
			$permission_group = "api/$permission_group";
		}
		return User::instance()->get_permission($permission_group, $label);
	}
	/**
	 * Page generation, blocks processing, adding of form with save/apply/cancel/reset and/or custom users buttons
	 *
	 * @throws ExitException
	 */
	protected function render_page () {
		$this->render_title();
		$this->render_content();
		if (!api_path()) {
			$this->render_blocks();
		}
	}
	/**
	 * Render page title
	 */
	protected function render_title () {
		$Page = Page::instance();
		/**
		 * Add generic Home or Module name title
		 */
		if (!api_path()) {
			$L = Language::instance();
			if (admin_path()) {
				$Page->title($L->administration);
			}
			$Page->title(
				$L->{home_page() ? 'home' : $this->module}
			);
		}
	}
	/**
	 * Render page content (without blocks, just module content)
	 *
	 * @throws ExitException
	 */
	protected function render_content () {
		$Page = Page::instance();
		/**
		 * If module consists of index.html only
		 */
		if (file_exists("$this->working_directory/index.html")) {
			ob_start();
			_include("$this->working_directory/index.html", false, false);
			$Page->content(ob_get_clean());
			return;
		}
		$this->execute_router();
	}
	/**
	 * Simple wrapper for form buttons
	 *
	 * @param string $name
	 * @param bool   $disabled
	 *
	 * @return string
	 */
	protected function form_button ($name, $disabled = false) {
		$L = Language::instance();
		return h::{'button[is=cs-button]'}(
			$L->$name,
			[
				'name'    => $name,
				'type'    => 'submit',
				'tooltip' => $L->{$name.'_info'},
				$disabled ? 'disabled' : false
			]
		);
	}
	/**
	 * Blocks rendering
	 */
	protected function render_blocks () {
		$blocks = Config::instance()->components['blocks'];
		/**
		 * It is frequent that there is no blocks - so, no need to to anything here
		 */
		if (!$blocks) {
			return;
		}
		$Page         = Page::instance();
		$blocks_array = [
			'top'    => '',
			'left'   => '',
			'right'  => '',
			'bottom' => ''
		];
		foreach ($blocks as $block) {
			/**
			 * If there is no need to show block or it was rendered by even handler - skip further processing
			 */
			if (
				!$this->should_block_be_rendered($block) ||
				!Event::instance()->fire(
					'System/Index/block_render',
					[
						'index'        => $block['index'],
						'blocks_array' => &$blocks_array
					]
				)
			) {
				/**
				 * Block was rendered by event handler
				 */
				continue;
			}
			$block['title'] = $this->ml_process($block['title']);
			switch ($block['type']) {
				default:
					$block['content'] = ob_wrapper(
						function () use ($block) {
							include BLOCKS."/block.$block[type].php";
						}
					);
					break;
				case 'html':
				case 'raw_html':
					$block['content'] = $this->ml_process($block['content']);
					break;
			}
			/**
			 * Template file will have access to `$block` variable, so it can use that
			 */
			$content = str_replace(
				[
					'<!--id-->',
					'<!--title-->',
					'<!--content-->'
				],
				[
					$block['index'],
					$block['title'],
					$block['content']
				],
				ob_wrapper(
					function () use ($block) {
						$template = file_exists(TEMPLATES."/blocks/block.$block[template]") ? $block['template'] : 'default.html';
						include TEMPLATES."/blocks/block.$template";
					}
				)
			);
			if ($block['position'] == 'floating') {
				$Page->replace(
					"<!--block#$block[index]-->",
					$content
				);
			} else {
				$blocks_array[$block['position']] .= $content;
			}
		}
		$Page->Top .= $blocks_array['top'];
		$Page->Left .= $blocks_array['left'];
		$Page->Right .= $blocks_array['right'];
		$Page->Bottom .= $blocks_array['bottom'];
	}
	/**
	 * Check whether to render block or not based on its properties (active state, when start to show, when it expires and permissions)
	 *
	 * @param array $block
	 *
	 * @return bool
	 */
	protected function should_block_be_rendered ($block) {
		return
			$block['active'] &&
			$block['start'] <= time() &&
			(
				!$block['expire'] ||
				$block['expire'] >= time()
			) &&
			User::instance()->get_permission('Block', $block['index']);
	}
	/**
	 * @param string $text
	 *
	 * @return string

	 */
	protected function ml_process ($text) {
		return Text::instance()->process(Config::instance()->module('System')->db('texts'), $text, true);
	}
	/**
	 * Saving changes and/or showing resulting message of saving changes
	 *
	 * @param bool|null $result If bool - result will be shown only, otherwise works similar to the $Config->save() and shows resulting message
	 *
	 * @return bool
	 */
	function save ($result = null) {
		$L    = Language::instance();
		$Page = Page::instance();
		if ($result || ($result === null && Config::instance()->save())) {
			$this->append_to_title = $L->changes_saved;
			$Page->success($L->changes_saved);
			return true;
		} else {
			$this->append_to_title = $L->changes_save_error;
			$Page->warning($L->changes_save_error);
			return false;
		}
	}
	/**
	 * Applying changes and/or showing resulting message of applying changes
	 *
	 * @param bool|null|string $result If bool - result will be shown only, otherwise works similar to the $Config->apply() and shows resulting message
	 *
	 * @return bool
	 */
	function apply ($result = null) {
		$L    = Language::instance();
		$Page = Page::instance();
		if ($result || ($result === null && Config::instance()->apply())) {
			$this->append_to_title = $L->changes_applied;
			$Page->success($L->changes_applied.$L->check_applied);
			return true;
		} else {
			$this->append_to_title = $L->changes_apply_error;
			$Page->warning($L->changes_apply_error);
			return false;
		}
	}
	/**
	 * Changes canceling and/or showing result of canceling changes
	 *
	 * @param bool $system If <b>true,/b> - cancels changes of system configuration, otherwise shows message about successful canceling
	 */
	function cancel ($system = true) {
		if ($system) {
			Config::instance()->cancel();
		}
		$L                     = Language::instance();
		$this->append_to_title = $L->changes_canceled;
		Page::instance()->success($L->changes_canceled);
	}
	/**
	 * Getter for `controller_path` propertie (no other properties supported currently)
	 *
	 * @param string $property
	 *
	 * @return false|string|string[]

	 */
	function __get ($property) {
		switch ($property) {
			case 'controller_path';
				return $this->controller_path;
		}
		return false;
	}
	/**
	 * Executes plugins processing, blocks and module page generation
	 *
	 * @throws ExitException
	 */
	function __finish () {
		/**
		 * Protection from double calling
		 */
		if ($this->called_once) {
			return;
		}
		$this->called_once = true;
		$Config            = Config::instance();
		$Page              = Page::instance();
		/**
		 * If site is closed
		 */
		if (!$Config->core['site_mode']) {
			if ($this->closed_site($Config)) {
				status_code(503);
				return;
			}
			/**
			 * Warning about closed site
			 */
			$Page->warning(get_core_ml_text('closed_title'));
		}
		Event::instance()->fire('System/Index/preload');
		$this->render_page();
		Event::instance()->fire('System/Index/postload');
	}
}


1			<?php
2			/**
3			* @package CleverStyle CMS
4			* @author Nazar Mokrynskyi <[email protected]>
5			* @copyright Copyright (c) 2011-2016, Nazar Mokrynskyi
6			* @license MIT License, see license.txt
7			*/
8			namespace cs;
9			use
10			h;
11
12			/**
13			* Provides next events:
14			* System/Index/block_render
15			* [
16			* 'index' => $index, //Block index
17			* 'blocks_array' => &$blocks_array //Reference to array in form ['top' => '', 'left' => '', 'right' => '', 'bottom' => '']
18			* ]
19			*
20			* System/Index/construct
21			*
22			* System/Index/preload
23			*
24			* System/Index/postload
25			*
26			* @method static Index instance($check = false)
27			*
28			* @property string[] $controller_path Path that will be used by controller to render page
29			*/
30			class Index {
31			use
32			Singleton,
33			Index\Router;
34
35			/**
36			* Appends to the end of title
37			*
38			* @var string
39			*/
40			protected $append_to_title = '';
41			/**
42			* Name of current module
43			*
44			* @var string
45			*/
46			protected $module;
47			protected $request_method;
48			protected $working_directory = '';
49			protected $called_once = false;
50			/**
51			* Reference to Route::instance()->path
52			*
53			* @var string[]
54			*/
55			protected $path = [];
56			/**
57			* Reference to Route::instance()->ids
58			*
59			* @var int[]
60			*/
61			protected $ids = [];
62			/**
63			* Path that will be used by controller to render page
64			*
65			* @var string[]
66			*/
67			protected $controller_path = ['index'];
68			/**
69			* Detecting module folder including of admin/api request type, including prepare file, including of plugins
70			*
71			* @throws ExitException
72			*/
73			function construct () {
74			$Config = Config::instance();
75			$Route = Route::instance();
76			$this->path = &$Route->path;
77			$this->ids = &$Route->ids;
78			if ($this->closed_site($Config)) {
79			return;
80			}
81			$this->module = current_module();
82			$this->working_directory = MODULES."/$this->module";
83			if (admin_path()) {
84			$this->working_directory .= '/admin';
85			} elseif (api_path()) {
86			$this->working_directory .= '/api';
87			}
88			if (!is_dir($this->working_directory)) {
89			throw new ExitException(404);
90			}
91			if (!$this->check_permission('index')) {
92			throw new ExitException(403);
93			}
94			Event::instance()->fire('System/Index/construct');
95			/**
96			* Plugins processing
97			*/
98			foreach ($Config->components['plugins'] as $plugin) {
99			_include(PLUGINS."/$plugin/index.php", false, false);
100			}
101			_include("$this->working_directory/prepare.php", false, false);
102			/**
103			* @var _SERVER $_SERVER
104			*/
105			$this->request_method = strtolower($_SERVER->request_method);
106			if (!preg_match('/^[a-z_]+$/', $this->request_method)) {
107			throw new ExitException(400);
108			}
109			}
110			/**
111			* Check if site is closed (taking user into account)
112			*
113			* @param Config $Config
114			*
115			* @return bool Whether user is not admin and this is not request for sign in (we allow to sign in on disabled site)
116			*/
117			protected function closed_site ($Config) {
118			if (
119			$Config->core['site_mode'] \|\|
120			User::instance()->admin()
121			) {
122			return false;
123			}
124			return
125			!api_path() \|\|
126			$this->module != 'System' \|\|
127			Route::instance()->route !== ['user', 'sign_in'];
128			}
129			/**
130			* Check whether user allowed to access to specified label
131			*
132			* @param string $label
133			*
134			* @return bool
135			*/
136			protected function check_permission ($label) {
137			$permission_group = $this->module;
138			if (admin_path()) {
139			$permission_group = "admin/$permission_group";
140			} elseif (api_path()) {
141			$permission_group = "api/$permission_group";
142			}
143			return User::instance()->get_permission($permission_group, $label);
144			}
145			/**
146			* Page generation, blocks processing, adding of form with save/apply/cancel/reset and/or custom users buttons
147			*
148			* @throws ExitException
149			*/
150			protected function render_page () {
151			$this->render_title();
152			$this->render_content();
153			if (!api_path()) {
154			$this->render_blocks();
155			}
156			}
157			/**
158			* Render page title
159			*/
160			protected function render_title () {
161			$Page = Page::instance();
162			/**
163			* Add generic Home or Module name title
164			*/
165			if (!api_path()) {
166			$L = Language::instance();
167			if (admin_path()) {
168			$Page->title($L->administration);
169			}
170			$Page->title(
171			$L->{home_page() ? 'home' : $this->module}
172			);
173			}
174			}
175			/**
176			* Render page content (without blocks, just module content)
177			*
178			* @throws ExitException
179			*/
180			protected function render_content () {
181			$Page = Page::instance();
182			/**
183			* If module consists of index.html only
184			*/
185			if (file_exists("$this->working_directory/index.html")) {
186			ob_start();
187			_include("$this->working_directory/index.html", false, false);
188			$Page->content(ob_get_clean());
189			return;
190			}
191			$this->execute_router();
192			}
193			/**
194			* Simple wrapper for form buttons
195			*
196			* @param string $name
197			* @param bool $disabled
198			*
199			* @return string
200			*/
201			protected function form_button ($name, $disabled = false) {
202			$L = Language::instance();
203			return h::{'button[is=cs-button]'}(
204			$L->$name,
205			[
206			'name' => $name,
207			'type' => 'submit',
208			'tooltip' => $L->{$name.'_info'},
209			$disabled ? 'disabled' : false
210			]
211			);
212			}
213			/**
214			* Blocks rendering
215			*/
216			protected function render_blocks () {
217			$blocks = Config::instance()->components['blocks'];
218			/**
219			* It is frequent that there is no blocks - so, no need to to anything here
220			*/
221			if (!$blocks) {
222			return;
223			}
224			$Page = Page::instance();
225			$blocks_array = [
226			'top' => '',
227			'left' => '',
228			'right' => '',
229			'bottom' => ''
230			];
231			foreach ($blocks as $block) {
232			/**
233			* If there is no need to show block or it was rendered by even handler - skip further processing
234			*/
235			if (
236			!$this->should_block_be_rendered($block) \|\|
237			!Event::instance()->fire(
238			'System/Index/block_render',
239			[
240			'index' => $block['index'],
241			'blocks_array' => &$blocks_array
242			]
243			)
244			) {
245			/**
246			* Block was rendered by event handler
247			*/
248			continue;
249			}
250			$block['title'] = $this->ml_process($block['title']);
251			switch ($block['type']) {
252			default:
253			$block['content'] = ob_wrapper(
254			function () use ($block) {
255			include BLOCKS."/block.$block[type].php";
256			}
257			);
258			break;
259			case 'html':
260			case 'raw_html':
261			$block['content'] = $this->ml_process($block['content']);
262			break;
263			}
264			/**
265			* Template file will have access to `$block` variable, so it can use that
266			*/
267			$content = str_replace(
268			[
269			'<!--id-->',
270			'<!--title-->',
271			'<!--content-->'
272			],
273			[
274			$block['index'],
275			$block['title'],
276			$block['content']
277			],
278			ob_wrapper(
279			function () use ($block) {
280			$template = file_exists(TEMPLATES."/blocks/block.$block[template]") ? $block['template'] : 'default.html';
281			include TEMPLATES."/blocks/block.$template";
282			}
283			)
284			);
285			if ($block['position'] == 'floating') {
286			$Page->replace(
287			"<!--block#$block[index]-->",
288			$content
289			);
290			} else {
291			$blocks_array[$block['position']] .= $content;
292			}
293			}
294			$Page->Top .= $blocks_array['top'];
295			$Page->Left .= $blocks_array['left'];
296			$Page->Right .= $blocks_array['right'];
297			$Page->Bottom .= $blocks_array['bottom'];
298			}
299			/**
300			* Check whether to render block or not based on its properties (active state, when start to show, when it expires and permissions)
301			*
302			* @param array $block
303			*
304			* @return bool
305			*/
306			protected function should_block_be_rendered ($block) {
307			return
308			$block['active'] &&
309			$block['start'] <= time() &&
310			(
311			!$block['expire'] \|\|
312			$block['expire'] >= time()
313			) &&
314			User::instance()->get_permission('Block', $block['index']);
315			}
316			/**
317			* @param string $text
318			*
319			* @return string
			1 ignored issue – show Documentation introduced 2015-11-21 02:31 UTC by Report Bug Copy Issue Report Should the return type not be `array\|string`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. If the return type contains the type array, this check recommends the use of a more specific type like `String[]` or `array<String>`. Loading history...
320			*/
321			protected function ml_process ($text) {
322			return Text::instance()->process(Config::instance()->module('System')->db('texts'), $text, true);
323			}
324			/**
325			* Saving changes and/or showing resulting message of saving changes
326			*
327			* @param bool\|null $result If bool - result will be shown only, otherwise works similar to the $Config->save() and shows resulting message
328			*
329			* @return bool
330			*/
331			function save ($result = null) {
332			$L = Language::instance();
333			$Page = Page::instance();
334			if ($result \|\| ($result === null && Config::instance()->save())) {
335			$this->append_to_title = $L->changes_saved;
336			$Page->success($L->changes_saved);
337			return true;
338			} else {
339			$this->append_to_title = $L->changes_save_error;
340			$Page->warning($L->changes_save_error);
341			return false;
342			}
343			}
344			/**
345			* Applying changes and/or showing resulting message of applying changes
346			*
347			* @param bool\|null\|string $result If bool - result will be shown only, otherwise works similar to the $Config->apply() and shows resulting message
348			*
349			* @return bool
350			*/
351			function apply ($result = null) {
352			$L = Language::instance();
353			$Page = Page::instance();
354			if ($result \|\| ($result === null && Config::instance()->apply())) {
355			$this->append_to_title = $L->changes_applied;
356			$Page->success($L->changes_applied.$L->check_applied);
357			return true;
358			} else {
359			$this->append_to_title = $L->changes_apply_error;
360			$Page->warning($L->changes_apply_error);
361			return false;
362			}
363			}
364			/**
365			* Changes canceling and/or showing result of canceling changes
366			*
367			* @param bool $system If <b>true,/b> - cancels changes of system configuration, otherwise shows message about successful canceling
368			*/
369			function cancel ($system = true) {
370			if ($system) {
371			Config::instance()->cancel();
372			}
373			$L = Language::instance();
374			$this->append_to_title = $L->changes_canceled;
375			Page::instance()->success($L->changes_canceled);
376			}
377			/**
378			* Getter for `controller_path` propertie (no other properties supported currently)
379			*
380			* @param string $property
381			*
382			* @return false\|string\|string[]
			0 ignored issues – show Documentation introduced 2016-01-04 00:56 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `string[]\|false`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
383			*/
384			function __get ($property) {
385			switch ($property) {
386			case 'controller_path';
387			return $this->controller_path;
388			}
389			return false;
390			}
391			/**
392			* Executes plugins processing, blocks and module page generation
393			*
394			* @throws ExitException
395			*/
396			function __finish () {
397			/**
398			* Protection from double calling
399			*/
400			if ($this->called_once) {
401			return;
402			}
403			$this->called_once = true;
404			$Config = Config::instance();
405			$Page = Page::instance();
406			/**
407			* If site is closed
408			*/
409			if (!$Config->core['site_mode']) {
410			if ($this->closed_site($Config)) {
411			status_code(503);
412			return;
413			}
414			/**
415			* Warning about closed site
416			*/
417			$Page->warning(get_core_ml_text('closed_title'));
418			}
419			Event::instance()->fire('System/Index/preload');
420			$this->render_page();
421			Event::instance()->fire('System/Index/postload');
422			}
423			}
424

nazar-pc / CleverStyle-Framework

Push — master ( dd2ca3...b52d57 )

Index::render_title() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like