), the inline elements are closed
+ * up to and including the block element holding them. Only block elements that cannot hold block
+ * content are closed (CLOSABLE_ELEMENTS: , headings,
, ...); a container such as ,
+ *
or is left whole, and only inline elements inside it are closed. An element without attributes that would be
+ * left empty on either side is dropped rather than closed/reopened, as is a
directly before
+ * the shortcode.
+ *
+ * @param string $content
+ * @param string[] $tags shortcode tags configured with shortcode_close_parent
+ * @return string
+ */
+ private function closeParentElements(string $content, array $tags): string
+ {
+ $tagAlternation = implode('|', array_map(function ($tag) {
+ return preg_quote($tag, '%');
+ }, $tags));
+ # Most content has no block shortcode at all. One cheap search for any of the tags skips the
+ # tokenising below, which on a 3 MB page without one took ~45 MB of memory (5.1.0's single
+ # regex needed ~5 MB). The lookahead is the same tag ending as in the full pattern.
+ if (!preg_match('%\[(?:' . $tagAlternation . ')(?=[\s\],/])%i', $content)) {
+ return $content;
+ }
+ # One pass over comments, HTML tags and block shortcodes, in document order. A shortcode inside
+ # a tag's attribute is part of the tag match, so it is (rightly) never treated as an element.
+ # The tag name must end at whitespace, ']', '/' or ',' (ShortcodeParser's own tag regex accepts
+ # `[tag,attr=x]`), so [sc_block_other] is not [sc_block].
+ # Enclosed content (`[sc]...[/sc]`) is matched as in the original regex: no '[' inside it.
+ # Element names may contain hyphens (custom elements, eg ), so the name runs on to
+ # whitespace, '/' or '>' rather than to a word boundary, which would cut it at the hyphen.
+ # Two scans are bounded so the pass stays linear: an unterminated comment runs to the end of
+ # the content (as it does for an HTML parser), instead of every '|$))'
+ . '|(?[a-z][a-z0-9-]*)(?=[\s/>])(?:[^<>"\']++|"[^"<]*+"|\'[^\'<]*+\')*+>)'
+ . '|(?\[(?' . $tagAlternation . ')(?=[\s\],/])[^\]\[]*\](?:[^\[]*?\[/\k\])*)%is';
+ # Tokenise: text between the matches, plus each match with its kind. One match at a time
+ # (preg_match from an offset, not preg_match_all) and kept as three flat lists rather than an
+ # array per token: on large content the full match set and per-token arrays cost several
+ # hundred MB.
+ $kinds = $strings = $names = [];
+ $cursor = 0;
+ $length = strlen($content);
+ while ($cursor < $length && preg_match($pattern, $content, $match, PREG_OFFSET_CAPTURE, $cursor)) {
+ [$string, $offset] = $match[0];
+ if ($offset > $cursor) {
+ $kinds[] = 'text';
+ $strings[] = substr($content, $cursor, $offset - $cursor);
+ $names[] = null;
+ }
+ if (isset($match['sc']) && $match['sc'][1] !== -1) {
+ $kinds[] = 'sc';
+ $names[] = null;
+ } elseif (isset($match['tag']) && $match['tag'][1] !== -1) {
+ $kinds[] = 'tag';
+ $names[] = strtolower($match['name'][0]);
+ } else {
+ $kinds[] = 'text';
+ $names[] = null;
+ }
+ $strings[] = $string;
+ # An empty match cannot happen (every alternative starts with a literal), but never loop on one
+ $cursor = $offset + max(1, strlen($string));
+ }
+ if (!in_array('sc', $kinds, true)) {
+ # No block shortcode outside a tag or comment: nothing to do
+ return $content;
+ }
+ if ($cursor < $length) {
+ $kinds[] = 'text';
+ $strings[] = substr($content, $cursor);
+ $names[] = null;
+ }
+
+ # The output is collected as a list of parts, one per token or inserted tag, and joined once at
+ # the end. The clean-ups below only look at, or drop, the last few parts: working on the whole
+ # output string instead (a regex or rtrim() over it, per shortcode) made the walk quadratic.
+ $out = [];
+ # Open elements, outermost first: [name, original opening tag]
+ $stack = [];
+ # How many elements of each name are open, so a stray closing tag (none of that name open)
+ # is ignored without scanning the whole stack: that scan made many stray closers inside
+ # deep nesting quadratic
+ $openCounts = [];
+ $count = count($kinds);
+ for ($i = 0; $i < $count; $i++) {
+ $kind = $kinds[$i];
+ $string = $strings[$i];
+ $name = $names[$i];
+
+ if ($kind === 'tag') {
+ $out[] = $string;
+ $this->trackTag($stack, $openCounts, $string, $name);
+ continue;
+ }
+ if ($kind !== 'sc' || !$stack) {
+ # Text, comments, and a block shortcode with no wrapping element: nothing to close
+ $out[] = $string;
+ continue;
+ }
+
+ # The elements to close, innermost first, as [name, opening tag, stack index]: inline
+ # ancestors up to the first block one, and
+ # that block one only if it cannot hold block content (CLOSABLE_ELEMENTS). A container
+ # (, , , , ...) stops the walk without being closed: splitting it
+ # would break the list or table around it (issue #9).
+ # More than MAX_INLINE_DEPTH inline ancestors, or more than MAX_REOPEN_LENGTH bytes of inline
+ # opening tags to reopen: leave the shortcode in place (see there).
+ $chain = [];
+ $reopenLength = 0;
+ for ($s = count($stack) - 1; $s >= 0; $s--) {
+ if ($this->isInline($stack[$s][0])) {
+ if (count($chain) >= self::MAX_INLINE_DEPTH) {
+ $chain = [];
+ break;
+ }
+ # The reopened copy is about as long as the opening tag (minus an id/name)
+ $reopenLength += strlen($stack[$s][1]);
+ if ($reopenLength > self::MAX_REOPEN_LENGTH) {
+ $chain = [];
+ break;
+ }
+ $chain[] = [$stack[$s][0], $stack[$s][1], $s];
+ continue;
+ }
+ if (in_array($stack[$s][0], self::CLOSABLE_ELEMENTS)) {
+ $chain[] = [$stack[$s][0], $stack[$s][1], $s];
+ }
+ break;
+ }
+ if (!$chain) {
+ # Directly inside a container: nothing to close, so nothing to clean up either (a
+ # before the shortcode stays, as it does at the top level)
+ $out[] = $string;
+ continue;
+ }
+
+ #
[sc] -> [sc] (a line break right before block output only adds a blank line)
+ $last = $this->lastNonBlankPart($out);
+ if ($last !== null && preg_match('%^$%i', $out[$last])) {
+ $this->dropPartsFrom($out, $last);
+ }
+ foreach ($chain as [$elName, $openTag]) {
+ # [sc] -> [sc]: the element would be left empty, so drop its opening tag instead.
+ # Only a bare opening tag, as before: one with attributes (an id used as an anchor, a
+ # class) is closed and kept, even if empty. The whitespace after it goes too.
+ $last = $this->lastNonBlankPart($out);
+ if ($last !== null && preg_match('%^<[a-z0-9-]+\s*>$%i', $openTag)
+ && (strcasecmp($out[$last], $openTag) === 0 || $out[$last] === "<{$elName}>")
+ ) {
+ $this->dropPartsFrom($out, $last);
+ } else {
+ $out[] = "";
+ }
+ }
+ $out[] = $string;
+
+ # [sc] -> [sc]: closing tags directly after the shortcode (whitespace aside) are
+ # consumed instead of reopening an element that would be left empty
+ while ($chain) {
+ $next = $i + 1;
+ while ($next < $count && $kinds[$next] === 'text' && trim($strings[$next]) === '') {
+ $next++;
+ }
+ if ($next < $count && $kinds[$next] === 'tag' && $names[$next] === $chain[0][0]
+ && strpos($strings[$next], 'trackTag($stack, $openCounts, $strings[$next], $names[$next]);
+ array_shift($chain);
+ $i = $next;
+ continue;
+ }
+ break;
+ }
+
+ # Reopen what is still open, outermost first. The block element is reopened bare, as
+ # before (an id must not be duplicated); inline ones keep their attributes, so a link or
+ # a styled span carries on after the shortcode - minus their id (and a link's name
+ # anchor), which must stay unique.
+ # The stack entry takes the reopened tag, as that is what now stands open in the output:
+ # a second shortcode right after then sees a bare reopened and drops it instead of
+ # leaving an empty between the two (when the original had attributes).
+ foreach (array_reverse($chain) as [$elName, $openTag, $stackIndex]) {
+ $reopened = $this->isInline($elName) ? $this->withoutUniqueAttributes($openTag, $elName) : "<{$elName}>";
+ $stack[$stackIndex][1] = $reopened;
+ $out[] = $reopened;
+ }
+ }
+
+ return implode('', $out);
+ }
+
+ /**
+ * Drop the output parts from this index to the end. array_pop() rather than array_splice(),
+ * which rebuilds the whole array and so would make every clean-up cost the full output size.
+ *
+ * @param string[] $out
+ * @param int $from
+ */
+ private function dropPartsFrom(array &$out, int $from): void
+ {
+ while (count($out) > $from) {
+ array_pop($out);
+ }
+ }
+
+ /**
+ * Index of the last output part that is not whitespace-only text, or null if there is none.
+ * Parts are whole tokens, so a tag is always a part of its own.
+ *
+ * @param string[] $out
+ * @return int|null
+ */
+ private function lastNonBlankPart(array $out): ?int
+ {
+ for ($p = count($out) - 1; $p >= 0; $p--) {
+ if (trim($out[$p]) !== '') {
+ return $p;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * An opening tag without its id attribute, and without name on a link (an anchor target), so
+ * a reopened copy of the element does not repeat them.
+ */
+ private function withoutUniqueAttributes(string $openTag, string $name): string
+ {
+ $attributes = $name === 'a' ? 'id|name' : 'id';
+ # Walk the tag with the same quote-aware alternation as the tag match: a quoted value is
+ # consumed whole by the first alternative, so `id=` written inside another attribute's value
+ # (title=" id=1") is never seen as an attribute. Only a real id/name attribute matches the
+ # second alternative (whitespace before the name, so data-id or aria-name are left alone;
+ # quoted, bare or no value) and is dropped; everything else is put back unchanged.
+ // return preg_replace('%\s+(?:' . $attributes . ')\s*=\s*(?:"[^"]*"|\'[^\']*\'|[^\s>"\']+)%i', '', $openTag);
+ return preg_replace_callback(
+ '%"[^"]*+"|\'[^\']*+\'|(?\s+(?:' . $attributes . ')(?=[\s=/>])(?:\s*=\s*(?:"[^"]*+"|\'[^\']*+\'|[^\s>"\']++))?)%i',
+ function ($match) {
+ return isset($match['drop']) && $match['drop'] !== '' ? '' : $match[0];
},
- (string) $content
+ $openTag
);
}
+
+ /**
+ * Whether an element is inline (phrasing) content. Custom elements (a hyphen in the name) are
+ * phrasing content in HTML, so they count as inline too.
+ */
+ private function isInline(string $name): bool
+ {
+ return in_array($name, self::INLINE_ELEMENTS) || strpos($name, '-') !== false;
+ }
+
+ /**
+ * Update the open-element stack for one tag.
+ *
+ * @param array $stack open elements, outermost first: [name, original opening tag]
+ * @param int[] $openCounts number of open elements per name, kept in step with $stack
+ * @param string $tag the tag as written
+ * @param string $name its lowercased element name
+ */
+ private function trackTag(array &$stack, array &$openCounts, string $tag, string $name): void
+ {
+ if (strpos($tag, ' '), -1) === '/') {
+ # Void or self-closed: never open
+ return;
+ }
+ $stack[] = [$name, $tag];
+ $openCounts[$name] = ($openCounts[$name] ?? 0) + 1;
+ }
}
diff --git a/tests/ShortcodeParserExtensionTest.php b/tests/ShortcodeParserExtensionTest.php
index e2b32e2..26fdd3c 100644
--- a/tests/ShortcodeParserExtensionTest.php
+++ b/tests/ShortcodeParserExtensionTest.php
@@ -7,6 +7,7 @@
use Shortcodable\Tests\Stub\SimpleShortcode;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
+use SilverStripe\View\Parsers\HTMLValue;
use SilverStripe\View\Parsers\ShortcodeParser;
/**
@@ -61,6 +62,497 @@ public function testInlineShortcodeStaysInsideItsParentElement()
);
}
+ /**
+ * Issue #8: the element closed and reopened must be the shortcode's own wrapping element, whatever
+ * precedes or surrounds it. Each case is input => expected output ('B' stands for the block stub's
+ * rendered output). All cases run and every mismatch is reported together, so a failure shows the
+ * whole table rather than the first broken row (no @dataProvider: see the compatibility note).
+ *
+ * The comparison is structural: ShortcodeParser::parse() itself loads the content into a DOM
+ * (HTMLValue, an HTML5 parser that repairs misnested markup the way a browser does) and returns
+ * that DOM serialised, so the expected markup is put through the same parser. A wrong element
+ * closed by the extension shows up as a different tree (a stray , a block left inside
+ * a ), not as a formatting difference.
+ */
+ public function testCloseParentClosesTheShortcodesOwnWrappingElement()
+ {
+ $b = ' B ';
+ $cases = [
+ // The case from the issue: an earlier sibling block must not be taken as the parent
+ 'heading and paragraph before' => [
+ 'AddressStreet 1 [sc_block] ',
+ "AddressStreet 1 $b",
+ ],
+ 'heading before, text around' => [
+ 'TitleSome [sc_block] content ',
+ "TitleSome $b content ",
+ ],
+ 'sibling after' => [
+ 'Some [sc_block] content Next',
+ "Some $b content Next",
+ ],
+ 'siblings on separate lines' => [
+ "A\n[sc_block] \nafter ",
+ "A\n$b\nafter ",
+ ],
+ // Only the direct block parent is closed, not an outer container
+ 'nested in a div' => [
+ '',
+ "",
+ ],
+ 'heading as parent' => [
+ 'Title [sc_block]',
+ "Title $b",
+ ],
+ // Inline parents are closed up to and including the block element that holds them, and
+ // reopened with their own attributes so a link or class carries on after the shortcode
+ 'inside strong inside p' => [
+ 'Some bold [sc_block] text end ',
+ "Some bold $b text end ",
+ ],
+ 'inside a link inside p' => [
+ 'see [sc_block] here ',
+ "see $b here ",
+ ],
+ 'only child of strong inside p' => [
+ '[sc_block] ',
+ $b,
+ ],
+ 'first child of a paragraph with attributes' => [
+ '[sc_block] after ',
+ "$b after ",
+ ],
+ // Several block shortcodes in one parent: each one closes the (reopened) parent
+ 'two in one paragraph' => [
+ 'A [sc_block] B [sc_block] C ',
+ "A $b B $b C ",
+ ],
+ 'two adjacent' => [
+ '[sc_block][sc_block] ',
+ "$b$b",
+ ],
+ // The reopened parent is bare, so it is dropped between two shortcodes even when the
+ // original had attributes; an inline one keeps its attributes, so it stays
+ 'two adjacent in a paragraph with attributes' => [
+ 'A [sc_block][sc_block] B ',
+ "A $b$b B ",
+ ],
+ 'two with a space in a paragraph with attributes' => [
+ 'A [sc_block] [sc_block] B ',
+ "A $b$b B ",
+ ],
+ 'inline shortcode before a block one' => [
+ '[sc_simple] and [sc_block] ',
+ 'SIMPLE[] and ' . $b,
+ ],
+ // First/last child: no empty parent element may be left on that side
+ 'first child' => [
+ '[sc_block] content ',
+ "$b content ",
+ ],
+ 'last child' => [
+ 'Some [sc_block] ',
+ "Some $b",
+ ],
+ 'only child with whitespace around' => [
+ "\n[sc_block]\n ",
+ $b,
+ ],
+ // Void elements are never taken as the parent; a trailing
is dropped as before
+ 'br directly before' => [
+ 'Line
[sc_block] ',
+ "Line $b",
+ ],
+ 'self-closed br earlier in the paragraph' => [
+ 'Line
text [sc_block] end ',
+ "Line
text $b end ",
+ ],
+ 'img before in the same paragraph' => [
+ ' [sc_block] end
',
+ "![\"\"](\"/a.png\")
$b end ",
+ ],
+ 'hr sibling before' => [
+ '
[sc_block] ',
+ "
$b",
+ ],
+ 'comment containing a tag before' => [
+ '[sc_block] ',
+ "$b",
+ ],
+ 'uppercase tags' => [
+ 'Some [sc_block] x ',
+ "Some $b x ",
+ ],
+ 'enclosing shortcode with content' => [
+ 'Before [sc_block]inner[/sc_block] after ',
+ "Before $b after ",
+ ],
+ // A shortcode with no wrapping element has nothing to close
+ 'top level, between paragraphs' => [
+ 'Intro [sc_block]Outro ',
+ "Intro $bOutro ",
+ ],
+ // ShortcodeParser also accepts a comma between the tag and its attributes
+ 'comma-separated attributes' => [
+ 'Some [sc_block,id=1] x ',
+ "Some $b x ",
+ ],
+ // A custom element's name includes hyphens; custom elements are phrasing content, so
+ // they are closed like the inline elements, up to the block element holding them
+ 'custom element inside p' => [
+ 'x [sc_block] y ',
+ "x $b y ",
+ ],
+ // A reopened inline element must not repeat an id (or a link's name anchor)
+ 'link with id and name inside p' => [
+ 'see [sc_block] here ',
+ "see $b here ",
+ ],
+ 'span with id inside p' => [
+ "a [sc_block] b ",
+ "a $b b ",
+ ],
+ // Only real id/name attributes are dropped, not `id=` text inside another attribute's value
+ 'id= inside a quoted title' => [
+ 'x [sc_block] y ',
+ "x $b y ",
+ ],
+ 'id= at the end of a quoted title before href' => [
+ 'x [sc_block] y ',
+ "x $b y ",
+ ],
+ // Tags inside a comment are not elements
+ 'comment containing tags inside the parent' => [
+ 'a [sc_block] b ',
+ "a $b b ",
+ ],
+ // Only closing tags are consumed after the shortcode, never an opening tag
+ 'opening tag directly after' => [
+ '[sc_block]x ',
+ "$bx ",
+ ],
+ // Element names are compared case-insensitively
+ 'uppercase inline and block tags' => [
+ 'x b [sc_block] c y ',
+ "x b $b c y ",
+ ],
+ // A self-closed non-void element (XHTML style) does not open, so it is not the parent
+ 'self-closed span before' => [
+ 'a [sc_block] b ',
+ "a $b b ",
+ ],
+ // Without a wrapping element nothing is cleaned up either: the
stays
+ 'top level after a br' => [
+ 'Line
[sc_block]',
+ "Line
$b",
+ ],
+ // A stray closing tag (nothing open by that name) leaves the open elements alone
+ 'stray closing tag inside the parent' => [
+ 'a [sc_block] b ',
+ "a $b b ",
+ ],
+ 'opening tag of the same element directly after' => [
+ 'a [sc_block]x b ',
+ "a $bx b ",
+ ],
+ // A '>' inside a quoted attribute value does not end the tag, double or single quoted
+ 'link with > in a double-quoted title' => [
+ 'x [sc_block] y Next paragraph ',
+ "b\" href=\"/x\">x $bb\" href=\"/x\"> y Next paragraph ",
+ ],
+ 'link with > in a single-quoted title' => [
+ "x [sc_block] y Next ",
+ "b\" href=\"/x\">x $bb\" href=\"/x\"> y Next ",
+ ],
+ // A tag that merely starts with the block tag's name is another shortcode
+ 'other shortcode sharing the prefix' => [
+ 'Some [sc_block_other] x ',
+ 'Some [sc_block_other] x ',
+ ],
+ ];
+
+ $failures = [];
+ foreach ($cases as $label => [$input, $expected]) {
+ $actual = ShortcodeParser::get()->parse($input);
+ $expected = HTMLValue::create($expected)->getContent();
+ if ($actual !== $expected) {
+ $failures[] = sprintf("%s\n input: %s\n expected: %s\n actual: %s", $label, json_encode($input), json_encode($expected), json_encode($actual));
+ }
+ }
+ $this->assertSame([], $failures, count($failures) . ' of ' . count($cases) . " cases failed:\n" . implode("\n", $failures));
+ }
+
+ /**
+ * Issue #9, option (b): a block shortcode closes only block elements that cannot hold block
+ * content (p, h1-h6, pre, summary) plus inline ancestors. A container that can
+ * already hold block content (div, li, td, blockquote, section, ...) is left whole, on one line
+ * or several: splitting it would delete or break the list item, table cell or quote around it.
+ * Input => expected output, compared structurally as in the #8 table above.
+ */
+ public function testContainerParentsAreLeftWhole()
+ {
+ $b = 'B ';
+ $cases = [
+ // Containers, multi-line: 5.1.0 left these alone (it only looked within one line)
+ 'table cell, multi-line' => [
+ "",
+ "",
+ ],
+ 'list item, multi-line' => [
+ "",
+ "",
+ ],
+ 'blockquote, multi-line' => [
+ "\n[sc_block]\n ",
+ "\n$b\n ",
+ ],
+ 'section, multi-line' => [
+ "",
+ "",
+ ],
+ // Containers, one line: 5.1.0 closed these (and dropped the emptied element); now left whole
+ 'table cell, one line' => [
+ '',
+ "",
+ ],
+ 'list item, one line' => [
+ '',
+ "",
+ ],
+ 'div, one line' => [
+ '[sc_block] ',
+ "$b ",
+ ],
+ 'list item with text around' => [
+ '',
+ "",
+ ],
+ 'definition description' => [
+ '- T
- x [sc_block] y
',
+ "- T
- x $b y
",
+ ],
+ // address and dt take flow content (WHATWG), so they are containers too
+ 'address' => [
+ 'Street [sc_block] 1',
+ "Street $b 1",
+ ],
+ 'definition term' => [
+ '- Term [sc_block]
- x
',
+ "- Term $b
- x
",
+ ],
+ // A
before the shortcode stays when nothing is closed, as at the top level
+ 'br before, inside a div' => [
+ 'Line
[sc_block] ',
+ "Line
$b ",
+ ],
+ // Inline ancestors inside a container are still closed and reopened, the container is not
+ 'strong inside a list item' => [
+ '',
+ "",
+ ],
+ 'only child of a bare em inside a table cell' => [
+ '',
+ "",
+ ],
+ // An inline element with attributes is closed and kept even if left empty, as in a
+ 'only child of a link inside a table cell' => [
+ ' ',
+ "",
+ ],
+ // A closable element inside a container: only that element is closed
+ 'paragraph inside a list item' => [
+ '',
+ "",
+ ],
+ // The closable elements besides p and h1-h6 (those are in the #8 table): pre and summary
+ 'pre, multi-line' => [
+ "\nline\n[sc_block]\n ",
+ "\nline\n $b",
+ ],
+ 'h4' => [
+ 'Title [sc_block]',
+ "Title $b",
+ ],
+ 'summary' => [
+ 'S [sc_block]bodyS {$b}bodya [sc_block] b ', 60000),
+ str_repeat('a [sc_block] b ', 60000),
+ ],
+ // The
before each shortcode is dropped and the emptied after it consumed
+ '60000 after a line break' => [
+ str_repeat("a
\n [sc_block]\n ", 60000),
+ str_repeat('a [sc_block]', 60000),
+ ],
+ // An unterminated comment runs to the end, so the shortcode is inside it: unchanged
+ '20000 unterminated comments' => [
+ str_repeat(' | |