3 * @copyright Copyright (c) 2014 Carsten Brandt
4 * @license https://github.com/cebe/markdown/blob/master/LICENSE
5 * @link https://github.com/cebe/markdown#readme
8 namespace cebe\markdown;
12 * A generic parser for markdown-like languages.
14 * @author Carsten Brandt <mail@cebe.cc>
19 * @var integer the maximum nesting level for language elements.
21 public $maximumNestingLevel = 32;
24 * @var string the current context the parser is in.
25 * TODO remove in favor of absy
27 protected $context = [];
29 * @var array these are "escapeable" characters. When using one of these prefixed with a
30 * backslash, the character will be outputted without the backslash and is not interpreted
33 protected $escapeCharacters = [
41 * Parses the given text considering the full language.
43 * This includes parsing block elements as well as inline elements.
45 * @param string $text the text to parse
46 * @return string parsed markup
48 public function parse($text)
56 $text = str_replace(["\r\n", "\n\r", "\r"], "\n", $text);
58 $this->prepareMarkers($text);
60 $absy = $this->parseBlocks(explode("\n", $text));
61 $markup = $this->renderAbsy($absy);
68 * Parses a paragraph without block elements (block elements are ignored).
70 * @param string $text the text to parse
71 * @return string parsed markup
73 public function parseParagraph($text)
81 $text = str_replace(["\r\n", "\n\r", "\r"], "\n", $text);
83 $this->prepareMarkers($text);
85 $absy = $this->parseInline($text);
86 $markup = $this->renderAbsy($absy);
93 * This method will be called before `parse()` and `parseParagraph()`.
94 * You can override it to do some initialization work.
96 protected function prepare()
101 * This method will be called after `parse()` and `parseParagraph()`.
102 * You can override it to do cleanup.
104 protected function cleanup()
111 private $_blockTypes;
114 * @return array a list of block element types available.
116 protected function blockTypes()
118 if ($this->_blockTypes === null) {
119 // detect block types via "identify" functions
120 $reflection = new \ReflectionClass($this);
121 $this->_blockTypes = array_filter(array_map(function($method) {
122 $name = $method->getName();
123 return strncmp($name, 'identify', 8) === 0 ? strtolower(substr($name, 8)) : false;
124 }, $reflection->getMethods(ReflectionMethod::IS_PROTECTED)));
126 sort($this->_blockTypes);
128 return $this->_blockTypes;
132 * Given a set of lines and an index of a current line it uses the registed block types to
133 * detect the type of this line.
134 * @param array $lines
135 * @param integer $current
136 * @return string name of the block type in lower case
138 protected function detectLineType($lines, $current)
140 $line = $lines[$current];
141 $blockTypes = $this->blockTypes();
142 foreach($blockTypes as $blockType) {
143 if ($this->{'identify' . $blockType}($line, $lines, $current)) {
151 * Parse block elements by calling `identifyLine()` to identify them
152 * and call consume function afterwards.
153 * The blocks are then rendered by the corresponding rendering methods.
155 protected function parseBlocks($lines)
157 if ($this->_depth >= $this->maximumNestingLevel) {
158 // maximum depth is reached, do not parse input
159 return [['text', implode("\n", $lines)]];
165 $blockTypes = $this->blockTypes();
167 // convert lines to blocks
168 for ($i = 0, $count = count($lines); $i < $count; $i++) {
170 if (!empty($line) && rtrim($line) !== '') { // skip empty lines
171 // identify a blocks beginning
173 foreach($blockTypes as $blockType) {
174 if ($this->{'identify' . $blockType}($line, $lines, $i)) {
175 // call consume method for the detected block type to consume further lines
176 list($block, $i) = $this->{'consume' . $blockType}($lines, $i);
177 if ($block !== false) {
184 // consider the line a normal paragraph
186 list($block, $i) = $this->consumeParagraph($lines, $i);
197 protected function renderAbsy($blocks)
200 foreach ($blocks as $block) {
201 array_unshift($this->context, $block[0]);
202 $output .= $this->{'render' . $block[0]}($block);
203 array_shift($this->context);
209 * Consume lines for a paragraph
215 protected function consumeParagraph($lines, $current)
217 // consume until newline
219 for ($i = $current, $count = count($lines); $i < $count; $i++) {
220 if (ltrim($lines[$i]) !== '') {
221 $content[] = $lines[$i];
228 'content' => $this->parseInline(implode("\n", $content)),
230 return [$block, --$i];
234 * Render a paragraph block
239 protected function renderParagraph($block)
241 return '<p>' . $this->renderAbsy($block['content']) . "</p>\n";
249 * @var array the set of inline markers to use in different contexts.
251 private $_inlineMarkers = [];
254 * Returns a map of inline markers to the corresponding parser methods.
256 * This array defines handler methods for inline markdown markers.
257 * When a marker is found in the text, the handler method is called with the text
258 * starting at the position of the marker.
260 * Note that markers starting with whitespace may slow down the parser,
261 * you may want to use [[renderText]] to deal with them.
263 * You may override this method to define a set of markers and parsing methods.
264 * The default implementation looks for protected methods starting with `parse` that
265 * also have an `@marker` annotation in PHPDoc.
267 * @return array a map of markers to parser methods
269 protected function inlineMarkers()
272 // detect "parse" functions
273 $reflection = new \ReflectionClass($this);
274 foreach($reflection->getMethods(ReflectionMethod::IS_PROTECTED) as $method) {
275 $methodName = $method->getName();
276 if (strncmp($methodName, 'parse', 5) === 0) {
277 preg_match_all('/@marker ([^\s]+)/', $method->getDocComment(), $matches);
278 foreach($matches[1] as $match) {
279 $markers[$match] = $methodName;
287 * Prepare markers that are used in the text to parse
289 * Add all markers that are present in markdown.
290 * Check is done to avoid iterations in parseInline(), good for huge markdown files
291 * @param string $text
293 private function prepareMarkers($text)
295 $this->_inlineMarkers = [];
296 foreach ($this->inlineMarkers() as $marker => $method) {
297 if (strpos($text, $marker) !== false) {
299 // put the longest marker first
300 if (isset($this->_inlineMarkers[$m])) {
301 reset($this->_inlineMarkers[$m]);
302 if (strlen($marker) > strlen(key($this->_inlineMarkers[$m]))) {
303 $this->_inlineMarkers[$m] = array_merge([$marker => $method], $this->_inlineMarkers[$m]);
307 $this->_inlineMarkers[$m][$marker] = $method;
313 * Parses inline elements of the language.
315 * @param string $text the inline text to parse.
318 protected function parseInline($text)
320 if ($this->_depth >= $this->maximumNestingLevel) {
321 // maximum depth is reached, do not parse input
322 return [['text', $text]];
326 $markers = implode('', array_keys($this->_inlineMarkers));
330 while (!empty($markers) && ($found = strpbrk($text, $markers)) !== false) {
332 $pos = strpos($text, $found);
334 // add the text up to next marker to the paragraph
336 $paragraph[] = ['text', substr($text, 0, $pos)];
341 foreach ($this->_inlineMarkers[$text[0]] as $marker => $method) {
342 if (strncmp($text, $marker, strlen($marker)) === 0) {
344 array_unshift($this->context, $method);
345 list($output, $offset) = $this->$method($text);
346 array_shift($this->context);
348 $paragraph[] = $output;
349 $text = substr($text, $offset);
355 $paragraph[] = ['text', substr($text, 0, 1)];
356 $text = substr($text, 1);
360 $paragraph[] = ['text', $text];
368 * Parses escaped special characters.
371 protected function parseEscape($text)
373 if (isset($text[1]) && in_array($text[1], $this->escapeCharacters)) {
374 return [['text', $text[1]], 2];
376 return [['text', $text[0]], 1];
380 * This function renders plain text sections in the markdown text.
381 * It can be used to work on normal text sections for example to highlight keywords or
382 * do special escaping.
384 protected function renderText($block)