Cornford\Alerter\Alert

Complexity

Total Complexity

16

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	2
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	4
A	create()	0	12	3
A	getType()	0	4	1
A	getContent()	0	4	1
A	__get()	0	8	2
A	useView()	0	6	1
A	useViewPath()	0	6	1
A	display()	0	12	3

<?php namespace Cornford\Alerter;

use Cornford\Alerter\Contracts\AlertableInterface;
use Cornford\Alerter\Exceptions\AlertContentException;
use Cornford\Alerter\Exceptions\AlertTypeException;
use Cornford\Alerter\Exceptions\AlertVariableException;
use Illuminate\Support\Facades\Config;

class Alert extends AlertType implements AlertableInterface {

	/**
	 * The content of the alert.
	 *
	 * @var string
	 */
	protected $content;

	/**
	 * The type of the alert.
	 *
	 * @var string
	 */
	protected $type;

	/**
	 * The view of the alert.
	 *
	 * @var string
	 */
	protected $view;

	/**
	 * The path for the alert view.
	 *
	 * @var string
	 */
	protected $viewPath;

	/**
	 * Construct a new alerter instance.
	 *
	 * @param string $type
	 * @param string $content
	 *
	 * @return self

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

	 */
	private function __construct($type, $content)
	{
		$this->type = $type;
		$this->content = $content;

		$viewPath = '';
		$view = '';

		if (class_exists('Config')) {
			$viewPath = Config::get('alerter::path');
			$view = Config::get('alerter::alert');
		}

		$this->viewPath = $viewPath ?: dirname(__FILE__) . DIRECTORY_SEPARATOR . 'Views';
		$this->view = $view ?: AlertDisplay::VIEW_SIMPLE;
	}

	/**
	 * Create a new alerter instance.
	 *
	 * @param string $type
	 * @param string $content
	 *
	 * @return self
	 *
	 * @throws \Cornford\Alerter\Exceptions\AlertContentException
	 * @throws \Cornford\Alerter\Exceptions\AlertTypeException
	 */
	public static function create($type, $content)
	{
		if (empty($type)) {
			throw new AlertTypeException('Unable to create message with invalid type.');
		}

		if (empty($content)) {
			throw new AlertContentException('Unable to create message with invalid content.');
		}

		return new self($type, $content);
	}

	/**
	 * Return the stored alert type.
	 *
	 * @return string
	 */
	public function getType()
	{
		return $this->type;
	}

	/**
	 * Return the stored alert content.
	 *
	 * @return string
	 */
	public function getContent()
	{
		return $this->content;
	}

	/**
	 * Return the stored alert variable if it exists.
	 *
	 * @param string $variable ob
	 *
	 * @return string
	 *
	 * @throws \Cornford\Alerter\Exceptions\AlertVariableException
	 */
	public function __get($variable)
	{
		if (!property_exists($this, $variable)) {
			throw new AlertVariableException('Unable to find variable: ' . $variable . '.');
		}

		return $this->{$variable};
	}

	/**
	 * Set the alert view.
	 *
	 * @param string $view
	 *
	 * @return self
	 */
	public function useView($view)
	{
		$this->view = $view;

		return $this;
	}

	/**
	 * Set the alert view path.
	 *
	 * @param string $path
	 *
	 * @return self
	 */
	public function useViewPath($path)
	{
		$this->viewPath = $path;

		return $this;
	}

	/**
	 * Return a string of alert display HTML for a set display view.
	 *
	 * @param string $view
	 * @param string $viewPath
	 *
	 * @return string
	 */
	public function display($viewPath = null, $view = null)
	{
		if (!$viewPath) {

The expression $viewPath of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

			$viewPath = $this->viewPath;
		}

		if (!$view) {

The expression $view of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

			$view = $this->view;
		}

		return (new AlertDisplay($this, $viewPath, $view))->display();
	}

}