public function postLine($text, $preserveSpaces = FALSE)
{
if (!$preserveSpaces) {
$text = Texy\Regexp::replace($text, '# {2,}#', ' ');
}
return Texy\Regexp::replace($text, $this->pattern);
}
/**
* Callback for: {{...}}.
*
* @return Texy\HtmlElement|string|FALSE
*/
public function pattern(Texy\LineParser $parser, array $matches)
{
list(, $mContent) = $matches;
// [1] => ...
$cmd = trim($mContent);
if ($cmd === '') {
return FALSE;
}
$raw = NULL;
$args = [];
// function (arg, arg, ...) or function: arg, arg
if ($matches = Texy\Regexp::match($cmd, '#^([a-z_][a-z0-9_-]*)\\s*(?:\\(([^()]*)\\)|:(.*))$#iu')) {
$cmd = $matches[1];
$raw = isset($matches[3]) ? trim($matches[3]) : trim($matches[2]);
if ($raw !== '') {
$args = preg_split('#\\s*' . preg_quote($this->separator, '#') . '\\s*#u', $raw);
}
}
// Texy 1.x way
if ($this->handler) {
if (is_callable([$this->handler, $cmd])) {
array_unshift($args, $parser);
return call_user_func_array([$this->handler, $cmd], $args);
}
if (is_callable($this->handler)) {
return call_user_func_array($this->handler, [$parser, $cmd, $args, $raw]);
}
}
// Texy 2 way
return $this->texy->invokeAroundHandlers('script', $parser, [$cmd, $args, $raw]);
}
/**
* Text pre-processing.
* @return void
*/
public function beforeParse(Texy\Texy $texy, &$text)
{
self::$livelock = [];
// [la trine]: http://www.latrine.cz/ text odkazu .(title)[class]{style}
if (!empty($texy->allowed['link/definition'])) {
$text = Texy\Regexp::replace($text, '#^\\[([^\\[\\]\\#\\?\\*\\n]{1,100})\\]: ++(\\S{1,1000})(\\ .{1,1000})?' . Patterns::MODIFIER . '?\\s*()$#mUu', [$this, 'patternReferenceDef']);
}
}
/**
* Finish invocation.
* @return Texy\HtmlElement|FALSE
*/
public function solve(Texy\HandlerInvocation $invocation, $content, Texy\Modifier $mod = NULL)
{
$texy = $this->texy;
// find hard linebreaks
if ($texy->mergeLines) {
// ....
// ... => \r means break line
$content = Regexp::replace($content, '#\\n +(?=\\S)#', "\r");
} else {
$content = Regexp::replace($content, '#\\n#', "\r");
}
$el = new Texy\HtmlElement('p');
$el->parseLine($texy, $content);
$content = $el->getText();
// string
// check content type
// block contains block tag
if (strpos($content, $texy::CONTENT_BLOCK) !== FALSE) {
$el->setName(NULL);
// ignores modifier!
// block contains text (protected)
} elseif (strpos($content, $texy::CONTENT_TEXTUAL) !== FALSE) {
// leave element p
// block contains text
} elseif (preg_match('#[^\\s' . Texy\Patterns::MARK . ']#u', $content)) {
// leave element p
// block contains only replaced element
} elseif (strpos($content, $texy::CONTENT_REPLACED) !== FALSE) {
$el->setName($texy->nontextParagraph);
// block contains only markup tags or spaces or nothing
} else {
// if {ignoreEmptyStuff} return FALSE;
if (!$mod) {
$el->setName(NULL);
}
}
if ($el->getName()) {
// apply modifier
if ($mod) {
$mod->decorate($texy, $el);
}
// add <br />
if (strpos($content, "\r") !== FALSE) {
$key = $texy->protect('<br />', $texy::CONTENT_REPLACED);
$content = str_replace("\r", $key, $content);
}
}
$content = strtr($content, "\r\n", ' ');
$el->setText($content);
return $el;
}
/**
* Callback function: <tag> | </tag> | ....
* @return string
* @internal
*/
public function cb($matches)
{
// html tag
list(, $mText, $mComment, $mEnd, $mTag, $mAttr, $mEmpty) = $matches;
// [1] => text
// [1] => !-- comment --
// [2] => /
// [3] => TAG
// [4] => ... (attributes)
// [5] => / (empty)
$s = '';
// phase #1 - stuff between tags
if ($mText !== '') {
$item = reset($this->tagStack);
if ($item && !isset($item['dtdContent']['%DATA'])) {
// text not allowed?
} elseif (array_intersect(array_keys($this->tagUsed, TRUE), $this->preserveSpaces)) {
// inside pre & textarea preserve spaces
$s = Texy\Helpers::freezeSpaces($mText);
} else {
$s = Regexp::replace($mText, '#[ \\n]+#', ' ');
// otherwise shrink multiple spaces
}
}
// phase #2 - HTML comment
if ($mComment) {
return $s . '<' . Texy\Helpers::freezeSpaces($mComment) . '>';
}
// phase #3 - HTML tag
$mEmpty = $mEmpty || isset(HtmlElement::$emptyElements[$mTag]);
if ($mEmpty && $mEnd) {
return $s;
// bad tag; /end/
}
if ($mEnd) {
// end tag
// has start tag?
if (empty($this->tagUsed[$mTag])) {
return $s;
}
// autoclose tags
$tmp = [];
$back = TRUE;
foreach ($this->tagStack as $i => $item) {
$tag = $item['tag'];
$s .= $item['close'];
$this->space -= $item['indent'];
$this->tagUsed[$tag]--;
$back = $back && isset(HtmlElement::$inlineElements[$tag]);
unset($this->tagStack[$i]);
if ($tag === $mTag) {
break;
}
array_unshift($tmp, $item);
}
if (!$back || !$tmp) {
return $s;
}
// allowed-check (nejspis neni ani potreba)
$item = reset($this->tagStack);
$dtdContent = $item ? $item['dtdContent'] : $this->baseDTD;
if (!isset($dtdContent[$tmp[0]['tag']])) {
return $s;
}
// autoopen tags
foreach ($tmp as $item) {
$s .= $item['open'];
$this->space += $item['indent'];
$this->tagUsed[$item['tag']]++;
array_unshift($this->tagStack, $item);
}
} else {
// start tag
$dtdContent = $this->baseDTD;
if (!isset($this->texy->dtd[$mTag])) {
// unknown (non-html) tag
$allowed = TRUE;
$item = reset($this->tagStack);
if ($item) {
$dtdContent = $item['dtdContent'];
}
} else {
// optional end tag closing
foreach ($this->tagStack as $i => $item) {
// is tag allowed here?
$dtdContent = $item['dtdContent'];
if (isset($dtdContent[$mTag])) {
break;
}
$tag = $item['tag'];
// auto-close hidden, optional and inline tags
if ($item['close'] && (!isset(HtmlElement::$optionalEnds[$tag]) && !isset(HtmlElement::$inlineElements[$tag]))) {
break;
}
// close it
$s .= $item['close'];
$this->space -= $item['indent'];
$this->tagUsed[$tag]--;
unset($this->tagStack[$i]);
$dtdContent = $this->baseDTD;
}
// is tag allowed in this content?
$allowed = isset($dtdContent[$mTag]);
// check deep element prohibitions
if ($allowed && isset(HtmlElement::$prohibits[$mTag])) {
foreach (HtmlElement::$prohibits[$mTag] as $pTag) {
if (!empty($this->tagUsed[$pTag])) {
$allowed = FALSE;
break;
}
}
}
}
// empty elements se neukladaji do zasobniku
if ($mEmpty) {
if (!$allowed) {
return $s;
}
if ($this->xml) {
$mAttr .= ' /';
}
$indent = $this->indent && !array_intersect(array_keys($this->tagUsed, TRUE), $this->preserveSpaces);
if ($indent && $mTag === 'br') {
// formatting exception
return rtrim($s) . '<' . $mTag . $mAttr . ">\n" . str_repeat("\t", max(0, $this->space - 1)) . "";
} elseif ($indent && !isset(HtmlElement::$inlineElements[$mTag])) {
$space = "\r" . str_repeat("\t", $this->space);
return $s . $space . '<' . $mTag . $mAttr . '>' . $space;
} else {
return $s . '<' . $mTag . $mAttr . '>';
}
}
$open = NULL;
$close = NULL;
$indent = 0;
/*
if (!isset(Texy\HtmlElement::$inlineElements[$mTag])) {
// block tags always decorate with \n
$s .= "\n";
$close = "\n";
}
*/
if ($allowed) {
$open = '<' . $mTag . $mAttr . '>';
// receive new content (ins & del are special cases)
if (!empty($this->texy->dtd[$mTag][1])) {
$dtdContent = $this->texy->dtd[$mTag][1];
}
// format output
if ($this->indent && !isset(HtmlElement::$inlineElements[$mTag])) {
$close = "" . '</' . $mTag . '>' . "\n" . str_repeat("\t", $this->space);
$s .= "\n" . str_repeat("\t", $this->space++) . $open . "";
$indent = 1;
} else {
$close = '</' . $mTag . '>';
$s .= $open;
}
// TODO: problematic formatting of select / options, object / params
}
// open tag, put to stack, increase counter
$item = ['tag' => $mTag, 'open' => $open, 'close' => $close, 'dtdContent' => $dtdContent, 'indent' => $indent];
array_unshift($this->tagStack, $item);
$tmp =& $this->tagUsed[$mTag];
$tmp++;
}
return $s;
}
public function postLine($text)
{
return Texy\Regexp::replace($text, '#[^\\ \\n\\t\\x14\\x15\\x16\\x{2013}\\x{2014}\\x{ad}-]{' . $this->wordLimit . ',}#u', [$this, 'pattern']);
}
/**
* Parses image's syntax.
* @param string input: small.jpg 80x13 | small-over.jpg | linked.jpg
* @param string
* @param bool
* @return Image
*/
public function factoryImage($content, $mod, $tryRef = TRUE)
{
$image = $tryRef ? $this->getReference(trim($content)) : FALSE;
if (!$image) {
$texy = $this->texy;
$content = explode('|', $content);
$image = new Image();
// dimensions
$matches = NULL;
if ($matches = Texy\Regexp::match($content[0], '#^(.*) (\\d+|\\?) *(X|x) *(\\d+|\\?) *()$#U')) {
$image->URL = trim($matches[1]);
$image->asMax = $matches[3] === 'X';
$image->width = $matches[2] === '?' ? NULL : (int) $matches[2];
$image->height = $matches[4] === '?' ? NULL : (int) $matches[4];
} else {
$image->URL = trim($content[0]);
}
if (!$texy->checkURL($image->URL, $texy::FILTER_IMAGE)) {
$image->URL = NULL;
}
// onmouseover image
if (isset($content[1])) {
$tmp = trim($content[1]);
if ($tmp !== '' && $texy->checkURL($tmp, $texy::FILTER_IMAGE)) {
$image->overURL = $tmp;
}
}
// linked image
if (isset($content[2])) {
$tmp = trim($content[2]);
if ($tmp !== '' && $texy->checkURL($tmp, $texy::FILTER_ANCHOR)) {
$image->linkedURL = $tmp;
}
}
}
$image->modifier->setProperties($mod);
return $image;
}
/**
* Finish invocation.
* @return string
*/
public function solveComment(Texy\HandlerInvocation $invocation, $content)
{
if (!$this->passComment) {
return '';
}
// sanitize comment
$content = Texy\Regexp::replace($content, '#-{2,}#', ' - ');
$content = trim($content, '-');
return $this->texy->protect('<!--' . $content . '-->', Texy\Texy::CONTENT_MARKUP);
}
/**
* Single block pre-processing.
* @return void
*/
public function beforeBlockParse(Texy\BlockParser $parser, &$text)
{
// autoclose exclusive blocks
$text = Texy\Regexp::replace($text, '#^(/--++ *+(?!div|texysource).*)$((?:\\n.*+)*?)(?:\\n\\\\--.*$|(?=(\\n/--.*$)))#mi', "\$1\$2\n\\--");
}
/**
* Callback for:.
*
* .(title)[class]{style}>
* |------------------
* | xxx | xxx | xxx | .(..){..}[..]
* |------------------
* | aa | bb | cc |
*
* @return HtmlElement|string|FALSE
*/
public function patternTable(Texy\BlockParser $parser, array $matches)
{
if ($this->disableTables) {
return FALSE;
}
list(, $mMod) = $matches;
// [1] => .(title)[class]{style}<>_
$texy = $this->texy;
$el = new HtmlElement('table');
$mod = new Modifier($mMod);
$mod->decorate($texy, $el);
$parser->moveBackward();
if ($parser->next('#^\\|(\\#|\\=){2,}(?![|\\#=+])(.+)\\1*\\|? *' . Patterns::MODIFIER_H . '?()$#Um', $matches)) {
list(, , $mContent, $mMod) = $matches;
// [1] => # / =
// [2] => ....
// [3] => .(title)[class]{style}<>
$caption = $el->create('caption');
$mod = new Modifier($mMod);
$mod->decorate($texy, $caption);
$caption->parseLine($texy, $mContent);
}
$isHead = FALSE;
$colModifier = [];
$prevRow = [];
// rowSpan building helper
$rowCounter = 0;
$colCounter = 0;
$elPart = NULL;
$lineMode = FALSE;
// rows must be separated by lines
while (TRUE) {
if ($parser->next('#^\\|([=-])[+|=-]{2,}$#Um', $matches)) {
// line
if ($lineMode) {
if ($matches[1] === '=') {
$isHead = !$isHead;
}
} else {
$isHead = !$isHead;
$lineMode = $matches[1] === '=';
}
$prevRow = [];
continue;
}
if ($parser->next('#^\\|(.*)(?:|\\|\\ *' . Patterns::MODIFIER_HV . '?)()$#U', $matches)) {
// smarter head detection
if ($rowCounter === 0 && !$isHead && $parser->next('#^\\|[=-][+|=-]{2,}$#Um', $foo)) {
$isHead = TRUE;
$parser->moveBackward();
}
if ($elPart === NULL) {
$elPart = $el->create($isHead ? 'thead' : 'tbody');
} elseif (!$isHead && $elPart->getName() === 'thead') {
$this->finishPart($elPart);
$elPart = $el->create('tbody');
}
// PARSE ROW
list(, $mContent, $mMod) = $matches;
// [1] => ....
// [2] => .(title)[class]{style}<>_
$elRow = new HtmlElement('tr');
$mod = new Modifier($mMod);
$mod->decorate($texy, $elRow);
$rowClass = $rowCounter % 2 === 0 ? $this->oddClass : $this->evenClass;
if ($rowClass && !isset($mod->classes[$this->oddClass]) && !isset($mod->classes[$this->evenClass])) {
$elRow->attrs['class'][] = $rowClass;
}
$col = 0;
$elCell = NULL;
// special escape sequence \|
$mContent = str_replace('\\|', "", $mContent);
$mContent = Regexp::replace($mContent, '#(\\[[^\\]]*)\\|#', "\$1");
// HACK: support for [..|..]
foreach (explode('|', $mContent) as $cell) {
$cell = strtr($cell, "", '|');
// rowSpan
if (isset($prevRow[$col]) && ($lineMode || ($matches = Regexp::match($cell, '#\\^\\ *$|\\*??(.*)\\ +\\^$#AU')))) {
$prevRow[$col]->rowSpan++;
if (!$lineMode) {
$cell = isset($matches[1]) ? $matches[1] : '';
}
$prevRow[$col]->text .= "\n" . $cell;
$col += $prevRow[$col]->colSpan;
$elCell = NULL;
continue;
}
// colSpan
if ($cell === '' && $elCell) {
$elCell->colSpan++;
unset($prevRow[$col]);
$col++;
continue;
}
// common cell
$matches = Regexp::match($cell, '#(\\*??)\\ *' . Patterns::MODIFIER_HV . '??(.*)' . Patterns::MODIFIER_HV . '?\\ *()$#AU');
if (!$matches) {
continue;
}
list(, $mHead, $mModCol, $mContent, $mMod) = $matches;
// [1] => * ^
// [2] => .(title)[class]{style}<>_
// [3] => ....
// [4] => .(title)[class]{style}<>_
if ($mModCol) {
$colModifier[$col] = new Modifier($mModCol);
}
if (isset($colModifier[$col])) {
$mod = clone $colModifier[$col];
} else {
$mod = new Modifier();
}
$mod->setProperties($mMod);
$elCell = new TableCellElement();
$elCell->setName($isHead || $mHead === '*' ? 'th' : 'td');
$mod->decorate($texy, $elCell);
$elCell->text = $mContent;
$elRow->add($elCell);
$prevRow[$col] = $elCell;
$col++;
}
// even up with empty cells
while ($col < $colCounter) {
if (isset($prevRow[$col]) && $lineMode) {
$prevRow[$col]->rowSpan++;
$prevRow[$col]->text .= "\n";
} else {
$elCell = new TableCellElement();
$elCell->setName($isHead ? 'th' : 'td');
if (isset($colModifier[$col])) {
$colModifier[$col]->decorate($texy, $elCell);
}
$elRow->add($elCell);
$prevRow[$col] = $elCell;
}
$col++;
}
$colCounter = $col;
if ($elRow->count()) {
$elPart->add($elRow);
$rowCounter++;
} else {
// redundant row
foreach ($prevRow as $elCell) {
$elCell->rowSpan--;
}
}
continue;
}
break;
}
if ($elPart === NULL) {
// invalid table
return FALSE;
}
if ($elPart->getName() === 'thead') {
// thead is optional, tbody is required
$elPart->setName('tbody');
}
$this->finishPart($elPart);
// event listener
$texy->invokeHandlers('afterTable', [$parser, $el, $mod]);
return $el;
}