$1'; + // $QuoteLayout = '
$1'; // Check for [quote] text $Text = preg_replace("/\[quote\](.*?)\[\/quote\]/is",">$1\n\n", $Text); $Text = preg_replace("/\[quote=(.*?)\](.*?)\[\/quote\]/is",">$2\n\n", $Text); - + // Images // html5 video and audio @@ -216,7 +228,7 @@ function bb2diaspora($Text,$preserve_nl = false) { $Text = preg_replace("/\[audio\](.*?)\[\/audio\]/", '$1', $Text); // $Text = preg_replace("/\[iframe\](.*?)\[\/iframe\]/", '', $Text); - + // [img=widthxheight]image source[/img] // $Text = preg_replace("/\[img\=([0-9]*)x([0-9]*)\](.*?)\[\/img\]/", '
- asdf
- asdf
- asdf
- `, know that this might fail and create a snapshot of our current parser
+ we keep on parsing and when we reach `
- ` we gotta rollback and keep this
+ list in HTML format.
diff --git a/include/markdownify/example.php b/include/markdownify/example.php
new file mode 100644
index 0000000000..ef86dca83c
--- /dev/null
+++ b/include/markdownify/example.php
@@ -0,0 +1,51 @@
+parseString($_POST['input']);
+ } else {
+ $_POST['input'] = '';
+ }
+?>
+
+
+
+
HTML to Markdown Converter + + + + + +BACK
+ + + + \ No newline at end of file diff --git a/include/markdownify/markdownify.php b/include/markdownify/markdownify.php new file mode 100644 index 0000000000..43730cb77f --- /dev/null +++ b/include/markdownify/markdownify.php @@ -0,0 +1,1184 @@ +,+ */ + var $notConverted = array(); + /** + * skip conversion to markdown + * + * @var bool + */ + var $skipConversion = false; + /* options */ + /** + * keep html tags which cannot be converted to markdown + * + * @var bool + */ + var $keepHTML = false; + /** + * wrap output, set to 0 to skip wrapping + * + * @var int + */ + var $bodyWidth = 0; + /** + * minimum body width + * + * @var int + */ + var $minBodyWidth = 25; + /** + * display links after each paragraph + * + * @var bool + */ + var $linksAfterEachParagraph = false; + /** + * constructor, set options, setup parser + * + * @param bool $linksAfterEachParagraph wether or not to flush stacked links after each paragraph + * defaults to false + * @param int $bodyWidth wether or not to wrap the output to the given width + * defaults to false + * @param bool $keepHTML wether to keep non markdownable HTML or to discard it + * defaults to true (HTML will be kept) + * @return void + */ + function Markdownify($linksAfterEachParagraph = MDFY_LINKS_EACH_PARAGRAPH, $bodyWidth = MDFY_BODYWIDTH, $keepHTML = MDFY_KEEPHTML) { + $this->linksAfterEachParagraph = $linksAfterEachParagraph; + $this->keepHTML = $keepHTML; + + if ($bodyWidth > $this->minBodyWidth) { + $this->bodyWidth = intval($bodyWidth); + } else { + $this->bodyWidth = false; + } + + $this->parser = new parseHTML; + $this->parser->noTagsInCode = true; + + # we don't have to do this every time + $search = array(); + $replace = array(); + foreach ($this->escapeInText as $s => $r) { + array_push($search, '#(?escapeInText = array( + 'search' => $search, + 'replace' => $replace + ); + } + /** + * parse a HTML string + * + * @param string $html + * @return string markdown formatted + */ + function parseString($html) { + $this->parser->html = $html; + $this->parse(); + return $this->output; + } + /** + * tags with elements which can be handled by markdown + * + * @var array + */ + var $isMarkdownable = array( + 'p' => array(), + 'ul' => array(), + 'ol' => array(), + 'li' => array(), + 'br' => array(), + 'blockquote' => array(), + 'code' => array(), + 'pre' => array(), + 'a' => array( + 'href' => 'required', + 'title' => 'optional', + ), + 'strong' => array(), + 'b' => array(), + 'em' => array(), + 'i' => array(), + 'img' => array( + 'src' => 'required', + 'alt' => 'optional', + 'title' => 'optional', + ), + 'h1' => array(), + 'h2' => array(), + 'h3' => array(), + 'h4' => array(), + 'h5' => array(), + 'h6' => array(), + 'hr' => array(), + ); + /** + * html tags to be ignored (contents will be parsed) + * + * @var array + */ + var $ignore = array( + 'html', + 'body', + ); + /** + * html tags to be dropped (contents will not be parsed!) + * + * @var array + */ + var $drop = array( + 'script', + 'head', + 'style', + 'form', + 'area', + 'object', + 'param', + 'iframe', + ); + /** + * Markdown indents which could be wrapped + * @note: use strings in regex format + * + * @var array + */ + var $wrappableIndents = array( + '\* ', # ul + '\d. ', # ol + '\d\d. ', # ol + '> ', # blockquote + '', # p + ); + /** + * list of chars which have to be escaped in normal text + * @note: use strings in regex format + * + * @var array + * + * TODO: what's with block chars / sequences at the beginning of a block? + */ + var $escapeInText = array( + '([-*_])([ ]{0,2}\1){2,}' => '\\\\$0|', # hr + '\*\*([^*\s]+)\*\*' => '\*\*$1\*\*', # strong + '\*([^*\s]+)\*' => '\*$1\*', # em + '__(?! |_)(.+)(?!<_| )__' => '\_\_$1\_\_', # em + '_(?! |_)(.+)(?!<_| )_' => '\_$1\_', # em + '`(.+)`' => '\`$1\`', # code + '\[(.+)\](\s*\()' => '\[$1\]$2', # links: [text] (url) => [text\] (url) + '\[(.+)\](\s*)\[(.*)\]' => '\[$1\]$2\[$3\]', # links: [text][id] => [text\][id\] + ); + /** + * wether last processed node was a block tag or not + * + * @var bool + */ + var $lastWasBlockTag = false; + /** + * name of last closed tag + * + * @var string + */ + var $lastClosedTag = ''; + /** + * iterate through the nodes and decide what we + * shall do with the current node + * + * @param void + * @return void + */ + function parse() { + $this->output = ''; + # drop tags + $this->parser->html = preg_replace('#<('.implode('|', $this->drop).')[^>]*>.*#sU', '', $this->parser->html); + while ($this->parser->nextNode()) { + switch ($this->parser->nodeType) { + case 'doctype': + break; + case 'pi': + case 'comment': + if ($this->keepHTML) { + $this->flushLinebreaks(); + $this->out($this->parser->node); + $this->setLineBreaks(2); + } + # else drop + break; + case 'text': + $this->handleText(); + break; + case 'tag': + if (in_array($this->parser->tagName, $this->ignore)) { + break; + } + if ($this->parser->isStartTag) { + $this->flushLinebreaks(); + } + if ($this->skipConversion) { + $this->isMarkdownable(); # update notConverted + $this->handleTagToText(); + continue; + } + if (!$this->parser->keepWhitespace && $this->parser->isBlockElement && $this->parser->isStartTag) { + $this->parser->html = ltrim($this->parser->html); + } + if ($this->isMarkdownable()) { + if ($this->parser->isBlockElement && $this->parser->isStartTag && !$this->lastWasBlockTag && !empty($this->output)) { + if (!empty($this->buffer)) { + $str =& $this->buffer[count($this->buffer) -1]; + } else { + $str =& $this->output; + } + if (substr($str, -strlen($this->indent)-1) != "\n".$this->indent) { + $str .= "\n".$this->indent; + } + } + $func = 'handleTag_'.$this->parser->tagName; + $this->$func(); + if ($this->linksAfterEachParagraph && $this->parser->isBlockElement && !$this->parser->isStartTag && empty($this->parser->openTags)) { + $this->flushStacked(); + } + if (!$this->parser->isStartTag) { + $this->lastClosedTag = $this->parser->tagName; + } + } else { + $this->handleTagToText(); + $this->lastClosedTag = ''; + } + break; + default: + trigger_error('invalid node type', E_USER_ERROR); + break; + } + $this->lastWasBlockTag = $this->parser->nodeType == 'tag' && $this->parser->isStartTag && $this->parser->isBlockElement; + } + if (!empty($this->buffer)) { + trigger_error('buffer was not flushed, this is a bug. please report!', E_USER_WARNING); + while (!empty($this->buffer)) { + $this->out($this->unbuffer()); + } + } + ### cleanup + $this->output = rtrim(str_replace('&', '&', str_replace('<', '<', str_replace('>', '>', $this->output)))); + # end parsing, flush stacked tags + $this->flushStacked(); + $this->stack = array(); + } + /** + * check if current tag can be converted to Markdown + * + * @param void + * @return bool + */ + function isMarkdownable() { + if (!isset($this->isMarkdownable[$this->parser->tagName])) { + # simply not markdownable + return false; + } + if ($this->parser->isStartTag) { + $return = true; + if ($this->keepHTML) { + $diff = array_diff(array_keys($this->parser->tagAttributes), array_keys($this->isMarkdownable[$this->parser->tagName])); + if (!empty($diff)) { + # non markdownable attributes given + $return = false; + } + } + if ($return) { + foreach ($this->isMarkdownable[$this->parser->tagName] as $attr => $type) { + if ($type == 'required' && !isset($this->parser->tagAttributes[$attr])) { + # required markdown attribute not given + $return = false; + break; + } + } + } + if (!$return) { + array_push($this->notConverted, $this->parser->tagName.'::'.implode('/', $this->parser->openTags)); + } + return $return; + } else { + if (!empty($this->notConverted) && end($this->notConverted) === $this->parser->tagName.'::'.implode('/', $this->parser->openTags)) { + array_pop($this->notConverted); + return false; + } + return true; + } + } + /** + * output all stacked tags + * + * @param void + * @return void + */ + function flushStacked() { + # links + foreach ($this->stack as $tag => $a) { + if (!empty($a)) { + call_user_func(array(&$this, 'flushStacked_'.$tag)); + } + } + } + /** + * output link references (e.g. [1]: http://example.com "title"); + * + * @param void + * @return void + */ + function flushStacked_a() { + $out = false; + foreach ($this->stack['a'] as $k => $tag) { + if (!isset($tag['unstacked'])) { + if (!$out) { + $out = true; + $this->out("\n\n", true); + } else { + $this->out("\n", true); + } + $this->out(' ['.$tag['linkID'].']: '.$tag['href'].(isset($tag['title']) ? ' "'.$tag['title'].'"' : ''), true); + $tag['unstacked'] = true; + $this->stack['a'][$k] = $tag; + } + } + } + /** + * flush enqued linebreaks + * + * @param void + * @return void + */ + function flushLinebreaks() { + if ($this->lineBreaks && !empty($this->output)) { + $this->out(str_repeat("\n".$this->indent, $this->lineBreaks), true); + } + $this->lineBreaks = 0; + } + /** + * handle non Markdownable tags + * + * @param void + * @return void + */ + function handleTagToText() { + if (!$this->keepHTML) { + if (!$this->parser->isStartTag && $this->parser->isBlockElement) { + $this->setLineBreaks(2); + } + } else { + # dont convert to markdown inside this tag + /** TODO: markdown extra **/ + if (!$this->parser->isEmptyTag) { + if ($this->parser->isStartTag) { + if (!$this->skipConversion) { + $this->skipConversion = $this->parser->tagName.'::'.implode('/', $this->parser->openTags); + } + } else { + if ($this->skipConversion == $this->parser->tagName.'::'.implode('/', $this->parser->openTags)) { + $this->skipConversion = false; + } + } + } + + if ($this->parser->isBlockElement) { + if ($this->parser->isStartTag) { + if (in_array($this->parent(), array('ins', 'del'))) { + # looks like ins or del are block elements now + $this->out("\n", true); + $this->indent(' '); + } + if ($this->parser->tagName != 'pre') { + $this->out($this->parser->node."\n".$this->indent); + if (!$this->parser->isEmptyTag) { + $this->indent(' '); + } else { + $this->setLineBreaks(1); + } + $this->parser->html = ltrim($this->parser->html); + } else { + # don't indent inside tags + $this->out($this->parser->node); + static $indent; + $indent = $this->indent; + $this->indent = ''; + } + } else { + if (!$this->parser->keepWhitespace) { + $this->output = rtrim($this->output); + } + if ($this->parser->tagName != 'pre') { + $this->indent(' '); + $this->out("\n".$this->indent.$this->parser->node); + } else { + # reset indentation + $this->out($this->parser->node); + static $indent; + $this->indent = $indent; + } + + if (in_array($this->parent(), array('ins', 'del'))) { + # ins or del was block element + $this->out("\n"); + $this->indent(' '); + } + if ($this->parser->tagName == 'li') { + $this->setLineBreaks(1); + } else { + $this->setLineBreaks(2); + } + } + } else { + $this->out($this->parser->node); + } + if (in_array($this->parser->tagName, array('code', 'pre'))) { + if ($this->parser->isStartTag) { + $this->buffer(); + } else { + # add stuff so cleanup just reverses this + $this->out(str_replace('<', '<', str_replace('>', '>', $this->unbuffer()))); + } + } + } + } + /** + * handle plain text + * + * @param void + * @return void + */ + function handleText() { + if ($this->hasParent('pre') && strpos($this->parser->node, "\n") !== false) { + $this->parser->node = str_replace("\n", "\n".$this->indent, $this->parser->node); + } + if (!$this->hasParent('code') && !$this->hasParent('pre')) { + # entity decode + $this->parser->node = $this->decode($this->parser->node); + if (!$this->skipConversion) { + # escape some chars in normal Text + $this->parser->node = preg_replace($this->escapeInText['search'], $this->escapeInText['replace'], $this->parser->node); + } + } else { + $this->parser->node = str_replace(array('"', '&apos'), array('"', '\''), $this->parser->node); + } + $this->out($this->parser->node); + $this->lastClosedTag = ''; + } + /** + * handle and tags + * + * @param void + * @return void + */ + function handleTag_em() { + $this->out('*', true); + } + function handleTag_i() { + $this->handleTag_em(); + } + /** + * handle and tags + * + * @param void + * @return void + */ + function handleTag_strong() { + $this->out('**', true); + } + function handleTag_b() { + $this->handleTag_strong(); + } + /** + * handletags + * + * @param void + * @return void + */ + function handleTag_h1() { + $this->handleHeader(1); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_h2() { + $this->handleHeader(2); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_h3() { + $this->handleHeader(3); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_h4() { + $this->handleHeader(4); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_h5() { + $this->handleHeader(5); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_h6() { + $this->handleHeader(6); + } + /** + * number of line breaks before next inline output + */ + var $lineBreaks = 0; + /** + * handle header tags (
-
) + * + * @param int $level 1-6 + * @return void + */ + function handleHeader($level) { + if ($this->parser->isStartTag) { + $this->out(str_repeat('#', $level).' ', true); + } else { + $this->setLineBreaks(2); + } + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_p() { + if (!$this->parser->isStartTag) { + $this->setLineBreaks(2); + } + } + /** + * handle tags + * + * @param void + * @return void + */ + function handleTag_a() { + if ($this->parser->isStartTag) { + $this->buffer(); + if (isset($this->parser->tagAttributes['title'])) { + $this->parser->tagAttributes['title'] = $this->decode($this->parser->tagAttributes['title']); + } else { + $this->parser->tagAttributes['title'] = null; + } + $this->parser->tagAttributes['href'] = $this->decode(trim($this->parser->tagAttributes['href'])); + $this->stack(); + } else { + $tag = $this->unstack(); + $buffer = $this->unbuffer(); + + if (empty($tag['href']) && empty($tag['title'])) { + # empty links... testcase mania, who would possibly do anything like that?! + $this->out('['.$buffer.']()', true); + return; + } + + if ($buffer == $tag['href'] && empty($tag['title'])) { + #
tags + * + * @param void + * @return void + */ + function handleTag_img() { + if (!$this->parser->isStartTag) { + return; # just to be sure this is really an empty tag... + } + + if (isset($this->parser->tagAttributes['title'])) { + $this->parser->tagAttributes['title'] = $this->decode($this->parser->tagAttributes['title']); + } else { + $this->parser->tagAttributes['title'] = null; + } + if (isset($this->parser->tagAttributes['alt'])) { + $this->parser->tagAttributes['alt'] = $this->decode($this->parser->tagAttributes['alt']); + } else { + $this->parser->tagAttributes['alt'] = null; + } + + if (empty($this->parser->tagAttributes['src'])) { + # support for "empty" images... dunno if this is really needed + # but there are some testcases which do that... + if (!empty($this->parser->tagAttributes['title'])) { + $this->parser->tagAttributes['title'] = ' '.$this->parser->tagAttributes['title'].' '; + } + $this->out('!['.$this->parser->tagAttributes['alt'].']('.$this->parser->tagAttributes['title'].')', true); + return; + } else { + $this->parser->tagAttributes['src'] = $this->decode($this->parser->tagAttributes['src']); + } + + # [This link][id] + $link_id = false; + if (!empty($this->stack['a'])) { + foreach ($this->stack['a'] as $tag) { + if ($tag['href'] == $this->parser->tagAttributes['src'] + && $tag['title'] === $this->parser->tagAttributes['title']) { + $link_id = $tag['linkID']; + break; + } + } + } else { + $this->stack['a'] = array(); + } + if (!$link_id) { + $link_id = count($this->stack['a']) + 1; + $tag = array( + 'href' => $this->parser->tagAttributes['src'], + 'linkID' => $link_id, + 'title' => $this->parser->tagAttributes['title'] + ); + array_push($this->stack['a'], $tag); + } + + $this->out('!['.$this->parser->tagAttributes['alt'].']['.$link_id.']', true); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_code() { + if ($this->hasParent('pre')) { + # ignore code blocks inside+ return; + } + if ($this->parser->isStartTag) { + $this->buffer(); + } else { + $buffer = $this->unbuffer(); + # use as many backticks as needed + preg_match_all('#`+#', $buffer, $matches); + if (!empty($matches[0])) { + rsort($matches[0]); + + $ticks = '`'; + while (true) { + if (!in_array($ticks, $matches[0])) { + break; + } + $ticks .= '`'; + } + } else { + $ticks = '`'; + } + if ($buffer[0] == '`' || substr($buffer, -1) == '`') { + $buffer = ' '.$buffer.' '; + } + $this->out($ticks.$buffer.$ticks, true); + } + } + /** + * handletags + * + * @param void + * @return void + */ + function handleTag_pre() { + if ($this->keepHTML && $this->parser->isStartTag) { + # check if a simplefollows + if (!preg_match('#^\s*tags + * + * @param void + * @return void + */ + function handleTag_blockquote() { + $this->indent('> '); + } + /** + * handle
- tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_ul() {
+ if ($this->parser->isStartTag) {
+ $this->stack();
+ if (!$this->keepHTML && $this->lastClosedTag == $this->parser->tagName) {
+ $this->out("\n".$this->indent.''."\n".$this->indent."\n".$this->indent);
+ }
+ } else {
+ $this->unstack();
+ if ($this->parent() != 'li' || preg_match('#^\s*(\s*
- tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_li() {
+ if ($this->parent() == 'ol') {
+ $parent =& $this->getStacked('ol');
+ if ($this->parser->isStartTag) {
+ $parent['num']++;
+ $this->out($parent['num'].'.'.str_repeat(' ', 3 - strlen($parent['num'])), true);
+ }
+ $this->indent(' ', false);
+ } else {
+ if ($this->parser->isStartTag) {
+ $this->out('* ', true);
+ }
+ $this->indent(' ', false);
+ }
+ if (!$this->parser->isStartTag) {
+ $this->setLineBreaks(1);
+ }
+ }
+ /**
+ * handle
tags + * + * @param void + * @return void + */ + function handleTag_hr() { + if (!$this->parser->isStartTag) { + return; # just to be sure this really is an empty tag + } + $this->out('* * *', true); + $this->setLineBreaks(2); + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_br() { + $this->out(" \n".$this->indent, true); + $this->parser->html = ltrim($this->parser->html); + } + /** + * node stack, e.g. for and tags + * + * @var array+ */ + var $stack = array(); + /** + * add current node to the stack + * this only stores the attributes + * + * @param void + * @return void + */ + function stack() { + if (!isset($this->stack[$this->parser->tagName])) { + $this->stack[$this->parser->tagName] = array(); + } + array_push($this->stack[$this->parser->tagName], $this->parser->tagAttributes); + } + /** + * remove current tag from stack + * + * @param void + * @return array + */ + function unstack() { + if (!isset($this->stack[$this->parser->tagName]) || !is_array($this->stack[$this->parser->tagName])) { + trigger_error('Trying to unstack from empty stack. This must not happen.', E_USER_ERROR); + } + return array_pop($this->stack[$this->parser->tagName]); + } + /** + * get last stacked element of type $tagName + * + * @param string $tagName + * @return array + */ + function & getStacked($tagName) { + // no end() so it can be referenced + return $this->stack[$tagName][count($this->stack[$tagName])-1]; + } + /** + * set number of line breaks before next start tag + * + * @param int $number + * @return void + */ + function setLineBreaks($number) { + if ($this->lineBreaks < $number) { + $this->lineBreaks = $number; + } + } + /** + * stores current buffers + * + * @var array + */ + var $buffer = array(); + /** + * buffer next parser output until unbuffer() is called + * + * @param void + * @return void + */ + function buffer() { + array_push($this->buffer, ''); + } + /** + * end current buffer and return buffered output + * + * @param void + * @return string + */ + function unbuffer() { + return array_pop($this->buffer); + } + /** + * append string to the correct var, either + * directly to $this->output or to the current + * buffers + * + * @param string $put + * @return void + */ + function out($put, $nowrap = false) { + if (empty($put)) { + return; + } + if (!empty($this->buffer)) { + $this->buffer[count($this->buffer) - 1] .= $put; + } else { + if ($this->bodyWidth && !$this->parser->keepWhitespace) { # wrap lines + // get last line + $pos = strrpos($this->output, "\n"); + if ($pos === false) { + $line = $this->output; + } else { + $line = substr($this->output, $pos); + } + + if ($nowrap) { + if ($put[0] != "\n" && $this->strlen($line) + $this->strlen($put) > $this->bodyWidth) { + $this->output .= "\n".$this->indent.$put; + } else { + $this->output .= $put; + } + return; + } else { + $put .= "\n"; # make sure we get all lines in the while below + $lineLen = $this->strlen($line); + while ($pos = strpos($put, "\n")) { + $putLine = substr($put, 0, $pos+1); + $put = substr($put, $pos+1); + $putLen = $this->strlen($putLine); + if ($lineLen + $putLen < $this->bodyWidth) { + $this->output .= $putLine; + $lineLen = $putLen; + } else { + $split = preg_split('#^(.{0,'.($this->bodyWidth - $lineLen).'})\b#', $putLine, 2, PREG_SPLIT_OFFSET_CAPTURE | PREG_SPLIT_DELIM_CAPTURE); + $this->output .= rtrim($split[1][0])."\n".$this->indent.$this->wordwrap(ltrim($split[2][0]), $this->bodyWidth, "\n".$this->indent, false); + } + } + $this->output = substr($this->output, 0, -1); + return; + } + } else { + $this->output .= $put; + } + } + } + /** + * current indentation + * + * @var string + */ + var $indent = ''; + /** + * indent next output (start tag) or unindent (end tag) + * + * @param string $str indentation + * @param bool $output add indendation to output + * @return void + */ + function indent($str, $output = true) { + if ($this->parser->isStartTag) { + $this->indent .= $str; + if ($output) { + $this->out($str, true); + } + } else { + $this->indent = substr($this->indent, 0, -strlen($str)); + } + } + /** + * decode email addresses + * + * @author derernst@gmx.ch -
) + * + * @param int $level 1-6 + * @return void + */ + function handleHeader($level) { + static $id = null; + if ($this->parser->isStartTag) { + if (isset($this->parser->tagAttributes['id'])) { + $id = $this->parser->tagAttributes['id']; + } + } else { + if (!is_null($id)) { + $this->out(' {#'.$id.'}'); + $id = null; + } + } + parent::handleHeader($level); + } + /** + * handle tags + * + * @param void + * @return void + */ + function handleTag_abbr() { + if ($this->parser->isStartTag) { + $this->stack(); + $this->buffer(); + } else { + $tag = $this->unstack(); + $tag['text'] = $this->unbuffer(); + $add = true; + foreach ($this->stack['abbr'] as $stacked) { + if ($stacked['text'] == $tag['text']) { + /** TODO: differing abbr definitions, i.e. different titles for same text **/ + $add = false; + break; + } + } + $this->out($tag['text']); + if ($add) { + array_push($this->stack['abbr'], $tag); + } + } + } + /** + * flush stacked abbr tags + * + * @param void + * @return void + */ + function flushStacked_abbr() { + $out = array(); + foreach ($this->stack['abbr'] as $k => $tag) { + if (!isset($tag['unstacked'])) { + array_push($out, ' *['.$tag['text'].']: '.$tag['title']); + $tag['unstacked'] = true; + $this->stack['abbr'][$k] = $tag; + } + } + if (!empty($out)) { + $this->out("\n\n".implode("\n", $out)); + } + } + /** + * handle
tags + * + * @param void + * @return void + */ + function handleTag_table() { + if ($this->parser->isStartTag) { + # check if upcoming table can be converted + if ($this->keepHTML) { + if (preg_match($this->tableLookaheadHeader, $this->parser->html, $matches)) { + # header seems good, now check body + # get align & number of cols + preg_match_all('#
tags + * + * @param void + * @return void + */ + function handleTag_tr() { + if ($this->parser->isStartTag) { + $this->col = -1; + } else { + $this->row++; + } + } + /** + * handle tags + * + * @param void + * @return void + */ + function handleTag_td() { + if ($this->parser->isStartTag) { + $this->col++; + if (!isset($this->table['col_widths'][$this->col])) { + $this->table['col_widths'][$this->col] = 0; + } + $this->buffer(); + } else { + $buffer = trim($this->unbuffer()); + $this->table['col_widths'][$this->col] = max($this->table['col_widths'][$this->col], $this->strlen($buffer)); + $this->table['rows'][$this->row][$this->col] = $buffer; + } + } + /** + * handle tags + * + * @param void + * @return void + */ + function handleTag_th() { + if (!$this->keepHTML && !isset($this->table['rows'][1]) && !isset($this->table['aligns'][$this->col+1])) { + if (isset($this->parser->tagAttributes['align'])) { + $this->table['aligns'][$this->col+1] = $this->parser->tagAttributes['align']; + } else { + $this->table['aligns'][$this->col+1] = ''; + } + } + $this->handleTag_td(); + } + /** + * handle - tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_dl() {
+ if (!$this->parser->isStartTag) {
+ $this->setLineBreaks(2);
+ }
+ }
+ /**
+ * handle
- tags + * + * @param void + * @return void + **/ + function handleTag_dt() { + if (!$this->parser->isStartTag) { + $this->setLineBreaks(1); + } + } + /** + * handle
- tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_dd() {
+ if ($this->parser->isStartTag) {
+ if (substr(ltrim($this->parser->html), 0, 3) == '
') { + # next comes a paragraph, so we'll need an extra line + $this->out("\n".$this->indent); + } elseif (substr($this->output, -2) == "\n\n") { + $this->output = substr($this->output, 0, -1); + } + $this->out(': '); + $this->indent(' ', false); + } else { + # lookahead for next dt + if (substr(ltrim($this->parser->html), 0, 4) == '
- ') {
+ $this->setLineBreaks(2);
+ } else {
+ $this->setLineBreaks(1);
+ }
+ $this->indent(' ');
+ }
+ }
+ /**
+ * handle
tags (custom footnote references, see markdownify_extra::parseString()) + * + * @param void + * @return void + */ + function handleTag_fnref() { + $this->out('[^'.$this->parser->tagAttributes['target'].']'); + } + /** + * handle tags (custom footnotes, see markdownify_extra::parseString() + * and markdownify_extra::_makeFootnotes()) + * + * @param void + * @return void + */ + function handleTag_fn() { + if ($this->parser->isStartTag) { + $this->out('[^'.$this->parser->tagAttributes['name'].']:'); + $this->setLineBreaks(1); + } else { + $this->setLineBreaks(2); + } + $this->indent(' '); + } + /** + * handle $1', $fns); + } +} \ No newline at end of file diff --git a/include/markdownify/parsehtml/parsehtml.php b/include/markdownify/parsehtml/parsehtml.php new file mode 100644 index 0000000000..1a8ecacda8 --- /dev/null +++ b/include/markdownify/parsehtml/parsehtml.php @@ -0,0 +1,618 @@ + etc.) + * + * @var arraytag (custom footnotes, see markdownify_extra::parseString() + * and markdownify_extra::_makeFootnotes()) + * + * @param void + * @return void + */ + function handleTag_footnotes() { + if (!$this->parser->isStartTag) { + $this->setLineBreaks(2); + } + } + /** + * parse a HTML string, clean up footnotes prior + * + * @param string $HTML input + * @return string Markdown formatted output + */ + function parseString($html) { + /** TODO: custom markdown-extra options, e.g. titles & classes **/ + # ... + # => + $html = preg_replace('@\s*\s*\d+\s*\s*@Us', ' ', $html); + # + #+ # => + #
+ #-
+ #
+ #
- ... + # ... + # + #
+ # + $html = preg_replace_callback('#... + # ... + #\s*#Us', array(&$this, '_makeFootnotes'), $html); + return parent::parseString($html); + } + /** + * replace HTML representation of footnotes with something more easily parsable + * + * @note this is a callback to be used in parseString() + * + * @param array $matches + * @return string + */ + function _makeFootnotes($matches) { + #
\s*- \s*(.+)\s*
- + # ... + # ↩ + #
+ # =>... + # remove footnote link + $fns = preg_replace('@\s*( \s*)?]*>↩\s*@s', '', $matches[1]); + # remove empty paragraph + $fns = preg_replace('@\s*
@s', '', $fns); + #- ...
->... + $fns = str_replace('- '; + return preg_replace('#
\s*(?=(?:+ */ + var $emptyTags = array( + 'br', + 'hr', + 'input', + 'img', + 'area', + 'link', + 'meta', + 'param', + ); + /** + * tags with preformatted text + * whitespaces wont be touched in them + * + * @var array + */ + var $preformattedTags = array( + 'script', + 'style', + 'pre', + 'code', + ); + /** + * supress HTML tags inside preformatted tags (see above) + * + * @var bool + */ + var $noTagsInCode = false; + /** + * html to be parsed + * + * @var string + */ + var $html = ''; + /** + * node type: + * + * - tag (see isStartTag) + * - text (includes cdata) + * - comment + * - doctype + * - pi (processing instruction) + * + * @var string + */ + var $nodeType = ''; + /** + * current node content, i.e. either a + * simple string (text node), or something like + * + * + * @var string + */ + var $node = ''; + /** + * wether current node is an opening tag () or not () + * set to NULL if current node is not a tag + * NOTE: empty tags (
) set this to true as well! + * + * @var bool | null + */ + var $isStartTag = null; + /** + * wether current node is an empty tag (
) or not () + * + * @var bool | null + */ + var $isEmptyTag = null; + /** + * tag name + * + * @var string | null + */ + var $tagName = ''; + /** + * attributes of current tag + * + * @var array (attribName=>value) | null + */ + var $tagAttributes = null; + /** + * wether the current tag is a block element + * + * @var bool | null + */ + var $isBlockElement = null; + + /** + * keep whitespace + * + * @var int + */ + var $keepWhitespace = 0; + /** + * list of open tags + * count this to get current depth + * + * @var array + */ + var $openTags = array(); + /** + * list of block elements + * + * @var array + * TODO: what shall we do withand ?! + */ + var $blockElements = array ( + # tag name =>is block + # block elements + 'address' => true, + 'blockquote' => true, + 'center' => true, + 'del' => true, + 'dir' => true, + 'div' => true, + 'dl' => true, + 'fieldset' => true, + 'form' => true, + 'h1' => true, + 'h2' => true, + 'h3' => true, + 'h4' => true, + 'h5' => true, + 'h6' => true, + 'hr' => true, + 'ins' => true, + 'isindex' => true, + 'menu' => true, + 'noframes' => true, + 'noscript' => true, + 'ol' => true, + 'p' => true, + 'pre' => true, + 'table' => true, + 'ul' => true, + # set table elements and list items to block as well + 'thead' => true, + 'tbody' => true, + 'tfoot' => true, + 'td' => true, + 'tr' => true, + 'th' => true, + 'li' => true, + 'dd' => true, + 'dt' => true, + # header items and html / body as well + 'html' => true, + 'body' => true, + 'head' => true, + 'meta' => true, + 'link' => true, + 'style' => true, + 'title' => true, + # unfancy media tags, when indented should be rendered as block + 'map' => true, + 'object' => true, + 'param' => true, + 'embed' => true, + 'area' => true, + # inline elements + 'a' => false, + 'abbr' => false, + 'acronym' => false, + 'applet' => false, + 'b' => false, + 'basefont' => false, + 'bdo' => false, + 'big' => false, + 'br' => false, + 'button' => false, + 'cite' => false, + 'code' => false, + 'del' => false, + 'dfn' => false, + 'em' => false, + 'font' => false, + 'i' => false, + 'img' => false, + 'ins' => false, + 'input' => false, + 'iframe' => false, + 'kbd' => false, + 'label' => false, + 'q' => false, + 'samp' => false, + 'script' => false, + 'select' => false, + 'small' => false, + 'span' => false, + 'strong' => false, + 'sub' => false, + 'sup' => false, + 'textarea' => false, + 'tt' => false, + 'var' => false, + ); + /** + * get next node, set $this->html prior! + * + * @param void + * @return bool + */ + function nextNode() { + if (empty($this->html)) { + # we are done with parsing the html string + return false; + } + static $skipWhitespace = true; + if ($this->isStartTag && !$this->isEmptyTag) { + array_push($this->openTags, $this->tagName); + if (in_array($this->tagName, $this->preformattedTags)) { + # dont truncate whitespaces for orcontents + $this->keepWhitespace++; + } + } + + if ($this->html[0] == '<') { + $token = substr($this->html, 0, 9); + if (substr($token, 0, 2) == 'html, '>'); + $this->setNode('pi', $pos + 1); + return true; + } + if (substr($token, 0, 4) == ''); + if ($pos === false) { + # could not find a closing -->, use next gt instead + # this is firefox' behaviour + $pos = strpos($this->html, '>') + 1; + } else { + $pos += 3; + } + $this->setNode('comment', $pos); + + $skipWhitespace = true; + return true; + } + if ($token == 'setNode('doctype', strpos($this->html, '>')+1); + + $skipWhitespace = true; + return true; + } + if ($token == 'html = substr($this->html, 9); + + $this->setNode('text', strpos($this->html, ']]>')+3); + + # remove trailing ]]> and trim + $this->node = substr($this->node, 0, -3); + $this->handleWhitespaces(); + + $skipWhitespace = true; + return true; + } + if ($this->parseTag()) { + # seems to be a tag + # handle whitespaces + if ($this->isBlockElement) { + $skipWhitespace = true; + } else { + $skipWhitespace = false; + } + return true; + } + } + if ($this->keepWhitespace) { + $skipWhitespace = false; + } + # when we get here it seems to be a text node + $pos = strpos($this->html, '<'); + if ($pos === false) { + $pos = strlen($this->html); + } + $this->setNode('text', $pos); + $this->handleWhitespaces(); + if ($skipWhitespace && $this->node == ' ') { + return $this->nextNode(); + } + $skipWhitespace = false; + return true; + } + /** + * parse tag, set tag name and attributes, see if it's a closing tag and so forth... + * + * @param void + * @return bool + */ + function parseTag() { + static $a_ord, $z_ord, $special_ords; + if (!isset($a_ord)) { + $a_ord = ord('a'); + $z_ord = ord('z'); + $special_ords = array( + ord(':'), // for xml:lang + ord('-'), // for http-equiv + ); + } + + $tagName = ''; + + $pos = 1; + $isStartTag = $this->html[$pos] != '/'; + if (!$isStartTag) { + $pos++; + } + # get tagName + while (isset($this->html[$pos])) { + $pos_ord = ord(strtolower($this->html[$pos])); + if (($pos_ord >= $a_ord && $pos_ord <= $z_ord) || (!empty($tagName) && is_numeric($this->html[$pos]))) { + $tagName .= $this->html[$pos]; + $pos++; + } else { + $pos--; + break; + } + } + + $tagName = strtolower($tagName); + if (empty($tagName) || !isset($this->blockElements[$tagName])) { + # something went wrong => invalid tag + $this->invalidTag(); + return false; + } + if ($this->noTagsInCode && end($this->openTags) == 'code' && !($tagName == 'code' && !$isStartTag)) { + # we supress all HTML tags inside code tags + $this->invalidTag(); + return false; + } + + # get tag attributes + /** TODO: in html 4 attributes do not need to be quoted **/ + $isEmptyTag = false; + $attributes = array(); + $currAttrib = ''; + while (isset($this->html[$pos+1])) { + $pos++; + # close tag + if ($this->html[$pos] == '>' || $this->html[$pos].$this->html[$pos+1] == '/>') { + if ($this->html[$pos] == '/') { + $isEmptyTag = true; + $pos++; + } + break; + } + + $pos_ord = ord(strtolower($this->html[$pos])); + if ( ($pos_ord >= $a_ord && $pos_ord <= $z_ord) || in_array($pos_ord, $special_ords)) { + # attribute name + $currAttrib .= $this->html[$pos]; + } elseif (in_array($this->html[$pos], array(' ', "\t", "\n"))) { + # drop whitespace + } elseif (in_array($this->html[$pos].$this->html[$pos+1], array('="', "='"))) { + # get attribute value + $pos++; + $await = $this->html[$pos]; # single or double quote + $pos++; + $value = ''; + while (isset($this->html[$pos]) && $this->html[$pos] != $await) { + $value .= $this->html[$pos]; + $pos++; + } + $attributes[$currAttrib] = $value; + $currAttrib = ''; + } else { + $this->invalidTag(); + return false; + } + } + if ($this->html[$pos] != '>') { + $this->invalidTag(); + return false; + } + + if (!empty($currAttrib)) { + # html 4 allows something like
- tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_ol() {
+ # same as above
+ $this->parser->tagAttributes['num'] = 0;
+ $this->handleTag_ul();
+ }
+ /**
+ * handle
- tags
+ *
+ * @param void
+ * @return void
+ */
+ function handleTag_li() {
+ if ($this->parent() == 'ol') {
+ $parent =& $this->getStacked('ol');
+ if ($this->parser->isStartTag) {
+ $parent['num']++;
+ $this->out($parent['num'].'.'.str_repeat(' ', 3 - strlen($parent['num'])), true);
+ }
+ $this->indent(' ', false);
+ } else {
+ if ($this->parser->isStartTag) {
+ $this->out('* ', true);
+ }
+ $this->indent(' ', false);
+ }
+ if (!$this->parser->isStartTag) {
+ $this->setLineBreaks(1);
+ }
+ }
+ /**
+ * handle