chillerlan\BBCode\BBCode

Complexity

Total Complexity

43

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	allowTags()	0	13	3
A	setCache()	0	5	1
C	setOptions()	0	55	17
B	parse()	0	40	5
B	parseBBCode()	0	50	10
B	parseAttributes()	0	27	6

<?php
/**
 * Class BBCode
 *
 * @filesource   BBCode.php
 * @created      19.04.2018
 * @package      chillerlan\BBCode
 * @author       smiley <smiley@chillerlan.net>
 * @copyright    2018 smiley
 * @license      MIT
 */

namespace chillerlan\BBCode;

use chillerlan\BBCode\Output\BBCodeOutputInterface;
use chillerlan\Settings\SettingsContainerInterface;
use Psr\Log\{
	LoggerAwareInterface, LoggerAwareTrait, LoggerInterface, NullLogger
};
use Psr\SimpleCache\CacheInterface;

class BBCode implements LoggerAwareInterface{
	use LoggerAwareTrait;

	/**
	 * @var \chillerlan\BBCode\BBCodeOptions|\chillerlan\Settings\SettingsContainerInterface
	 */
	protected $options;

	/**
	 * @var \Psr\SimpleCache\CacheInterface|\chillerlan\BBCode\BBCache
	 */
	protected $cache;

	/**
	 * @var \chillerlan\BBCode\SanitizerInterface
	 */
	protected $sanitizerInterface;

	/**
	 * @var \chillerlan\BBCode\Output\BBCodeOutputInterface
	 */
	protected $outputInterface;

	/**
	 * @var \chillerlan\BBCode\ParserMiddlewareInterface
	 */
	protected $parserMiddleware;

	/**
	 * @var array
	 */
	protected $tags = [];

	/**
	 * @var array
	 */
	protected $noparse = [];

	/**
	 * @var array
	 */
	protected $allowed = [];

	/**
	 * @var int
	 */
	protected $limit;

	/**
	 * BBCode constructor.
	 *
	 * @param \chillerlan\Settings\SettingsContainerInterface|null $options
	 * @param \Psr\SimpleCache\CacheInterface|null                 $cache
	 * @param \Psr\Log\LoggerInterface|null                        $logger
	 */
	public function __construct(SettingsContainerInterface $options = null, CacheInterface $cache = null, LoggerInterface $logger = null){
		$this
			->setCache($cache ?? new BBCache)
			->setLogger($logger ?? new NullLogger);

		$this->setOptions($options ?? new BBCodeOptions);
	}

	/**
	 * @param array $allowedTags
	 *
	 * @return \chillerlan\BBCode\BBCode
	 */
	public function allowTags(array $allowedTags):BBCode{
		$this->allowed = [];

		foreach($allowedTags as $tag){
			$tag = strtolower($tag);

			if(in_array($tag, $this->tags, true)){
				$this->allowed[] = $tag;
			}
		}

		return $this;
	}

	/**
	 * @param \Psr\SimpleCache\CacheInterface $cache
	 *
	 * @return \chillerlan\BBCode\BBCode
	 */
	public function setCache(CacheInterface $cache):BBCode{
		$this->cache = $cache;

		return $this;
	}

	/**
	 * @todo
	 *
	 * @param \chillerlan\Settings\SettingsContainerInterface $options
	 *
	 * @throws \chillerlan\BBCode\BBCodeException
	 * @return \chillerlan\BBCode\BBCode
	 */
	public function setOptions(SettingsContainerInterface $options):BBCode{
		$this->options = $options;

		mb_internal_encoding('UTF-8');

		if(
			ini_set('pcre.backtrack_limit', $this->options->pcre_backtrack_limit) === false

Accessing pcre_backtrack_limit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			|| ini_set('pcre.recursion_limit', $this->options->pcre_recursion_limit) === false

Accessing pcre_recursion_limit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			|| ini_set('pcre.jit', $this->options->pcre_jit) === false

Accessing pcre_jit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		){
			throw new BBCodeException('could not alter ini settings');
		}

		if(ini_get('pcre.backtrack_limit') !== (string)$this->options->pcre_backtrack_limit

Accessing pcre_backtrack_limit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			|| ini_get('pcre.recursion_limit') !== (string)$this->options->pcre_recursion_limit

Accessing pcre_recursion_limit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			|| ini_get('pcre.jit') !== (string)$this->options->pcre_jit

Accessing pcre_jit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		){
			throw new BBCodeException('ini settings differ from options');
		}

		if($this->options->sanitizeInput || $this->options->sanitizeOutput){

Accessing sanitizeInput on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing sanitizeOutput on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$this->sanitizerInterface  = new $this->options->sanitizerInterface($this->options);

Accessing sanitizerInterface on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			if(!$this->sanitizerInterface instanceof SanitizerInterface){
				throw new BBcodeException('invalid SanitizerInterface');
			}
		}

		if($this->options->preParse || $this->options->postParse){

Accessing preParse on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing postParse on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$this->parserMiddleware = new $this->options->parserMiddlewareInterface($this->options, $this->cache, $this->logger);

Accessing parserMiddlewareInterface on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			if(!$this->parserMiddleware instanceof ParserMiddlewareInterface){
				throw new BBcodeException('invalid ParserMiddlewareInterface');
			}
		}

		$this->outputInterface = new $this->options->outputInterface($this->options, $this->cache, $this->logger);

Accessing outputInterface on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		if(!$this->outputInterface instanceof BBCodeOutputInterface){
			throw new BBcodeException('invalid BBCodeOutputInterface');
		}

		$this->tags    = $this->outputInterface->getTags();
		$this->noparse = $this->outputInterface->getNoparse();
		$this->limit   = (int)$this->options->nestingLimit;

Accessing nestingLimit on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		if(is_array($this->options->allowedTags) && !empty($this->options->allowedTags)){

Accessing allowedTags on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$this->allowTags($this->options->allowedTags);

Accessing allowedTags on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		}
		elseif($this->options->allowAvailableTags === true){

Accessing allowAvailableTags on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$this->allowed = $this->tags;
		}

		return $this;
	}

	/**
	 * Transforms a BBCode string to HTML (or whatevs)
	 *
	 * @param string $bbcode
	 *
	 * @return string
	 */
	public function parse(string $bbcode):string{

		// sanitize the input if needed
		if($this->options->sanitizeInput){

Accessing sanitizeInput on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$bbcode = $this->sanitizerInterface->sanitizeInput($bbcode);
		}

		// run the pre-parser
		if($this->options->preParse){

Accessing preParse on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$bbcode = $this->parserMiddleware->pre($bbcode);
		}

		// @todo: array < 2 elements causes a PREG_BACKTRACK_LIMIT_ERROR! (breaks match pattern)
		$singleTags = array_merge(['br', 'hr'], $this->outputInterface->getSingleTags());

		// close singletags: [br] -> [br][/br]
		$bbcode = preg_replace('#\[('.implode('|', $singleTags).')((?:\s|=)[^]]*)?]#is', '[$1$2][/$1]', $bbcode);

		// @todo: find non-singletags without a closing tag and close them (or convert the brackets to entities)

		// protect newlines
		$bbcode = str_replace(["\r", "\n"], ['', $this->options->placeholder_eol], $bbcode);

Accessing placeholder_eol on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		// parse the bbcode
		$bbcode = $this->parseBBCode($bbcode);

		// run the post-parser
		if($this->options->postParse){

Accessing postParse on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$bbcode = $this->parserMiddleware->post($bbcode);
		}

		// replace the newline placeholders
		$bbcode = str_replace($this->options->placeholder_eol, $this->outputInterface->getEOL(), $bbcode);

Accessing placeholder_eol on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		// run the sanitizer/html purifier/whatever as a final step
		if($this->options->sanitizeOutput){

Accessing sanitizeOutput on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$bbcode = $this->sanitizerInterface->sanitizeOutput($bbcode);
		}

		return $bbcode;
	}

	/**
	 * @param $bbcode
	 *
	 * @return string
	 */
	protected function parseBBCode($bbcode):string{
		static $callback_count = 0;

		$callback = false;

		if(is_array($bbcode) && count($bbcode) === 4){
			[$match, $tag, $attributes, $content] = $bbcode;

The variable $match seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $tag seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $attributes seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $content seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

			$tag        = strtolower($tag);

The variable $tag seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

			$attributes = $this->parseAttributes($attributes);

The variable $attributes seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

			$callback   = true;

			$callback_count++;
		}
		else if(is_string($bbcode) && !empty($bbcode)){
			$match      = null;
			$tag        = null;
			$attributes = [];
			$content    = $bbcode;
		}
		else{
			return '';
		}

		if($callback_count < $this->limit && !in_array($tag, $this->noparse , true)){
			$content = preg_replace_callback('#\[(\w+)((?:\s|=)[^]]*)?]((?:[^[]|\[(?!/?\1((?:\s|=)[^]]*)?])|(?R))*)\[/\1]#', __METHOD__, $content);

The variable $content does not seem to be defined for all execution paths leading up to this point.

			$e = preg_last_error();

			/**
			 * 1 - PREG_INTERNAL_ERROR
			 * 2 - PREG_BACKTRACK_LIMIT_ERROR
			 * 3 - PREG_RECURSION_LIMIT_ERROR
			 * 4 - PREG_BAD_UTF8_ERROR
			 * 5 - PREG_BAD_UTF8_OFFSET_ERROR
			 * 6 - PREG_JIT_STACKLIMIT_ERROR
			 */
			if($e !== PREG_NO_ERROR){
				$this->logger->debug('preg_error', ['errno' => $e, '$content' => $content]);

				$content = $match ?? '';//$content ?? $bbcode ??
			}
		}

		if($callback === true && in_array($tag, $this->allowed, true)){
			$content = $this->outputInterface->transform($tag, $attributes, $content, $match, $callback_count);

The variable $match does not seem to be defined for all execution paths leading up to this point.

			$callback_count = 0;
		}

		return $content;
	}

	/**
	 * @param string $attributes
	 *
	 * @return array
	 */
	protected function parseAttributes(string $attributes):array{
		$attr = [];

		if(empty($attributes)){
			return $attr;
		}

		// @todo: fix attributes pattern: accept single and double quotes around the value
		if(preg_match_all('#(?<name>^|[[a-z]+)\=(["\']?)(?<value>[^"\']*?)\2(?: |$)#i', $attributes, $matches, PREG_SET_ORDER) > 0){
#			print_r(['$attributes' => $attributes, '$matches' => $matches]);

			foreach($matches as $attribute){
				$name = empty($attribute['name']) ? $this->options->placeholder_bbtag : strtolower(trim($attribute['name']));

Accessing placeholder_bbtag on the interface chillerlan\Settings\SettingsContainerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

				$attr[$name] = trim($attribute['value'], '"\' ');
			}
		}

		$e = preg_last_error();

		if($e !== PREG_NO_ERROR){
			$this->logger->debug('preg_error', ['errno' => $e, '$attributes' => $attributes]);
			$attr['__error__'] = $attributes;
		}

		return $attr;
	}

}