cs\Page

Complexity

Total Complexity

61

Size/Duplication

Total Lines	545
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	6
Bugs	2	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	7	2
A	construct()	0	22	2
A	init()	0	6	1
A	set_theme()	0	4	1
A	content()	0	8	2
A	json()	0	6	1
C	get_template()	0	32	8
C	prepare()	0	92	7
A	get_favicon_path()	0	7	2
A	get_property_with_indentation()	0	3	1
A	replace()	0	8	2
A	process_replacing()	0	7	3
A	link()	0	6	2
A	atom()	0	10	1
A	rss()	0	10	1
A	canonical_url()	0	8	1
A	title()	0	9	2
A	success()	0	3	1
A	notice()	0	3	1
A	warning()	0	3	1
A	top_message()	0	9	1
C	error()	0	48	12
B	__finish()	0	31	6

<?php
/**
 * @package   CleverStyle CMS
 * @author    Nazar Mokrynskyi <nazar@mokrynskyi.com>
 * @copyright Copyright (c) 2011-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs;
use
	h,
	cs\Page\Includes,
	cs\Page\Meta;

class Page {
	use
		Singleton,
		Includes;
	public $Content;
	public $interface   = true;
	public $pre_Html    = '';
	public $Html        = '';
	public $Description = '';
	/**
	 * @var string|string[]
	 */
	public $Title     = [];
	public $Head      = '';
	public $pre_Body  = '';
	public $Left      = '';
	public $Top       = '';
	public $Right     = '';
	public $Bottom    = '';
	public $post_Body = '';
	public $post_Html = '';
	/**
	 * Number of tabs by default for indentation the substitution of values into template
	 *
	 * @var array
	 */
	public $level = [
		'Head'      => 0,
		'pre_Body'  => 1,
		'Left'      => 3,
		'Top'       => 3,
		'Content'   => 4,
		'Bottom'    => 3,
		'Right'     => 3,
		'post_Body' => 1
	];
	/**
	 * @var array[]
	 */
	protected $link = [];
	/**
	 * @var string[]
	 */
	protected $search_replace = [];
	/**
	 * @var false|string
	 */
	protected $canonical_url      = false;
	protected $theme;
	protected $error_showed       = false;
	protected $finish_called_once = false;
	/**
	 * @param string $property
	 *
	 * @return false|null|string
	 */
	function __get ($property) {
		// For internal use by \cs\Meta class
		if ($property === 'canonical_url') {
			return $this->canonical_url;
		}
		return false;
	}
	protected function construct () {
		$Config = Config::instance(true);
		/**
		 * We need Config for initialization
		 */
		if (!$Config) {
			Event::instance()->once(

It seems like once() must be provided by classes using this trait. How about adding it as abstract method to this trait?

				'System/Config/init/after',
				function () {
					$this->init();
				}
			);
		} else {
			$this->init();
		}
		Event::instance()->on(

It seems like on() must be provided by classes using this trait. How about adding it as abstract method to this trait?

			'System/Config/changed',
			function () {
				$this->init();
			}
		);
	}
	/**
	 * Initialization: setting of title and theme according to system configuration
	 *
	 * @return Page
	 */
	protected function init () {
		$Config         = Config::instance();
		$this->Title[0] = htmlentities(get_core_ml_text('name'), ENT_COMPAT, 'utf-8');
		$this->set_theme($Config->core['theme']);
		return $this;
	}
	/**
	 * Theme changing
	 *
	 * @param string $theme
	 *
	 * @return Page
	 */
	function set_theme ($theme) {
		$this->theme = $theme;
		return $this;
	}
	/**
	 * Adding of content on the page
	 *
	 * @param string   $add
	 * @param bool|int $level
	 *
	 * @return Page
	 */
	function content ($add, $level = false) {
		if ($level !== false) {
			$this->Content .= h::level($add, $level);
		} else {
			$this->Content .= $add;
		}
		return $this;
	}
	/**
	 * Sets body with content, that is transformed into JSON format
	 *
	 * @param mixed $add
	 *
	 * @return Page
	 */
	function json ($add) {
		_header('Content-Type: application/json; charset=utf-8', true);
		interface_off();
		$this->Content = _json_encode($add);
		return $this;
	}
	/**
	 * Loading of theme template
	 *
	 * @return bool
	 */
	protected function get_template () {
		/**
		 * Theme is fixed for administration, and may vary for other pages
		 */
		if (admin_path()) {
			$this->theme = 'CleverStyle';
		}
		$theme_dir = THEMES."/$this->theme";
		_include("$theme_dir/prepare.php", false, false);
		ob_start();
		$return = true;
		/**
		 * If website is closed and user is not an administrator - send `503 Service Unavailable` header and show closed site page
		 */
		if (
			!Config::instance()->core['site_mode'] &&
			!User::instance(true)->admin() &&

It seems like admin() must be provided by classes using this trait. How about adding it as abstract method to this trait?

			status_code(503) &&
			!_include("$theme_dir/closed.php", false, false) &&
			!_include("$theme_dir/closed.html", false, false)
		) {
			echo
				"<!doctype html>\n".
				h::title(get_core_ml_text('closed_title')).
				get_core_ml_text('closed_text');
			$return = false;
		} else {
			_include("$theme_dir/index.php", false, false) || _include("$theme_dir/index.html");
		}
		$this->Html = ob_get_clean();
		return $return;
	}
	/**
	 * Processing of template, substituting of content, preparing for the output
	 *
	 * @return Page

Should the return type not be Page|null?

	 */
	protected function prepare () {
		$Config = Config::instance(true);
		/**
		 * Loading of template
		 */
		if (!$this->get_template()) {
			return;
		}
		/**
		 * Forming page title
		 */
		$this->Title = array_filter($this->Title, 'trim');
		$this->Title = $Config->core['title_reverse'] ? array_reverse($this->Title) : $this->Title;
		$this->Title = implode($Config->core['title_delimiter'] ?: '|', $this->Title);
		/**
		 * Forming <head> content
		 */
		$this->Head =
			h::title($this->Title).
			h::meta(
				[
					'charset' => 'utf-8'
				]
			).
			h::meta(
				$this->Description ? [
					'name'    => 'description',
					'content' => $this->Description
				] : false
			).
			h::meta(
				[
					'name'    => 'generator',
					'content' => 'CleverStyle CMS by Mokrynskyi Nazar'
				]
			).
			h::base(
				$Config ? [
					'href' => $Config->base_url().'/'

It seems like base_url() must be provided by classes using this trait. How about adding it as abstract method to this trait?

				] : false
			).
			$this->Head.
			h::link(
				[
					'rel'  => 'shortcut icon',
					'href' => $this->get_favicon_path()
				]
			).
			h::link(array_values($this->link) ?: false);
		/**
		 * Addition of CSS, JavaScript and Web Components includes
		 */
		$this->add_includes_on_page();
		/**
		 * Generation of Open Graph protocol information
		 */
		Meta::instance()->render();

It seems like render() must be provided by classes using this trait. How about adding it as abstract method to this trait?

		/**
		 * Substitution of information into template
		 */
		$this->Html = str_replace(
			[
				'<!--pre_Html-->',
				'<!--head-->',
				'<!--pre_Body-->',
				'<!--left_blocks-->',
				'<!--top_blocks-->',
				'<!--content-->',
				'<!--bottom_blocks-->',
				'<!--right_blocks-->',
				'<!--post_Body-->',
				'<!--post_Html-->'
			],
			_rtrim(
				[
					$this->pre_Html,
					$this->get_property_with_indentation('Head'),
					$this->get_property_with_indentation('pre_Body'),
					$this->get_property_with_indentation('Left'),
					$this->get_property_with_indentation('Top'),
					$this->get_property_with_indentation('Content'),
					$this->get_property_with_indentation('Bottom'),
					$this->get_property_with_indentation('Right'),
					$this->get_property_with_indentation('post_Body'),
					$this->post_Html
				],
				"\t"
			),
			$this->Html
		);
		return $this;
	}
	/**
	 * @return string
	 */
	protected function get_favicon_path () {
		$file = file_exists_with_extension(THEMES."/$this->theme/img/favicon", ['png', 'ico']);
		if ($file) {
			return str_replace(THEMES, 'themes', $file);
		}
		return 'favicon.ico';
	}
	/**
	 * @param string $property
	 *
	 * @return string
	 */
	protected function get_property_with_indentation ($property) {
		return h::level($this->$property, $this->level[$property]);
	}
	/**
	 * Replacing anything in source code of finally generated page
	 *
	 * Parameters may be both simply strings for str_replace() and regular expressions for preg_replace()
	 *
	 * @param string|string[] $search
	 * @param string|string[] $replace
	 *
	 * @return Page
	 */
	function replace ($search, $replace = '') {
		if (is_array($search)) {
			$this->search_replace = $search + $this->search_replace;
		} else {
			$this->search_replace[$search] = $replace;
		}
		return $this;
	}
	/**
	 * Processing of replacing in content
	 *
	 * @param string $content
	 *
	 * @return string
	 */
	protected function process_replacing ($content) {
		foreach ($this->search_replace as $search => $replace) {
			$content = _preg_replace($search, $replace, $content) ?: str_replace($search, $replace, $content);
		}
		$this->search_replace = [];
		return $content;
	}
	/**
	 * Adding links
	 *
	 * @param array $data According to h class syntax
	 *
	 * @return Page
	 */
	function link ($data) {
		if ($data !== false) {
			$this->link[] = $data;
		}
		return $this;
	}
	/**
	 * Simple wrapper of $Page->link() for inserting Atom feed on page
	 *
	 * @param string $href
	 * @param string $title
	 *
	 * @return Page
	 */
	function atom ($href, $title = 'Atom Feed') {
		return $this->link(
			[
				'href'  => $href,
				'title' => $title,
				'rel'   => 'alternate',
				'type'  => 'application/atom+xml'
			]
		);
	}
	/**
	 * Simple wrapper of $Page->link() for inserting RSS feed on page
	 *
	 * @param string $href
	 * @param string $title
	 *
	 * @return Page
	 */
	function rss ($href, $title = 'RSS Feed') {
		return $this->link(
			[
				'href'  => $href,
				'title' => $title,
				'rel'   => 'alternate',
				'type'  => 'application/rss+xml'
			]
		);
	}
	/**
	 * Specify canonical url of current page
	 *
	 * @param string $url
	 *
	 * @return Page
	 */
	function canonical_url ($url) {
		$this->canonical_url         = $url;
		$this->link['canonical_url'] = [
			'href' => $this->canonical_url,
			'rel'  => 'canonical'
		];
		return $this;
	}
	/**
	 * Adding text to the title page
	 *
	 * @param string $title
	 * @param bool   $replace Replace whole title by this
	 *
	 * @return Page
	 */
	function title ($title, $replace = false) {
		$title = htmlentities($title, ENT_COMPAT, 'utf-8');
		if ($replace) {
			$this->Title = [$title];
		} else {
			$this->Title[] = $title;
		}
		return $this;
	}
	/**
	 * Display success message
	 *
	 * @param string $success_text
	 *
	 * @return Page
	 */
	function success ($success_text) {
		return $this->top_message($success_text, 'success');
	}
	/**
	 * Display notice message
	 *
	 * @param string $notice_text
	 *
	 * @return Page
	 */
	function notice ($notice_text) {
		return $this->top_message($notice_text, 'warning');
	}
	/**
	 * Display warning message
	 *
	 * @param string $warning_text
	 *
	 * @return Page
	 */
	function warning ($warning_text) {
		return $this->top_message($warning_text, 'error');
	}
	/**
	 * Generic method for 3 methods above
	 *
	 * @param string $message
	 * @param string $class_ending
	 *
	 * @return Page
	 */
	protected function top_message ($message, $class_ending) {
		$this->Top .= h::div(
			$message,
			[
				'class' => "cs-text-center cs-block-$class_ending cs-text-$class_ending"
			]
		);
		return $this;
	}
	/**
	 * Error pages processing
	 *
	 * @param null|string|string[] $custom_text Custom error text instead of text like "404 Not Found" or array with two elements: [error, error_description]
	 * @param bool                 $json        Force JSON return format
	 * @param int                  $error_code  HTTP status code
	 *
	 * @throws ExitException
	 */
	function error ($custom_text = null, $json = false, $error_code = 500) {
		if ($this->error_showed) {
			return;
		}
		$this->error_showed = true;
		/**
		 * Hack for 403 after sign out in administration
		 */
		if ($error_code == 403 && !api_path() && _getcookie('sign_out')) {
			_header('Location: /', true, 302);
			$this->Content = '';
			throw new ExitException;
		}
		interface_off();
		$status_text       = status_code($error_code);
		$error_description = $status_text;
		if (is_array($custom_text)) {
			list($error_code, $error_description) = $custom_text;
		} elseif ($custom_text) {
			$error_description = $custom_text;
		}
		if ($json || api_path()) {
			if ($json) {
				_header('Content-Type: application/json; charset=utf-8', true);
				interface_off();
			}
			$this->json(
				[
					'error'             => $error_code,
					'error_description' => $error_description
				]
			);
		} else {
			ob_start();
			if (
				!_include(THEMES."/$this->theme/error.html", false, false) &&
				!_include(THEMES."/$this->theme/error.php", false, false)
			) {
				echo
					"<!doctype html>\n".
					h::title(status_code($error_code)).
					$error_description;
			}
			$this->Content = ob_get_clean();
		}
		$this->__finish();
		throw new ExitException;
	}
	/**
	 * Provides next events:
	 *  System/Page/display/before
	 *
	 *  System/Page/display/after
	 *
	 * Page generation
	 */
	function __finish () {
		/**
		 * Protection from double calling
		 */
		if ($this->finish_called_once) {
			return;
		}
		$this->finish_called_once = true;
		/**
		 * For AJAX and API requests only content without page template
		 */
		$api = api_path();
		if ($api || !$this->interface) {
			/**
			 * Processing of replacing in content
			 */
			echo $this->process_replacing($this->Content ?: ($api ? 'null' : ''));
		} else {
			Event::instance()->fire('System/Page/display/before');

It seems like fire() must be provided by classes using this trait. How about adding it as abstract method to this trait?

			/**
			 * Processing of template, substituting of content, preparing for the output
			 */
			$this->prepare();
			/**
			 * Processing of replacing in content
			 */
			$this->Html = $this->process_replacing($this->Html);
			Event::instance()->fire('System/Page/display/after');

It seems like fire() must be provided by classes using this trait. How about adding it as abstract method to this trait?

			echo rtrim($this->Html);
		}
	}
}