HtmlUp::setext() - Code Metrics - Inspection of "Develop" - adhocore/htmlup - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#14)

by Jitendra

created 2018-09-01 03:07 UTC

HtmlUp::setext() A

↳ Parent: HtmlUp

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	5
nc	3
nop	0
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php

/*
 * This file is part of the HTMLUP package.
 *
 * (c) Jitendra Adhikari <[email protected]>
 *     <https://github.com/adhocore>
 *
 * Licensed under MIT license.
 */

namespace Ahc;

/**
 * HtmlUp - A **lightweight** && **fast** `markdown` to HTML Parser.
 *
 * Supports most of the markdown specs except deep nested elements.
 * Check readme.md for the details of its features && limitations.
 *
 * @author    adhocore | Jitendra Adhikari <[email protected]>
 * @copyright (c) 2014 Jitendra Adhikari
 */
class HtmlUp extends BlockElementParser
{
    /**
     * Constructor.
     *
     * @param string $markdown
     * @param int    $indentWidth
     */
    public function __construct($markdown = \null, $indentWidth = 4)
    {
        $this->scan($markdown, $indentWidth);
    }

    protected function scan($markdown, $indentWidth = 4)
    {
        if ('' === \trim($markdown)) {
            return;
        }

        $this->indentLen = $indentWidth == 2 ? 2 : 4;
        $this->indentStr = $indentWidth == 2 ? '  ' : '    ';

        // Normalize whitespaces
        $markdown = \str_replace("\t", $this->indentStr, $markdown);
        $markdown = \str_replace(["\r\n", "\r"], "\n", $markdown);

        $this->lines = \array_merge([''], \explode("\n", $markdown), ['']);
    }

    public function __toString()
    {
        return $this->parse();
    }

    /**
     * Parse markdown.
     *
     * @param string $markdown
     * @param int    $indentWidth
     *
     * @return string
     */
    public function parse($markdown = \null, $indentWidth = 4)
    {
        if (\null !== $markdown) {
            $this->reset(\true);

            $this->scan($markdown, $indentWidth);
        }

        if (empty($this->lines)) {
            return '';
        }

        $this->parseBlockElements();

        return (new SpanElementParser)->parse($this->markup);
    }

    protected function parseBlockElements()
    {
        while (isset($this->lines[++$this->pointer])) {
            $this->init();

            if ($this->flush() || $this->raw()) {
                continue;
            }

            $this->quote();

            if (($block = $this->isBlock()) || $this->inList) {
                $this->markup .= $block ? '' : $this->trimmedLine;

                continue;
            }

            $this->table() || $this->paragraph();
        }
    }

    protected function isBlock()
    {
        return $this->atx() || $this->setext() || $this->code() || $this->rule() || $this->listt();
    }

    protected function init()
    {
        list($this->prevLine, $this->trimmedPrevLine) = [$this->line, $this->trimmedLine];

        $this->line        = $this->lines[$this->pointer];
        $this->trimmedLine = \trim($this->line);

        $this->indent   = \strlen($this->line) - \strlen(\ltrim($this->line));
        $this->nextLine = isset($this->lines[$this->pointer + 1])
            ? $this->lines[$this->pointer + 1]
            : '';
        $this->trimmedNextLine = \trim($this->nextLine);
        $this->nextIndent      = \strlen($this->nextLine) - \strlen(\ltrim($this->nextLine));
    }

    protected function reset($all = \false)
    {
        $except = $all ? [] : \array_flip(['lines', 'pointer', 'markup', 'indentStr', 'indentLen']);

        // Reset all current values.
        foreach (\get_class_vars(__CLASS__) as $prop => $value) {
            isset($except[$prop]) || $this->{$prop} = $value;
        }
    }

    protected function flush()
    {
        if ('' !== $this->trimmedLine) {
            return \false;
        }

        while (!empty($this->stackList)) {
            $this->markup .= \array_pop($this->stackList);
        }

        while (!empty($this->stackBlock)) {
            $this->markup .= \array_pop($this->stackBlock);
        }

        while (!empty($this->stackTable)) {
            $this->markup .= \array_pop($this->stackTable);
        }

        $this->markup .= "\n";

        $this->reset(\false);

        return \true;
    }

    protected function raw()
    {
        if ($this->inHtml || \preg_match(static::RE_RAW, $this->trimmedLine)) {
            $this->markup .= "\n$this->line";
            if (!$this->inHtml && empty($this->lines[$this->pointer - 1])) {
                $this->inHtml = \true;
            }

            return \true;
        }
    }

    protected function quote()
    {
        if (\preg_match(static::RE_MD_QUOTE, $this->line, $quoteMatch)) {
            $this->line        = \substr($this->line, \strlen($quoteMatch[0]));
            $this->trimmedLine = \trim($this->line);

            if (!$this->inQuote || $this->quoteLevel < \strlen($quoteMatch[1])) {
                $this->markup .= "\n<blockquote>";

                $this->stackBlock[] = "\n</blockquote>";

                $this->quoteLevel++;
            }

            return $this->inQuote = \true;
        }
    }

    protected function atx()
    {
        if (isset($this->trimmedLine[0]) && $this->trimmedLine[0] === '#') {
            $level = \strlen($this->trimmedLine) - \strlen(\ltrim($this->trimmedLine, '#'));

            if ($level < 7) {
                $this->markup .= "\n<h{$level}>" . \ltrim(\ltrim($this->trimmedLine, '# ')) . "</h{$level}>";

                return \true;
            }
        }
    }

    protected function setext()
    {
        if (\preg_match(static::RE_MD_SETEXT, $this->nextLine)) {
            $level = \trim($this->nextLine, '- ') === '' ? 2 : 1;

            $this->markup .= "\n<h{$level}>{$this->trimmedLine}</h{$level}>";

            $this->pointer++;

            return \true;
        }
    }

    protected function code()
    {
        $isShifted = ($this->indent - $this->nextIndent) >= $this->indentLen;
        $codeBlock = \preg_match(static::RE_MD_CODE, $this->line, $codeMatch);

        if ($codeBlock || (!$this->inList && !$this->inQuote && $isShifted)) {
            $lang = isset($codeMatch[1])
                ? ' class="language-' . $codeMatch[1] . '"'
                : '';

            $this->markup .= "\n<pre><code{$lang}>";

            if (!$codeBlock) {
                $this->markup .= $this->escape(\substr($this->line, $this->indentLen));
            }

            $this->codeInternal($codeBlock);

            $this->pointer++;

            $this->markup .= '</code></pre>';

            return \true;
        }
    }

    protected function rule()
    {
        if ($this->trimmedPrevLine === ''
            && \preg_match(static::RE_MD_RULE, $this->trimmedLine)
        ) {
            $this->markup .= "\n<hr />";

            return \true;
        }
    }

    protected function listt()
    {
        $isUl = \in_array(\substr($this->trimmedLine, 0, 2), ['- ', '* ', '+ ']);

        if ($isUl || \preg_match(static::RE_MD_OL, $this->trimmedLine)) {
            $wrapper = $isUl ? 'ul' : 'ol';

            if (!$this->inList) {
                $this->stackList[] = "</$wrapper>";
                $this->markup .= "\n<$wrapper>\n";
                $this->inList      = \true;

                $this->listLevel++;
            }

            $this->markup .= '<li>' . \ltrim($this->trimmedLine, '+-*0123456789. ');

            $this->listInternal();

            return \true;
        }
    }

    protected function table()
    {
        static $headerCount = 0;

        if (!$this->inTable) {
            $headerCount = \substr_count(\trim($this->trimmedLine, '|'), '|');

            return $this->tableInternal($headerCount);
        }

        $this->markup .= "<tr>\n";

        foreach (\explode('|', \trim($this->trimmedLine, '|')) as $i => $col) {
            if ($i > $headerCount) {
                break;
            }

            $col           = \trim($col);
            $this->markup .= "<td>{$col}</td>\n";
        }

        $this->markup .= "</tr>\n";

        if (empty($this->trimmedNextLine)
            || !\substr_count(\trim($this->trimmedNextLine, '|'), '|')
        ) {
            $headerCount        = 0;
            $this->inTable      = \false;
            $this->stackTable[] = "</tbody>\n</table>";
        }

        return \true;
    }

    protected function paragraph()
    {
        $this->markup .= $this->inPara ? "\n<br />" : "\n<p>";
        $this->markup .= $this->trimmedLine;

        if (empty($this->trimmedNextLine)) {
            $this->markup .= '</p>';
            $this->inPara = \false;
        } else {
            $this->inPara = \true;
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the HTMLUP package.
5			*
6			* (c) Jitendra Adhikari <[email protected]>
7			* <https://github.com/adhocore>
8			*
9			* Licensed under MIT license.
10			*/
11
12			namespace Ahc;
13
14			/**
15			* HtmlUp - A lightweight && fast `markdown` to HTML Parser.
16			*
17			* Supports most of the markdown specs except deep nested elements.
18			* Check readme.md for the details of its features && limitations.
19			*
20			* @author adhocore \| Jitendra Adhikari <[email protected]>
21			* @copyright (c) 2014 Jitendra Adhikari
22			*/
23			class HtmlUp extends BlockElementParser
24			{
25			/**
26			* Constructor.
27			*
28			* @param string $markdown
29			* @param int $indentWidth
30			*/
31			public function __construct($markdown = \null, $indentWidth = 4)
32			{
33			$this->scan($markdown, $indentWidth);
34			}
35
36			protected function scan($markdown, $indentWidth = 4)
37			{
38			if ('' === \trim($markdown)) {
39			return;
40			}
41
42			$this->indentLen = $indentWidth == 2 ? 2 : 4;
43			$this->indentStr = $indentWidth == 2 ? ' ' : ' ';
44
45			// Normalize whitespaces
46			$markdown = \str_replace("\t", $this->indentStr, $markdown);
47			$markdown = \str_replace(["\r\n", "\r"], "\n", $markdown);
48
49			$this->lines = \array_merge([''], \explode("\n", $markdown), ['']);
50			}
51
52			public function __toString()
53			{
54			return $this->parse();
55			}
56
57			/**
58			* Parse markdown.
59			*
60			* @param string $markdown
61			* @param int $indentWidth
62			*
63			* @return string
64			*/
65			public function parse($markdown = \null, $indentWidth = 4)
66			{
67			if (\null !== $markdown) {
68			$this->reset(\true);
69
70			$this->scan($markdown, $indentWidth);
71			}
72
73			if (empty($this->lines)) {
74			return '';
75			}
76
77			$this->parseBlockElements();
78
79			return (new SpanElementParser)->parse($this->markup);
80			}
81
82			protected function parseBlockElements()
83			{
84			while (isset($this->lines[++$this->pointer])) {
85			$this->init();
86
87			if ($this->flush() \|\| $this->raw()) {
88			continue;
89			}
90
91			$this->quote();
92
93			if (($block = $this->isBlock()) \|\| $this->inList) {
94			$this->markup .= $block ? '' : $this->trimmedLine;
95
96			continue;
97			}
98
99			$this->table() \|\| $this->paragraph();
100			}
101			}
102
103			protected function isBlock()
104			{
105			return $this->atx() \|\| $this->setext() \|\| $this->code() \|\| $this->rule() \|\| $this->listt();
106			}
107
108			protected function init()
109			{
110			list($this->prevLine, $this->trimmedPrevLine) = [$this->line, $this->trimmedLine];
111
112			$this->line = $this->lines[$this->pointer];
113			$this->trimmedLine = \trim($this->line);
114
115			$this->indent = \strlen($this->line) - \strlen(\ltrim($this->line));
116			$this->nextLine = isset($this->lines[$this->pointer + 1])
117			? $this->lines[$this->pointer + 1]
118			: '';
119			$this->trimmedNextLine = \trim($this->nextLine);
120			$this->nextIndent = \strlen($this->nextLine) - \strlen(\ltrim($this->nextLine));
121			}
122
123			protected function reset($all = \false)
124			{
125			$except = $all ? [] : \array_flip(['lines', 'pointer', 'markup', 'indentStr', 'indentLen']);
126
127			// Reset all current values.
128			foreach (\get_class_vars(__CLASS__) as $prop => $value) {
129			isset($except[$prop]) \|\| $this->{$prop} = $value;
130			}
131			}
132
133			protected function flush()
134			{
135			if ('' !== $this->trimmedLine) {
136			return \false;
137			}
138
139			while (!empty($this->stackList)) {
140			$this->markup .= \array_pop($this->stackList);
141			}
142
143			while (!empty($this->stackBlock)) {
144			$this->markup .= \array_pop($this->stackBlock);
145			}
146
147			while (!empty($this->stackTable)) {
148			$this->markup .= \array_pop($this->stackTable);
149			}
150
151			$this->markup .= "\n";
152
153			$this->reset(\false);
154
155			return \true;
156			}
157
158			protected function raw()
159			{
160			if ($this->inHtml \|\| \preg_match(static::RE_RAW, $this->trimmedLine)) {
161			$this->markup .= "\n$this->line";
162			if (!$this->inHtml && empty($this->lines[$this->pointer - 1])) {
163			$this->inHtml = \true;
164			}
165
166			return \true;
167			}
168			}
169
170			protected function quote()
171			{
172			if (\preg_match(static::RE_MD_QUOTE, $this->line, $quoteMatch)) {
173			$this->line = \substr($this->line, \strlen($quoteMatch[0]));
174			$this->trimmedLine = \trim($this->line);
175
176			if (!$this->inQuote \|\| $this->quoteLevel < \strlen($quoteMatch[1])) {
177			$this->markup .= "\n<blockquote>";
178
179			$this->stackBlock[] = "\n</blockquote>";
180
181			$this->quoteLevel++;
182			}
183
184			return $this->inQuote = \true;
185			}
186			}
187
188			protected function atx()
189			{
190			if (isset($this->trimmedLine[0]) && $this->trimmedLine[0] === '#') {
191			$level = \strlen($this->trimmedLine) - \strlen(\ltrim($this->trimmedLine, '#'));
192
193			if ($level < 7) {
194			$this->markup .= "\n<h{$level}>" . \ltrim(\ltrim($this->trimmedLine, '# ')) . "</h{$level}>";
195
196			return \true;
197			}
198			}
199			}
200
201			protected function setext()
202			{
203			if (\preg_match(static::RE_MD_SETEXT, $this->nextLine)) {
204			$level = \trim($this->nextLine, '- ') === '' ? 2 : 1;
205
206			$this->markup .= "\n<h{$level}>{$this->trimmedLine}</h{$level}>";
207
208			$this->pointer++;
209
210			return \true;
211			}
212			}
213
214			protected function code()
215			{
216			$isShifted = ($this->indent - $this->nextIndent) >= $this->indentLen;
217			$codeBlock = \preg_match(static::RE_MD_CODE, $this->line, $codeMatch);
218
219			if ($codeBlock \|\| (!$this->inList && !$this->inQuote && $isShifted)) {
220			$lang = isset($codeMatch[1])
221			? ' class="language-' . $codeMatch[1] . '"'
222			: '';
223
224			$this->markup .= "\n<pre><code{$lang}>";
225
226			if (!$codeBlock) {
227			$this->markup .= $this->escape(\substr($this->line, $this->indentLen));
228			}
229
230			$this->codeInternal($codeBlock);
231
232			$this->pointer++;
233
234			$this->markup .= '</code></pre>';
235
236			return \true;
237			}
238			}
239
240			protected function rule()
241			{
242			if ($this->trimmedPrevLine === ''
243			&& \preg_match(static::RE_MD_RULE, $this->trimmedLine)
244			) {
245			$this->markup .= "\n<hr />";
246
247			return \true;
248			}
249			}
250
251			protected function listt()
252			{
253			$isUl = \in_array(\substr($this->trimmedLine, 0, 2), ['- ', '* ', '+ ']);
254
255			if ($isUl \|\| \preg_match(static::RE_MD_OL, $this->trimmedLine)) {
256			$wrapper = $isUl ? 'ul' : 'ol';
257
258			if (!$this->inList) {
259			$this->stackList[] = "</$wrapper>";
260			$this->markup .= "\n<$wrapper>\n";
261			$this->inList = \true;
262
263			$this->listLevel++;
264			}
265
266			$this->markup .= '<li>' . \ltrim($this->trimmedLine, '+-*0123456789. ');
267
268			$this->listInternal();
269
270			return \true;
271			}
272			}
273
274			protected function table()
275			{
276			static $headerCount = 0;
277
278			if (!$this->inTable) {
279			$headerCount = \substr_count(\trim($this->trimmedLine, '\|'), '\|');
280
281			return $this->tableInternal($headerCount);
282			}
283
284			$this->markup .= "<tr>\n";
285
286			foreach (\explode('\|', \trim($this->trimmedLine, '\|')) as $i => $col) {
287			if ($i > $headerCount) {
288			break;
289			}
290
291			$col = \trim($col);
292			$this->markup .= "<td>{$col}</td>\n";
293			}
294
295			$this->markup .= "</tr>\n";
296
297			if (empty($this->trimmedNextLine)
298			\|\| !\substr_count(\trim($this->trimmedNextLine, '\|'), '\|')
299			) {
300			$headerCount = 0;
301			$this->inTable = \false;
302			$this->stackTable[] = "</tbody>\n</table>";
303			}
304
305			return \true;
306			}
307
308			protected function paragraph()
309			{
310			$this->markup .= $this->inPara ? "\n<br />" : "\n<p>";
311			$this->markup .= $this->trimmedLine;
312
313			if (empty($this->trimmedNextLine)) {
314			$this->markup .= '</p>';
315			$this->inPara = \false;
316			} else {
317			$this->inPara = \true;
318			}
319			}
320			}
321

adhocore / htmlup

Pull Request — master (#14)

HtmlUp::setext() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like