s9e\TextFormatter\Plugins\Litedown\Parser

Complexity

Total Complexity

43

Size/Duplication

Total Lines	421
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
B	parse()	0	24	1
A	addImageTag()	0	9	1
A	addLinkTag()	0	14	2
B	decode()	0	23	4
A	encode()	0	12	1
A	getLabels()	0	16	2
A	init()	0	21	3
A	matchImages()	0	16	4
A	matchInlineImages()	0	19	2
B	matchReferenceImages()	0	29	4
A	matchInlineLinks()	0	18	2
B	matchLinkReferences()	0	26	4
A	matchLinks()	0	11	3
B	matchReferenceLinks()	0	24	5
A	overwrite()	0	7	2
A	setLinkAttributes()	0	17	3

<?php

/**
* @package   s9e\TextFormatter
* @copyright Copyright (c) 2010-2017 The s9e Authors
* @license   http://www.opensource.org/licenses/mit-license.php The MIT License
*/
namespace s9e\TextFormatter\Plugins\Litedown;

use s9e\TextFormatter\Parser\Tag;
use s9e\TextFormatter\Plugins\Litedown\Parser\Blocks;
use s9e\TextFormatter\Plugins\Litedown\Parser\Emphasis;
use s9e\TextFormatter\Plugins\Litedown\Parser\ForcedLineBreaks;
use s9e\TextFormatter\Plugins\Litedown\Parser\InlineCode;
use s9e\TextFormatter\Plugins\Litedown\Parser\Strikethrough;
use s9e\TextFormatter\Plugins\Litedown\Parser\Superscript;
use s9e\TextFormatter\Plugins\ParserBase;

class Parser extends ParserBase
{
	/**
	* @var bool Whether current text contains escape characters
	*/
	protected $hasEscapedChars;

	/**
	* @var bool Whether current text contains references
	*/
	protected $hasRefs;

	/**
	* @var array Array of [label => link info]
	*/
	protected $refs;

	/**
	* @var string Text being parsed
	*/
	protected $text;

	/**
	* {@inheritdoc}
	*/
	public function parse($text, array $matches)
	{
		$this->init($text);

		// Match block-level markup as well as forced line breaks
		$this->text = (new Blocks($this->parser))->parse($this->text);

		// Capture link references after block markup as been overwritten
		$this->matchLinkReferences();

		// Inline code must be done first to avoid false positives in other inline markup
		$this->text = (new InlineCode($this->parser))->parse($this->text);

		// Do the rest of inline markup. Images must be matched before links
		$this->matchImages();
		$this->matchLinks();
		(new Strikethrough($this->parser))->parse($this->text);
		(new Superscript($this->parser))->parse($this->text);
		(new Emphasis($this->parser))->parse($this->text);
		(new ForcedLineBreaks($this->parser))->parse($this->text);

		// Unset the text to free its memory
		unset($this->text);
	}

	/**
	* Add an image tag for given text span
	*
	* @param  integer $startTagPos Start tag position
	* @param  integer $endTagPos   End tag position
	* @param  integer $endTagLen   End tag length
	* @param  string  $linkInfo    URL optionally followed by space and a title
	* @param  string  $alt         Value for the alt attribute
	* @return void
	*/
	protected function addImageTag($startTagPos, $endTagPos, $endTagLen, $linkInfo, $alt)
	{
		$tag = $this->parser->addTagPair('IMG', $startTagPos, 2, $endTagPos, $endTagLen);
		$this->setLinkAttributes($tag, $linkInfo, 'src');
		$tag->setAttribute('alt', $this->decode($alt));

		// Overwrite the markup
		$this->overwrite($startTagPos, $endTagPos + $endTagLen - $startTagPos);
	}

	/**
	* Add an image tag for given text span
	*
	* @param  integer $startTagPos Start tag position
	* @param  integer $endTagPos   End tag position
	* @param  integer $endTagLen   End tag length
	* @param  string  $linkInfo    URL optionally followed by space and a title
	* @return void
	*/
	protected function addLinkTag($startTagPos, $endTagPos, $endTagLen, $linkInfo)
	{
		// Give the link a slightly worse priority if this is a implicit reference and a slightly
		// better priority if it's an explicit reference or an inline link or to give it precedence
		// over possible BBCodes such as [b](https://en.wikipedia.org/wiki/B)
		$priority = ($endTagLen === 1) ? 1 : -1;

		$tag = $this->parser->addTagPair('URL', $startTagPos, 1, $endTagPos, $endTagLen, $priority);
		$this->setLinkAttributes($tag, $linkInfo, 'url');

		// Overwrite the markup without touching the link's text
		$this->overwrite($startTagPos, 1);
		$this->overwrite($endTagPos,   $endTagLen);
	}

	/**
	* Decode a chunk of encoded text to be used as an attribute value
	*
	* Decodes escaped literals and removes slashes and 0x1A characters
	*
	* @param  string $str Encoded text
	* @return string      Decoded text
	*/
	protected function decode($str)
	{
		if ($this->config['decodeHtmlEntities'] && strpos($str, '&') !== false)
		{
			$str = html_entity_decode($str, ENT_QUOTES, 'UTF-8');
		}
		$str = str_replace("\x1A", '', $str);

		if ($this->hasEscapedChars)
		{
			$str = strtr(
				$str,
				[
					"\x1B0" => '!', "\x1B1" => '"', "\x1B2" => "'", "\x1B3" => '(',
					"\x1B4" => ')', "\x1B5" => '*', "\x1B6" => '[', "\x1B7" => '\\',
					"\x1B8" => ']', "\x1B9" => '^', "\x1BA" => '_', "\x1BB" => '`',
					"\x1BC" => '~'
				]
			);
		}

		return $str;
	}

	/**
	* Encode escaped literals that have a special meaning
	*
	* @param  string $str Original text
	* @return string      Encoded text
	*/
	protected function encode($str)
	{
		return strtr(
			$str,
			[
				'\\!' => "\x1B0", '\\"' => "\x1B1", "\\'" => "\x1B2", '\\('  => "\x1B3",
				'\\)' => "\x1B4", '\\*' => "\x1B5", '\\[' => "\x1B6", '\\\\' => "\x1B7",
				'\\]' => "\x1B8", '\\^' => "\x1B9", '\\_' => "\x1BA", '\\`'  => "\x1BB",
				'\\~' => "\x1BC"
			]
		);
	}

	/**
	* Capture and return labels used in current text
	*
	* @return array Labels' text position as keys, lowercased text content as values
	*/
	protected function getLabels()
	{
		preg_match_all(
			'/\\[((?:[^\\x17[\\]]|\\[[^\\x17[\\]]*\\])*)\\]/',
			$this->text,
			$matches,
			PREG_OFFSET_CAPTURE
		);
		$labels = [];
		foreach ($matches[1] as $m)
		{
			$labels[$m[1] - 1] = strtolower($m[0]);
		}

		return $labels;
	}

	/**
	* Initialize this parser with given text
	*
	* @param  string $text Text to be parsed
	* @return void
	*/
	protected function init($text)
	{
		if (strpos($text, '\\') === false || !preg_match('/\\\\[!"\'()*[\\\\\\]^_`~]/', $text))
		{
			$this->hasEscapedChars = false;
		}
		else
		{
			$this->hasEscapedChars = true;

			// Encode escaped literals that have a special meaning otherwise, so that we don't have
			// to take them into account in regexps
			$text = $this->encode($text);
		}

		// We append a couple of lines and a non-whitespace character at the end of the text in
		// order to trigger the closure of all open blocks such as quotes and lists
		$text .= "\n\n\x17";

		$this->text = $text;
	}

	/**
	* Match images markup
	*
	* @return void
	*/
	protected function matchImages()
	{
		$pos = strpos($this->text, '![');
		if ($pos === false)
		{
			return;
		}
		if (strpos($this->text, '](', $pos) !== false)
		{
			$this->matchInlineImages();
		}
		if ($this->hasRefs)
		{
			$this->matchReferenceImages();
		}
	}

	/**
	* Match inline images markup
	*
	* @return void
	*/
	protected function matchInlineImages()
	{
		preg_match_all(
			'/!\\[(?:[^\\x17[\\]]|\\[[^\\x17[\\]]*\\])*\\]\\(( *(?:[^\\x17\\s()]|\\([^\\x17\\s()]*\\))*(?=[ )]) *(?:"[^\\x17]*?"|\'[^\\x17]*?\'|\\([^\\x17)]*\\))? *)\\)/',
			$this->text,
			$matches,
			PREG_OFFSET_CAPTURE | PREG_SET_ORDER
		);
		foreach ($matches as $m)
		{
			$linkInfo    = $m[1][0];
			$startTagPos = $m[0][1];
			$endTagLen   = 3 + strlen($linkInfo);
			$endTagPos   = $startTagPos + strlen($m[0][0]) - $endTagLen;
			$alt         = substr($m[0][0], 2, strlen($m[0][0]) - $endTagLen - 2);

			$this->addImageTag($startTagPos, $endTagPos, $endTagLen, $linkInfo, $alt);
		}
	}

	/**
	* Match reference images markup
	*
	* @return void
	*/
	protected function matchReferenceImages()
	{
		preg_match_all(
			'/!\\[((?:[^\\x17[\\]]|\\[[^\\x17[\\]]*\\])*)\\](?: ?\\[([^\\x17[\\]]+)\\])?/',
			$this->text,
			$matches,
			PREG_OFFSET_CAPTURE | PREG_SET_ORDER
		);
		foreach ($matches as $m)
		{
			$startTagPos = $m[0][1];
			$endTagPos   = $startTagPos + 2 + strlen($m[1][0]);
			$endTagLen   = 1;
			$alt         = $m[1][0];
			$id          = $alt;

			if (isset($m[2][0], $this->refs[$m[2][0]]))
			{
				$endTagLen = strlen($m[0][0]) - strlen($alt) - 2;
				$id        = $m[2][0];
			}
			elseif (!isset($this->refs[$id]))
			{
				continue;
			}

			$this->addImageTag($startTagPos, $endTagPos, $endTagLen, $this->refs[$id], $alt);
		}
	}

	/**
	* Match inline links markup
	*
	* @return void
	*/
	protected function matchInlineLinks()
	{
		preg_match_all(
			'/\\[(?:[^\\x17[\\]]|\\[[^\\x17[\\]]*\\])*\\]\\(( *(?:[^\\x17\\s()]|\\([^\\x17\\s()]*\\))*(?=[ )]) *(?:"[^\\x17]*?"|\'[^\\x17]*?\'|\\([^\\x17)]*\\))? *)\\)/',
			$this->text,
			$matches,
			PREG_OFFSET_CAPTURE | PREG_SET_ORDER
		);
		foreach ($matches as $m)
		{
			$linkInfo    = $m[1][0];
			$startTagPos = $m[0][1];
			$endTagLen   = 3 + strlen($linkInfo);
			$endTagPos   = $startTagPos + strlen($m[0][0]) - $endTagLen;

			$this->addLinkTag($startTagPos, $endTagPos, $endTagLen, $linkInfo);
		}
	}

	/**
	* Capture link reference definitions in current text
	*
	* @return void
	*/
	protected function matchLinkReferences()
	{
		$this->hasRefs = false;
		$this->refs    = [];
		if (strpos($this->text, ']:') === false)
		{
			return;
		}

		$regexp = '/^\\x1A* {0,3}\\[([^\\x17\\]]+)\\]: *([^\\s\\x17]+ *(?:"[^\\x17]*?"|\'[^\\x17]*?\'|\\([^\\x17)]*\\))?)[^\\x17\\n]*\\n?/m';
		preg_match_all($regexp, $this->text, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
		foreach ($matches as $m)
		{
			$this->parser->addIgnoreTag($m[0][1], strlen($m[0][0]), -2);

			// Ignore the reference if it already exists
			$id = strtolower($m[1][0]);
			if (isset($this->refs[$id]))
			{
				continue;
			}

			$this->hasRefs   = true;
			$this->refs[$id] = $m[2][0];
		}
	}

	/**
	* Match inline and reference links
	*
	* @return void
	*/
	protected function matchLinks()
	{
		if (strpos($this->text, '](') !== false)
		{
			$this->matchInlineLinks();
		}
		if ($this->hasRefs)
		{
			$this->matchReferenceLinks();
		}
	}

	/**
	* Match reference links markup
	*
	* @return void
	*/
	protected function matchReferenceLinks()
	{
		$labels = $this->getLabels();
		foreach ($labels as $startTagPos => $id)
		{
			$labelPos  = $startTagPos + 2 + strlen($id);
			$endTagPos = $labelPos - 1;
			$endTagLen = 1;

			if ($this->text[$labelPos] === ' ')
			{
				++$labelPos;
			}
			if (isset($labels[$labelPos], $this->refs[$labels[$labelPos]]))
			{
				$id        = $labels[$labelPos];
				$endTagLen = $labelPos + 2 + strlen($id) - $endTagPos;
			}
			if (isset($this->refs[$id]))
			{
				$this->addLinkTag($startTagPos, $endTagPos, $endTagLen, $this->refs[$id]);
			}
		}
	}

	/**
	* Overwrite part of the text with substitution characters ^Z (0x1A)
	*
	* @param  integer $pos Start of the range
	* @param  integer $len Length of text to overwrite
	* @return void
	*/
	protected function overwrite($pos, $len)
	{
		if ($len > 0)
		{
			$this->text = substr($this->text, 0, $pos) . str_repeat("\x1A", $len) . substr($this->text, $pos + $len);
		}
	}

	/**
	* Set a URL or IMG tag's attributes
	*
	* @param  Tag    $tag      URL or IMG tag
	* @param  string $linkInfo Link's info: an URL optionally followed by spaces and a title
	* @param  string $attrName Name of the URL attribute
	* @return void
	*/
	protected function setLinkAttributes(Tag $tag, $linkInfo, $attrName)
	{
		$url   = trim($linkInfo);
		$title = '';
		$pos   = strpos($url, ' ');
		if ($pos !== false)
		{
			$title = substr(trim(substr($url, $pos)), 1, -1);
			$url   = substr($url, 0, $pos);
		}

		$tag->setAttribute($attrName, $this->decode($url));
		if ($title > '')
		{
			$tag->setAttribute('title', $this->decode($title));
		}
	}
}