ElkArte\Exceptions\Exception

Complexity

Total Complexity

20

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Test Coverage

Coverage

75%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
B	logMessage()	0	21	8
A	loadMessage()	0	27	6
A	fatalLangError()	0	3	1
A	parseMessage()	0	16	3

<?php

/**
 * General exception handler. Has support for throwing errors that
 * are specifically targeted at users and even placing multiple messages
 * in one exception.
 *
 * @package   ElkArte Forum
 * @copyright ElkArte Forum contributors
 * @license   BSD http://opensource.org/licenses/BSD-3-Clause (see accompanying LICENSE.txt file)
 *
 * @version 2.0 Beta 1
 *
 */

namespace ElkArte\Exceptions;

use ElkArte\Errors\Errors;

The type ElkArte\Errors\Errors was not found. Maybe you did not declare it correctly or list all dependencies?

use ElkArte\Languages\Txt;
use ElkArte\User;

/**
 * General exception handler aimed at extending the default functionality of PHP exceptions.
 * This class introduces additional features to format and log error messages, load language files,
 * handle custom error messages, and integrate with the ElkArte system.
 */
class Exception extends \Exception
{
	/** @var string[] Values to use in vsprintf. */
	protected $sprintf = [];

	/**
	 * \ElkArte\Exceptions\Exception constructor.
	 * Extended exception rules because we need more stuff
	 *
	 * @param string|string[] $message index of $txt or message
	 *  - If an array is used, then it can specify a custom language template to load.
	 * @param bool|string $log type of error, defines under which "log" is shown.
	 *  - If false is used, the error is not logged.
	 * @param string[] $sprintf optional array of values to use in vsprintf with the $txt
	 * @param int $code
	 * @param Exception|null $previous
	 */
	public function __construct($message, protected $log = false, $sprintf = [], $code = 0, Exception $previous = null)
	{
		$this->sprintf = is_array($sprintf) ? $sprintf : (array) $sprintf;

The condition is_array($sprintf) is always true.

		// Make sure everything is assigned properly, this will route through the exception_handler
		// in the Errors class.
		parent::__construct($this->loadMessage($message), $code, $previous);
	}

	/**
	 * Loads the language file specified in \ElkArte\Exceptions\Exception::parseMessage()
	 * and replaces the index received in the constructor.
	 *
	 * @param string|string[] $message
	 *
	 * @return string The index or the message.
	 */
	protected function loadMessage($message): string
	{
		global $txt;

		if (empty($message))
		{
			Errors::instance()->display_minimal_error('');
		}

		$msg = '';

The assignment to $msg is dead and can be removed.

		$lang = false;

The assignment to $lang is dead and can be removed.

		try
		{
			[$msg, $lang] = $this->parseMessage($message);
			if ($lang !== false)
			{
				Txt::load($lang);
			}
		}
		catch (\Exception)
		{
			Errors::instance()->display_minimal_error($message);
		}

		$this->logMessage($message, $lang);

It seems like $message can also be of type string[]; however, parameter $msg of ElkArte\Exceptions\Exception::logMessage() does only seem to accept string, maybe add an additional type check?

		return isset($txt[$msg]) ? (empty($this->sprintf) ? $txt[$msg] : vsprintf($txt[$msg], $this->sprintf)) : ($msg);
	}

	/**
	 * Cleans up the message param passed to the constructor.
	 *
	 * @param string|string[] $message Can be several different things:
	 * - The index of $txt string
	 * - A plain text message
	 * - An array with the following structure:
	 *   array(
	 *       0 => language to load (use \ElkArte\Languages\Txt::load)
	 *       1 => index of $txt
	 *   )
	 * - A namespaced index in the form:
	 *     - lexicon.index
	 *     - a txt language file followed by a "dot" followed by the "index"
	 *     - e.g., Post.attach_timeout
	 * - "lexicon" is loaded by \ElkArte\Languages\Txt::load.
	 *
	 * @return array
	 */
	protected function parseMessage($message): array
	{
		// Load message with language support
		if (is_array($message))
		{
			return [$message[1], $message[0]];
		}

		if (preg_match('/^(\w+)\.(.+)$/', $message, $matches) !== 0)
		{
			// language.messageIndex
			return [$matches[2], $matches[1]];
		}

		// Simple Error message
		return [$message, 'Errors'];
	}

	/**
	 * Loads the language file specified in \ElkArte\Exceptions\Exception::parseMessage()
	 * and replaces the index received in the constructor.  Logs the message if needed.
	 *
	 * @param string $msg the message to log
	 * @param string $lexicon the language file to load
	 */
	protected function logMessage($msg, $lexicon): void
	{
		global $language, $txt;

		if (empty($msg))
		{
			$this->log = false;
			return;
		}

		// Don't need to reload the language file if both the user and
		// the forum share the same language.
		if (!isset($language) || (isset(User::$info->language) && $language !== User::$info->language))

The property language does not exist on ElkArte\Helper\ValuesContainer. Since you implemented __get, consider adding a @property annotation.

		{
			Txt::load($lexicon, $language);
		}

		if ($this->log !== false)
		{
			$msg = isset($txt[$msg]) ? (empty($this->sprintf) ? $txt[$msg] : vsprintf($txt[$msg], $this->sprintf)) : ($msg);
			Errors::instance()->log_error($msg, $this->log, $this->getFile(), $this->getLine());
		}
	}

	/**
	 * Calls fatal_lang_error and ends the execution of the script.
	 *
	 * @deprecated since 2.0, use Errors::instance()->fatal_lang_error directly
	 */
	public function fatalLangError(): never
	{
		Errors::instance()->fatal_lang_error($this->message, $this->log, $this->sprintf);
	}
}